Episode 9: Exploring Dart: Generics

Season 2: Exploring Dart

Programming languages evolve, and with them, the tools and techniques they offer. One such powerful tool in modern languages is Generics. They might appear complicated at first glance, but once understood, they can significantly enhance your coding prowess. Let's dive deep into this topic and simplify the world of generics for you.

Why Use Generics?

The question that might be ringing in your mind is – why do we need generics? Here's why:

1. Type Safety: Generics ensure that you don't mix apples with oranges. It prevents type errors, ensuring that your lists, sets, or other collections only contain the type of items they're supposed to.

var names = <String>[];
names.addAll(['Seth', 'Kathy', 'Lars']);
names.add(42); // This will throw an error.

1. Here, the error occurs because we declared our list as List<String>, which means it's designed to contain only strings.

2. Better Code Generation: When the compiler knows the exact type you're working with, it can optimize the generated code, making your program faster and more efficient.

3. Reduce Code Duplication: Generics allow you to write a single implementation that works with multiple types. Instead of having separate classes or functions for different types, generics allow for flexibility without sacrificing type safety.

Using Collection Literals with Generics

In Dart, you can also specify the type directly when using collection literals.

var names = <String>['Seth', 'Kathy', 'Lars'];
var uniqueNames = <String>{'Seth', 'Kathy', 'Lars'};
var pages = <String, String>{
  'index.html': 'Homepage',
  'robots.txt': 'Hints for web robots',
  'humans.txt': 'We are people, not machines'
};

Parameterized Types with Constructors

Generics are not limited to collections. They can be used with constructors as well:

var nameSet = Set<String>.from(names);
var views = Map<int, View>();

Generics and Runtime

One of Dart's unique features is that its generics are reified. This means they retain their type information during runtime, allowing for more powerful runtime type checks.

var names = <String>[];
print(names is List<String>); // Outputs true

Unlike some other languages where generics lose their type at runtime, Dart retains this information, providing an additional layer of safety and flexibility.

Restricting the Parameterized Type

Generics are flexible, but there are times when you might want to restrict the kind of types a generic class or method can accept. Dart allows you to do this with the extends keyword.

class Foo<T extends Object> {
  // Only non-nullable types are allowed for T.
}

class Bar<T extends SomeBaseClass> {
  // T must be a subtype of SomeBaseClass or the class itself.
}

Using Generic Methods

Generics can also be used in methods. They allow a method to operate on different types without sacrificing type safety.

T first<T>(List<T> ts) {
  // Return the first element of the list ts.
}

With this function, you can retrieve the first element from a list, irrespective of the list's type.

Conclusion

Generics, with their angle brackets and type placeholders, can seem intimidating. However, they are a powerful tool designed to make your code safer, more readable, and less redundant. The next time you come across them in code, or the next time you find yourself writing the same function for different types, consider giving generics a try. It might just be the elegant solution you were looking for.