> ## 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 Type Parameter Bound A type parameter bound restricts the set of concrete types that can be substituted for a generic type parameter. By applying a bound, the Dart type system guarantees that any type argument provided at compile time is a subtype of the specified bounding type. This allows the compiler to safely resolve method and property lookups on instances of the generic type against the interface of the bound. In Dart, type bounds are declared using the `extends` keyword within the angle brackets `< >` of a generic class, mixin, interface, or method declaration. ```dart theme={"dark"} class GenericDeclaration { // Implementation } ``` ## Subtyping Rules and Compiler Behavior When a bound is established as ``, any type argument `X` supplied during instantiation must satisfy the subtyping relationship `X <: BoundingType`. If `X` is not a subtype of `BoundingType`, the Dart analyzer emits a compile-time error. Because the compiler enforces this constraint, instances of `T` within the generic scope are treated as instances of `BoundingType`. ```dart theme={"dark"} class Base { void baseMethod() {} } class Derived extends Base {} // T is constrained to Base or its subtypes class Container { final T instance; Container(this.instance); void invoke() { // The compiler allows this because T is guaranteed to extend Base instance.baseMethod(); } } // Valid: Derived <: Base Container validContainer = Container(Derived()); // Invalid: String is not a subtype of Base // Container invalidContainer = Container("text"); // Compile-time error ``` ## Implicit and Nullability Bounds If a generic type parameter is declared without an explicit bound (e.g., ``), Dart implicitly applies the top type `Object?` as the bound. This means the type parameter accepts any type, including nullable types. To explicitly restrict a type parameter to non-nullable types, the bound must be set to the non-nullable `Object`. ```dart theme={"dark"} // Implicitly class Unbounded { T? value; // T can be nullable (e.g., String?) } // Explicitly restricted to non-nullable types class NonNullableBound { T value; // T cannot be a nullable type (e.g., String? is invalid) NonNullableBound(this.value); } ``` ## F-Bounded Quantification (Recursive Bounds) Dart supports F-bounded polymorphism, allowing a type parameter to appear within its own bound. This is strictly used when the bounding type is itself a generic type that requires the implementing type as an argument. ```dart theme={"dark"} abstract class Equatable { bool isEquivalent(T other); } // T is constrained by a generic interface parameterized over T itself class Processor> { bool compare(T a, T b) { return a.isEquivalent(b); } } ``` ## Multiple Bounds Dart does not support intersection types for generic bounds (e.g., ``). A type parameter can only have a single explicit `extends` clause. To enforce multiple constraints, the bounding type itself must be a composite interface (an abstract class or mixin) that implements the required supertypes.

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