Dart 3 New Features — Sealed Classes, Pattern Matching, and Records
Dart 3 changed how we write Dart. Master the three flagship features with real examples.
Records: Return Multiple Values Type-Safely
// Before Dart 3: needed a Map or a dedicated class
Map<String, dynamic> getUser() => {'name': 'Alice', 'age': 30};
// Dart 3: Records are type-safe
(String name, int age) getUser() => ('Alice', 30);
// Named fields
({String name, int age}) getUserNamed() => (name: 'Alice', age: 30);
// Usage
final user = getUser();
print(user.$1); // 'Alice'
print(user.$2); // 30
final named = getUserNamed();
print(named.name); // 'Alice'
// Destructuring
final (name, age) = getUser();
print('$name is $age years old');
Patterns: Structural Matching
// switch expression (returns a value)
String describe(Object value) => switch (value) {
int n when n < 0 => 'negative',
int n when n == 0 => 'zero',
int _ => 'positive',
String s => 'string: $s',
_ => 'unknown',
};
// List pattern
final [first, second, ...rest] = [1, 2, 3, 4, 5];
print(first); // 1
print(rest); // [3, 4, 5]
// Map pattern
final {'name': String name, 'age': int age} = {'name': 'Bob', 'age': 25};
print('$name: $age');
// Object pattern
class Point { final double x, y; const Point(this.x, this.y); }
String describePoint(Point p) => switch (p) {
Point(x: 0, y: 0) => 'origin',
Point(x: var x, y: 0) => 'x-axis at $x',
Point(x: 0, y: var y) => 'y-axis at $y',
Point(x: var x, y: var y) => '($x, $y)',
};
Sealed Classes: Exhaustive Pattern Matching
// sealed class = subclassable only within the same library
sealed class Shape {}
class Circle extends Shape { final double radius; Circle(this.radius); }
class Rectangle extends Shape { final double w, h; Rectangle(this.w, this.h); }
class Triangle extends Shape { final double base, height; Triangle(this.base, this.height); }
// The compiler verifies exhaustiveness — no else needed
double area(Shape shape) => switch (shape) {
Circle(:final radius) => 3.14 * radius * radius,
Rectangle(:final w, :final h) => w * h,
Triangle(:final base, :final height) => base * height / 2,
};
// Forget Triangle → compile error (exhaustiveness check)
In Practice: Type-Safe API Response Modeling
sealed class ApiResult<T> {}
class Success<T> extends ApiResult<T> { final T data; Success(this.data); }
class Failure<T> extends ApiResult<T> { final String message; Failure(this.message); }
class Loading<T> extends ApiResult<T> {}
// Pattern-match in the UI
Widget buildWidget(ApiResult<User> result) => switch (result) {
Loading() => const CircularProgressIndicator(),
Success(:final data) => UserCard(user: data),
Failure(:final message) => ErrorText(message),
};
Summary
Records → type-safe multiple return values: (T1, T2) or ({name: T1, age: T2})
Patterns → switch expression returns a value / List, Map, Object patterns
Sealed → restrict inheritance + compile-time exhaustiveness / ideal for API state
Combining all three Dart 3 features catches the majority of runtime errors at compile time.