typedef OnError<E> = void Function(E error);

abstract class Either<E, S> {
  const Either();

  E? getError();

  S? getSuccess();

  bool isError();

  bool isSuccess();

  void when({
    required OnError<E> error,
    required void Function(S success) success,
  });
}

class Success<E, S> extends Either<E, S> {
  final S _success;

  const Success(this._success);

  @override
  E? getError() => null;

  @override
  S? getSuccess() => _success;

  @override
  bool isError() => false;

  @override
  bool isSuccess() => true;

  @override
  void when({
    required OnError<E> error,
    required void Function(S success) success,
  }) {
    success(_success);
  }
}

class Error<E, S> extends Either<E, S> {
  final E _error;

  const Error(this._error);

  @override
  E? getError() => _error;

  @override
  S? getSuccess() => null;

  @override
  bool isError() => true;

  @override
  bool isSuccess() => false;

  @override
  void when({
    required OnError<E> error,
    required void Function(S success) success,
  }) {
    error(_error);
  }
}