// 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');

// 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 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)

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),

};

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