> ## 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. # Dart void `void` is a special type in Dart used to indicate that the value of an expression is completely discarded and cannot be used. It serves as a static type system constraint rather than a distinct runtime type, signaling to the compiler that a function's return value or a generic type argument is intentionally meaningless. ## Type System Behavior In Dart's sound type system, `void` is not a bottom type or a completely empty type. At runtime, `void` is equivalent to `Object?` (meaning it can technically hold any value, including `null`). However, at compile-time, the Dart analyzer strips away all access to the object's interface. * **Property/Method Access:** You cannot call methods or access properties on an expression of type `void`. * **Assignment:** You cannot assign a `void` expression to a variable, unless that variable is explicitly typed as `void`. Attempting to assign a `void` expression to `dynamic`, `var`, or any other type results in a compile-time error. ```dart theme={"dark"} void doSomething() {} void main() { // Static Error: This expression has type 'void' and can't be used. var result = doSomething(); // Static Error: This expression has type 'void' and can't be used. dynamic dynResult = doSomething(); // Allowed, but strictly limits further use of 'explicitVoid' void explicitVoid = doSomething(); } ``` ## Return Semantics When a function is declared with a `void` return type, Dart enforces specific rules depending on whether the function uses a block body (`{ ... }`) or an arrow body (`=>`). ### Block-Bodied Functions In a block-bodied `void` function, returning a concrete value or explicitly returning `null` violates Dart's strict return rules and results in a compile-time error. 1. **Implicit Return:** If no `return` statement is provided, the function implicitly returns `null` at runtime. 2. **Empty Return:** An empty `return;` statement is valid and halts execution. 3. **Returning Void:** You can return the result of another `void` expression. 4. **Strict Errors:** Explicitly returning `null` (`return null;`) or any concrete value (`return 5;`) is a static compilation error. ```dart theme={"dark"} void emptyReturn() { return; // Valid } void chainedVoid() { return emptyReturn(); // Valid: returning another void expression } void invalidNullReturn() { return null; // Static Error: A value of type 'Null' can't be returned from a void function. } void invalidValueReturn() { return "string"; // Static Error: A value of type 'String' can't be returned from a void function. } ``` ### Arrow Functions (`=>`) Unlike block-bodied functions, an arrow function with a `void` return type *can* evaluate an expression that results in a concrete value. The Dart compiler permits this syntax and implicitly discards the resulting value. This semantic exception exists primarily to facilitate concise callback implementations. ```dart theme={"dark"} int calculateValue() => 42; // Valid: The integer result of calculateValue() is evaluated but statically discarded. void arrowVoid() => calculateValue(); // Valid: Evaluates to 5, but the value is discarded by the compiler. void inlineArrow() => 5; ``` ## Generics and Parameterized Types `void` is frequently used as a type argument in generics to satisfy type signatures where a parameterized type is required, but the inner value must be ignored. The compiler enforces the same strict access rules on the generic type parameter. ```dart theme={"dark"} // The Future completes, but its resolved value cannot be utilized. Future asyncOperation() async { await Future.delayed(Duration(seconds: 1)); } // A generic class instantiated with void class Box { T? value; Box(this.value); } void genericExample() { Box voidBox = Box(null); // Static Error: This expression has type 'void' and can't be used. print(voidBox.value.toString()); } ``` ## `void` vs `Null` While a `void` function implicitly returns `null` at runtime, `void` and `Null` are distinct in the static type system. A variable of type `Null` can only ever hold the value `null`, but its value *can* be evaluated, assigned, and passed around. A `void` expression's value, regardless of what it is at runtime, is statically forbidden from being evaluated or consumed by the surrounding code.

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