boxing

I have some non-copyable type and a function that consumes and (maybe) produces it: type Foo = Vec<u8>; fn quux(_: Foo) -> Option<Foo> { Some(Vec::new()) } Now consider a type that is somehow conceptually very similar to Box : struct NotBox<T> { contents: T } We can write a function that temporarily moves out contents of the NotBox and puts something back in before returning it: fn bar(mut notbox: NotBox<Foo>) -> Option<NotBox<Foo>> { let foo = notbox.contents; // now `notbox` is "empty" match quux(foo) { Some(new_foo) => { notbox.contents = new_foo; // we put something back in Some(notbox) }

We have some code that archives data from a Microsoft Access database into a MS SQL Server database. Assuming we have a data reader already populated from the Access table and we are adding a parameter to a SqlCommand in preparation for the insert, we have a typecast that is failing. Here is the code: oSqlServerDbCmd_ForInsert.Parameters.AddWithValue("@Duration", (int) oReader["Duration"]); The field from the oReader is actually an Access Integer, which is a short in C#. If we cast to a short here there is no problem. However, if we cast to an int the code throws an InvalidCastException. I may

After reading this answer to "Vector of objects belonging to a trait" , it looks like Rust does automatic unboxing. Is this the case? My code doesn't compile and I don't understand how that answer's code could compile. What is the correct way to unbox the elements of a polymorphic vector, one containing boxed traits? I've read Rust by Example and the Box documentation and I can't see any method that looks like unbox() . My code is: trait HasArea { fn area(&self) -> f64; } struct Circle { x: f64, y: f64, radius: f64, } impl HasArea for Circle { fn area(&self) -> f64 { std::f64::consts::PI *

In Nullable micro-optimizations, part one , Eric mentions that Nullable<T> has a strange boxing behaviour that could not be achieved by a similar user-defined type. What are the special features that the C# language grants to the predefined Nullable<T> type? Especially the ones that could not be made to work on a MyNullable type. Of course, Nullable<T> has special syntactic sugar T? , but my question is more about semantics. Eric Lippert What I was getting at is: there is no such thing as a boxed nullable . When you box an int , you get a reference to a boxed int . When you box an int? , you

Boxed nullable underlying type can be cast to enum but boxed enum type can't be cast to nullable type. And similarly, Boxed nullable enum can be cast to underlying type but boxed underlying type can't be cast to nullable enum. Ok, I know "boxed nullable type" is not the best way to describe it, but it's for the sake of the question. I'm aware it's the underlying value type that's getting boxed. I will show it with examples. Assume I have an enum with int as the underlying type. enum Sex { Male, Female } Case I: int? i = 1; object o = i; Sex e = (Sex)o; //success //but Sex e = Sex.Male; object

Very simple question: int a = 5; string str = a.ToString(); Since ToString is a virtual method of System.Object, does it mean that everytime I call this method for integer types, a boxing occurs? You've already got answers telling you that when ToString() is overridden for a value type, there will be no boxing when you call it, but it's nice to have some way of actually seeing that. Take the type int? ( Nullable<int> ). This is a useful type because it is a value type, yet boxing may produce a null reference, and instance methods cannot be called through a null reference. It does have an