Freezed ❄ – Data Class & Union in One Dart Package

dependencies:
  json_annotation: ^3.0.1
  meta: ^1.1.8

dev_dependencies:
  build_runner:
  freezed: ^0.1.3+1
  json_serializable: ^3.2.5

data class User(val name: String, val age: Int)

@immutable
class User {
  final String name;
  final int age;

  User(this.name, this.age);

  User copyWith({
    String name,
    int age,
  }) {
    return User(
      name ?? this.name,
      age ?? this.age,
    );
  }

  @override
  bool operator ==(Object o) {
    if (identical(this, o)) return true;

    return o is User && o.name == name && o.age == age;
  }

  @override
  int get hashCode => name.hashCode ^ age.hashCode;
}

import 'package:meta/meta.dart';

part 'freezed_classes.freezed.dart';

@immutable
abstract class User with _$User {
  const factory User(String name, int age) = _User;
}

flutter pub run build_runner watch --delete-conflicting-outputs

void main() {
  final user = User('Matt', 20);
  // user.age = 5; // error, User is immutable
  final user2 = user.copyWith(name: 'John');

  final sameValueUser1 = User('abc', 123);
  final sameValueUser2 = User('abc', 123);
  print(sameValueUser1 == sameValueUser2); // true

  print(user); // User(name: Matt, age: 20)
}

@immutable
abstract class User with _$User {
  const factory User(String name, {int age}) = _User;
}

import 'package:json_annotation/json_annotation.dart';
import 'package:meta/meta.dart';

part 'freezed_classes.freezed.dart';
part 'freezed_classes.g.dart';

@immutable
abstract class User with _$User {
  const factory User(String name, int age) = _User;
  factory User.fromJson(Map<String, dynamic> json) => _$UserFromJson(json);
}

void main() {
  final user = User('Matt', 20);
  final Map<String, dynamic> serialized = user.toJson();
  final User deserialized = User.fromJson(serialized);
}

// Nest classes to access them only as Operation.Add or Operation.Subtract
sealed class Operation {
  class Add(val value: Int) : Operation()
  class Substract(val value: Int) : Operation()
}

// Don't nest classes if you want to instantiate Add or Subtract directly
sealed class Operation
class Add(val value: Int) : Operation()
class Substract(val value: Int) : Operation()

fun main() {
  ...
  // exhaustive "switch", notifies you if you forget to handle a case
  when(operation) {
    is Add -> //do something
    is Subtract -> // do something
  }
}

@immutable
abstract class OperationNested with _$OperationNested {
  // "Nested" unions have private generated classes (underscore)
  const factory OperationNested.add(int value) = _Add;
  const factory OperationNested.subtract(int value) = _Subtract;
}

void main() {
  final result = performOperation(2, OperationNested.add(2));
  print(result); // 4
}

// Function pretending to do something useful
int performOperation(int operand, OperationNested operation) {
  // Like switch statement but forgetting about a case will result in info/error
  return operation.when(
    add: (value) => operand + value,
    subtract: (value) => operand - value,
  );
}

@immutable
abstract class OperationNonNested with _$OperationNonNested {
  // "Non-nested" unions have public generated classes (no underscore)
  const factory OperationNonNested.add(int value) = Add;
  const factory OperationNonNested.subtract(int value) = Subtract;
}

void main() {
  // Still possible to use the factory
  final result1 = performOperation(2, OperationNonNested.add(2));
  // But non-nested union cases can also be instantiated directly
  final result2 = performOperation(2, Add(2));

  print(result1); // 4
  print(result2); // 4
}

int performOperation(int operand, OperationNonNested operation) {
  // When method still works even with cases instantiated directly
  return operation.when(
    add: (value) => operand + value,
    subtract: (value) => operand - value,
  );
}

return operation.maybeWhen(
  add: (value) => operand + value,
  // ignoring subtract
  orElse: () => -1,
);

int performOperation(int operand, OperationNonNested operation) {
  return operation.map(
    add: (Add caseClass) => operand + caseClass.value,
    subtract: (Subtract caseClass) => operand - caseClass.value,
  );
}

{
  ...
  "Part statement": {
    "prefix": "pts",
    "body": [
      "part '${TM_FILENAME_BASE}.g.dart';",
    ],
    "description": "Creates a filled-in part statement"
  },
  "Part 'Freezed' statement": {
    "prefix": "ptf",
    "body": [
      "part '${TM_FILENAME_BASE}.freezed.dart';",
    ],
    "description": "Creates a filled-in freezed part statement"
  },
  "Freezed Data Class": {
    "prefix": "fdataclass",
    "body": [
      "@immutable",
      "abstract class ${1:DataClass} with _$${1:DataClass}{",
      "  const factory ${1:DataClass}(${2}) = _${1:DataClass};",
      "}"
    ],
    "description": "Freezed Data Class"
  },
  "Freezed Union": {
    "prefix": "funion",
    "body": [
      "@immutable",
      "abstract class ${1:Union} with _$${1:Union}{",
      "  const factory ${1:Union}.${2}(${4}) = ${3};",
      "}"
    ],
    "description": "Freezed Union"
  },
  "Freezed Union Case": {
    "prefix": "funioncase",
    "body": [
      "const factory ${1:Union}.${2}(${4}) = ${3};"
    ],
    "description": "Freezed Union Case"
  },
  ...
}