Dart enum when, maybeWhen & whenOrNull example with dartz

dart-enum-when-maybe-when-and-when-or-null-example-with-dartz.md

Dart Enum Dartz

Enum when, maybeWhen & whenOrNull example with dartz

This is the boilerplate or example of the enum when method helper like generated freezed result using dartz package

Warning

This snippet uses dartz package, so make sure you have already imported it.

import 'package:dartz/dartz.dart';

Enum Declaration

enum Direction {
  left,
  right,
  forward,
  backward;

  const Direction();

  T when<T>({
    required T Function() left,
    required T Function() right,
    required T Function() forward,
    required T Function() backward,
  }) {
    return () {
      switch (this) {
        case Direction.left:
          return left;
        case Direction.right:
          return right;
        case Direction.forward:
          return forward;
        case Direction.backward:
          return backward;
      }
    }.call().call();
  }

  T maybeWhen<T>({
    T Function()? left,
    T Function()? right,
    T Function()? forward,
    T Function()? backward,
    required T orElse,
  }) {
    return some(unit)
        .map((_) {
          switch (this) {
            case Direction.left:
              return left;
            case Direction.right:
              return right;
            case Direction.forward:
              return forward;
            case Direction.backward:
              return backward;
          }
        })
        .bind(optionOf)
        .fold(() => orElse, (a) => a());
  }

  T? whenOrNull<T>({
    T Function()? left,
    T Function()? right,
    T Function()? forward,
    T Function()? backward,
  }) {
    return () {
      switch (this) {
        case Direction.left:
          return left;
        case Direction.right:
          return right;
        case Direction.forward:
          return forward;
        case Direction.backward:
          return backward;
      }
    }.call()?.call();
  }
}

Example Function Usage

calc(Direction e) {
  final resWhen = e.when<String>(
    left: () => 'l',
    right: () => 'r',
    forward: () => 'f',
    backward: () => 'b',
  );
  final resWhenNull = e.when<String?>(
    left: () => null,
    right: () => null,
    forward: () => null,
    backward: () => null,
  );
  final resMaybeWhen = e.maybeWhen<String>(
    left: () => 'l',
    orElse: 'fallback message',
  );
  final resMaybeWhenNull = e.maybeWhen<String?>(
    left: () => null,
    orElse: 'fallback message',
  );
  final resWhenOrNull = e.whenOrNull<String>(
    left: () => 'l',
  );
  final resWhenOrNullNull = e.whenOrNull<String?>(
    left: () => null,
  );

  print([
    '${resWhen} -> (resWhen)',
    '${resWhenNull} -> (resWhenNull)',
    '${resMaybeWhen} -> (resMaybeWhen)',
    '${resMaybeWhenNull} -> (resMaybeWhenNull)',
    '${resWhenOrNull} -> (resWhenOrNull)',
    '${resWhenOrNullNull} -> (resWhenOrNullNull)',
  ].join('\n'));
}

Example Run

Future<void> main() async {
  print('left');
  calc(Direction.left);
  print('');
  print('forward (omitted value)');
  calc(Direction.forward);
  print('');
}

Print Result

left
l -> (resWhen)
null -> (resWhenNull)
l -> (resMaybeWhen)
null -> (resMaybeWhenNull)
l -> (resWhenOrNull)
null -> (resWhenOrNullNull)

forward (omitted value)
f -> (resWhen)
null -> (resWhenNull)
fallback message -> (resMaybeWhen)
fallback message -> (resMaybeWhenNull)
null -> (resWhenOrNull)
null -> (resWhenOrNullNull)