Stacktypes

Stacktypes is a term used in discussions of memory management and type systems to describe a category of value types whose instances are allocated on the call stack rather than the heap. In this usage, a stacktype's lifetime is bound to the activation record of the function or procedure that creates it, and it is automatically deallocated when that function returns.

Characteristics commonly associated with stacktypes include fast allocation and deallocation via stack pointer adjustment, locality of reference, and avoidance of garbage collection. However, their lifetimes are short and non-escaping by design: stacktypes cannot safely persist beyond the stack frame that created them, and storing them in data structures that outlive that frame is forbidden or requires indirection, such as boxing or handles. Large or recursive stack allocations can risk stack overflow, and cross-language or cross-thread sharing may require careful restrictions.

From a type-system perspective, stacktypes motivate lifetime or region checks, ownership or borrowing rules, and explicit annotations to prevent escaping or aliasing. Some language designs treat stacktypes as special, stack-only or region-bounded types, while others use general lifetime parametrics to enforce constraints.

Practical use cases include representing temporaries, function-local caches, or small value objects that do not need heap storage. They pose challenges for APIs that produce values for long-term use, concurrency, or data structures that live beyond a single frame.

Although stacktypes are discussed in theory, the term is not universally standardized; in many contexts related concepts are referred to as stack-allocated types, stack-allocated values, or region-based types. The concept intersects with stack allocation, lifetimes, region memory management, and RAII-style resource reclamation.