> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift Void In Swift, `Void` is a type alias for an empty tuple, representing the absence of a specific value. Unlike C-family languages where `void` is a compiler keyword indicating "nothing," Swift's `Void` is a first-class type within the type system. In the Swift Standard Library, `Void` is explicitly defined as: ```swift theme={"dark"} public typealias Void = () ``` ## Type and Value Equivalence Because `Void` is merely an alias, the identifier `Void` (the type) and `()` (the empty tuple type) are strictly interchangeable. Furthermore, the only possible instance (value) of the `Void` type is the empty tuple value `()`. ```swift theme={"dark"} // Type declaration using Void let explicitVoid: Void = () // Type declaration using the empty tuple type let implicitVoid: () = () ``` ## Function Signatures When a function or closure does not explicitly declare a return type, the Swift compiler implicitly assigns it a return type of `Void`. The following three function declarations are semantically identical after type checking. However, because the Swift Abstract Syntax Tree (AST) preserves source fidelity, the syntactic differences (omitted return type vs. `-> Void` vs. `-> ()`) are represented by distinct type representation nodes in the AST: ```swift theme={"dark"} func executeOperationA() { } func executeOperationB() -> Void { } func executeOperationC() -> () { } ``` Similarly, if a function returns `Void`, the compiler implicitly inserts a `return ()` statement at the end of the function body. You can explicitly return the empty tuple value, though it is syntactically redundant: ```swift theme={"dark"} func terminate() -> Void { // Implicitly returns () return () } ``` ## Memory Layout Because `Void` contains no elements, instances of `Void` carry no data. Consequently, the Swift compiler optimizes `Void` to have a size of zero bytes. ```swift theme={"dark"} MemoryLayout.size // 0 bytes MemoryLayout.alignment // 1 byte MemoryLayout.stride // 1 byte ``` *Note: While the `size` is 0, the `stride` and `alignment` are 1. Swift requires all types to have a minimum stride of 1 byte so that distinct elements in a contiguous memory block (like an `Array`) have unique memory addresses.* ## Generics Integration Because `Void` is a standard type rather than a special keyword, it satisfies generic type constraints just like `Int`, `String`, or any custom `struct`. When a generic placeholder resolves to `Void`, the compiler substitutes the empty tuple type, and the generic type expects the empty tuple value `()`. ```swift theme={"dark"} // Void satisfying the generic type parameter 'Success' in Result let successState: Result = .success(()) // Void satisfying a generic parameter in a custom structure struct Container { let payload: T } let emptyContainer = Container(payload: ()) ```

Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More