Is it possible to declare a tuple struct whose members are private, except for initialization?

Question

Is it possible to declare a tuple struct where the members are hidden for all intents and purposes, except for declaring?

// usize isn't public since I don't want users to manipulate it directly
struct MyStruct(usize); 

// But now I can't initialize the struct using an argument to it.
let my_var = MyStruct(0xff)
//                    ^^^^
//                    How to make this work?

Is there a way to keep the member private but still allow new structs to be initialized with an argument as shown above?

As an alternative, a method such as MyStruct::new can be implemented, but I'm still interested to know if its possible to avoid having to use a method on the type since it's shorter, and nice for types that wrap a single variable.

---

Background

Without going into too many details, the only purpose of this type is to wrap a single type (a helper which hides some details, adds some functionality and is optimized away completely when compiled), in this context it's not exactly exposing hidden internals to use the Struct(value) style initializing. Further, since the wrapper is zero overhead, its a little misleading to use the new method which is often associated with allocation/creation instead of casting.

Just as it's convenient type (int)v or int(v), instead of int::new(v), I'd like to do this for my own type.

It's used often, so the ability to use short expression is very convenient. Currently I'm using a macro which calls a new method, its OK but a little awkward/indirect, hence this question.

Answer 1

Strictly speaking this isn't possible in Rust.

However the desired outcome can be achieved using a normal struct with a like-named function (yes, this works!)

pub struct MyStruct {
    value: usize,
}

#[allow(non_snake_case)]
pub fn MyStruct(value: usize) -> MyStruct {
    MyStruct { value }
}

Now, you can write MyStruct(5) but not access the internals of MyStruct.

Answer 2

I'm afraid that such a concept is not possible, but for a good reason. Each member of a struct, unless marked with pub, is admitted as an implementation detail that should not raise to the surface of the public API, regardless of when and how the object is currently being used. Under this point of view, the question's goal reaches a conundrum: wishing to keep members private while letting the API user define them arbitrarily is not only uncommon but also not very sensible.

As you mentioned, having a method named new is the recommended approach of doing that. It's not like you're compromising code readability with the extra characters you have to type. Alternatively, for the case where the struct is known to wrap around an item, making the member public can be a possible solution. That, on the other hand, would allow any kind of mutations through a mutable borrow (thus possibly breaking the struct's invariants, as mentioned by @MatthieuM). This decision depends on the intended API.