Generics in Dart — Type Safety Without the Repetition

Imagine we need a box that holds one item. We want type safety — the compiler should catch mistakes. So we write a box for each type.

class IntBox {
  final int value;
  IntBox(this.value);
}

class StringBox {
  final String value;
  StringBox(this.value);
}

class UserBox {
  final User value;
  UserBox(this.value);
}

class AnyBox {
  final dynamic value;
  AnyBox(this.value);
}

void main() {
  var box = AnyBox(42);
  String s = box.value;   // compiles fine, crashes at runtime
}

class Box<T> {
  final T value;
  Box(this.value);
}

void main() {
  var intBox = Box<int>(42);
  var stringBox = Box<String>('hello');

  int n = intBox.value;       // works
  String s = stringBox.value; // works
  String bad = intBox.value;  // compile error — caught before runtime
}

We've been using generics since Episode 6 — List<int>, Set<String>, Map<String, User>. Now let's see how they work under the hood.

A generic class declares one or more type parameters in angle brackets after the class name.

class Pair<A, B> {
  final A first;
  final B second;

  Pair(this.first, this.second);

  @override
  String toString() => '($first, $second)';
}

void main() {
  var coords = Pair<int, int>(10, 20);
  var entry = Pair<String, double>('price', 9.99);

  print(coords);  // (10, 20)
  print(entry);   // (price, 9.99)
}

// A simple cache with generic key and value types
class Cache<K, V> {
  final Map<K, V> _store = {};

  V? get(K key) => _store[key];

  void put(K key, V value) {
    _store[key] = value;
  }

  void clear() => _store.clear();
}

void main() {
  var userCache = Cache<int, User>();
  userCache.put(1, User('Alice'));

  var configCache = Cache<String, String>();
  configCache.put('theme', 'dark');
}

Methods and standalone functions can have their own type parameters, independent of any class.

T first<T>(List<T> items) {
  if (items.isEmpty) throw StateError('Empty list');
  return items[0];
}

void main() {
  var numbers = [1, 2, 3];
  var strings = ['a', 'b', 'c'];

  int n = first(numbers);     // T is int
  String s = first(strings);  // T is String
}

class Transformer<T> {
  final T value;
  Transformer(this.value);

  // R is a new type parameter, specific to this method
  R transform<R>(R Function(T) mapper) {
    return mapper(value);
  }
}

void main() {
  var t = Transformer<int>(42);

  String s = t.transform((n) => n.toString());  // R = String
  double d = t.transform((n) => n * 1.5);       // R = double
}

Sometimes we need more than "any type." We need a type that supports specific operations. That's where bounds come in.

// This won't work — T might not have compareTo
T findMax<T>(List<T> items) {
  var max = items[0];
  for (var item in items) {
    if (item.compareTo(max) > 0) max = item;  // error!
  }
  return max;
}

T findMax<T extends Comparable<T>>(List<T> items) {
  var max = items[0];
  for (var item in items) {
    if (item.compareTo(max) > 0) max = item;  // works!
  }
  return max;
}

void main() {
  print(findMax([3, 1, 4, 1, 5]));   // 5
  print(findMax(['banana', 'apple', 'cherry']));  // cherry
}

// Must be a number
T sum<T extends num>(List<T> values) {
  return values.reduce((a, b) => (a + b) as T);
}

// Must have a toJson method (via interface)
void save<T extends Serializable>(T item) {
  var json = item.toJson();
  // ...
}

// Multiple type parameters, each with bounds
class Repository<K extends Object, V extends Entity> {
  V? findById(K id) { ... }
}

Here's a puzzle. Dog extends Animal. We can pass a Dog where an Animal is expected. But what about List<Dog> and List<Animal>?

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

void printAnimals(List<Animal> animals) {
  for (var a in animals) print(a);
}

void main() {
  var dogs = <Dog>[Dog(), Dog()];
  printAnimals(dogs);   // Does this work?
}

void addCat(List<Animal> animals) {
  animals.add(Cat());   // adding a Cat to a list of Animals
}

void main() {
  var dogs = <Dog>[Dog(), Dog()];
  addCat(dogs);   // passes a List<Dog> as List<Animal>
  // Now dogs contains a Cat — type safety broken?
}

We don't always have to write out type arguments. Dart's type inference is smart enough to figure them out from context.

// Explicit type arguments
var explicit = <int>[1, 2, 3];
var explicitMap = <String, int>{'a': 1, 'b': 2};

// Inferred from the elements
var inferred = [1, 2, 3];           // List<int>
var inferredMap = {'a': 1, 'b': 2}; // Map<String, int>

// Inferred from the variable type
List<int> numbers = [];   // empty List<int>, not List<dynamic>

T first<T>(List<T> items) => items[0];

var numbers = [1, 2, 3];
var n = first(numbers);   // T inferred as int, n is int

// Explicit when needed
var x = first<num>([1, 2, 3]);  // force T to be num

// Ambiguous — what type is this empty list?
var items = [];   // List<dynamic> — probably not what we want

// Help Dart out
var items = <String>[];    // List<String>
List<String> items = [];   // same result

// Complex chains might need hints
var result = things
    .map((t) => t.name)
    .where((n) => n.isNotEmpty)
    .toList();
// Usually fine, but if 'things' has an unclear type, add hints

Here's something that surprises developers from Java or TypeScript. In Dart, generic types are reified — they exist at runtime, not just compile time.

void main() {
  var numbers = <int>[1, 2, 3];
  var strings = <String>['a', 'b', 'c'];

  print(numbers is List<int>);      // true
  print(numbers is List<String>);   // false
  print(strings is List<String>);   // true
  print(strings is List<int>);      // false
}

// Runtime type dispatch
void process(Object data) {
  if (data is List<int>) {
    print('Sum: ${data.reduce((a, b) => a + b)}');
  } else if (data is List<String>) {
    print('Joined: ${data.join(', ')}');
  } else if (data is Map<String, dynamic>) {
    print('Keys: ${data.keys}');
  }
}

// Getting the runtime type
var items = <String>['a', 'b'];
print(items.runtimeType);   // List<String>