unboxed

Unboxed refers to values that are not wrapped in a heap‑allocated container or reference type, allowing them to be represented directly within a machine word or a primitive storage location. The term is most commonly used in statically typed, compiled languages such as C#, Java, Haskell, and Rust, where a distinction exists between value types and reference types.

In many managed runtimes, “boxing” is the process of taking a value‑type value (such as an integer or struct) and placing it inside an object allocated on the heap. This allows the value to be treated polymorphically, for example by storing it in a variable of type Object or as an element of a heterogeneous collection. “Unboxing” is the reverse operation: extracting the original value from its boxed wrapper. Unboxing is typically a checked operation; in C# the explicit cast operator performs unboxing, throwing an InvalidCastException if the runtime type does not match.

Benefits of keeping data boxed are flexibility and uniform treatment of all values as objects, which simplifies runtime type handling and garbage collection. However, unnecessary boxing incurs overhead: memory allocation, increased indirection, and potential cache misses. Unboxed values eliminate this overhead by keeping data in registers or stack slots, improving speed for high‑performance code.

Several languages provide native support for unboxed primitives. In Java, the wrapper classes (Integer, Double, etc.) are boxed types, while the primitive types (int, double) are unboxed. In C#, value types (struct, int, bool) are unboxed, while reference types (class, string) are boxed when cast to Object. Haskell’s "unboxed" types, denoted with !U or !#, are stored in a raw memory representation to increase performance in arrays and tight loops. Rust allows “unboxing” by using non‑`Box<T>` types directly; manual `Box::new` allocation boxes a value while `box` or `box.into_inner()` unboxes it.

In performance‑critical sections, developers often explicitly avoid boxing by using generic parameters with constraints, value‑type only collections, or compiler intrinsics that generate unboxed code. Modern compilers increasingly optimise away unnecessary boxing, but understanding the distinction remains important for writing efficient low‑level code.