Dart Generic Method

A generic method in Dart is a function or method that declares one or more formal type parameters. These type parameters allow the method to operate on abstract types while enforcing strict compile-time type safety, deferring concrete type resolution until the method is invoked.

Syntax and Scope

Type parameters are enclosed in angle brackets (<...>) and positioned immediately after the method name, preceding the parameter list.

void methodName<T>(T parameter) {
  // Method body
}

Once declared, the type parameter (T) enters the method’s lexical scope and can be utilized in several distinct contexts:

Return type: Defining the type of the value returned by the method.
Parameter types: Defining the types of the arguments accepted by the method.
Local variables: Defining the types of variables declared within the method body.
Type tests and casts: Utilizing the type parameter in is and as expressions (e.g., value is T, value as T).
Type arguments for generics: Passing the type parameter to other generic classes, collections, or methods (e.g., List<T>).

T processItem<T>(T item, dynamic unknownValue) {
  if (unknownValue is T) {                  // Type test
    T localVariable = unknownValue;         // Local variable
    List<T> list = [item, localVariable];   // Type argument for collection
    return list.last;                       // Return type
  }
  return unknownValue as T;                 // Type cast
}

Multiple Type Parameters

A generic method can declare multiple type parameters by separating them with commas. Each parameter operates independently within the method’s scope.

Map<K, V> pairItems<K, V>(K key, V value) {
  return {key: value};
}

Type Bounds (Constraints)

By default, a type parameter accepts any Dart object (equivalent to <T extends Object?>). To restrict the acceptable types, Dart uses the extends keyword to establish an upper bound. The generic method will only accept types that are subtypes of the specified bound.

// T is constrained to num or its subtypes (int, double)
T getLarger<T extends num>(T a, T b) {
  return a > b ? a : b; 
}

Invocation and Type Inference

When invoking a generic method, concrete types can be passed explicitly within angle brackets at the call site.

// Explicit type declaration
getLarger<int>(10, 20);

However, the Dart analyzer employs type inference. If the type arguments are omitted, the compiler infers the concrete type based on the static types of the provided arguments or the expected return context.

// Implicit type inference (T is inferred as double based on the arguments)
getLarger(10.5, 20.5);

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

Methods

Constructors

Classes

Getters & Setters

Variables

Fields

Parameters

Pattern Matching

Generics

Extensions

Type Aliases

Enums

Control Flow

Loops

Error Handling

Standard Library Types

Annotations

Libraries & Imports

Built-In Types

Comments

Cascade Operators

Spread Operators

Access Operators

Type Cast & Test Operators

Conditional Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Increment & Decrement Operators

Unary Operators

Bitwise Operators

Assignment Operators

Dart Generic Method

Syntax and Scope

Multiple Type Parameters

Type Bounds (Constraints)

Invocation and Type Inference

​Syntax and Scope

​Multiple Type Parameters

​Type Bounds (Constraints)

​Invocation and Type Inference

Syntax and Scope

Multiple Type Parameters

Type Bounds (Constraints)

Invocation and Type Inference