Example - Study: check if typedef works for type checks

result.dart

import 'dart:async';

typedef FutureResult<T> = Future<Result<T>>;
typedef FutureOrResult<T> = FutureOr<Result<T>>;

typedef ConcatResult<F, S> = ({F first, S second});

abstract class Result<T> {
  const Result();

  const factory Result.success(T data) = Success;

  const factory Result.cachedSuccess(T data) = CachedSuccess;

  const factory Result.failure(String message, [Cause? cause]) = Failure;

  bool get isSuccess => this is Success<T>;

  bool get isCached => this is CachedSuccess<T>;

  bool get isFailure => this is Failure;
  
  bool get isTypeDefCacheResult => this is CacheResult<T>;
}


class Success<T> extends Result<T> {
  const Success(this.data);

  final T data;
}

class CachedSuccess<T> extends Result<T> {
  const CachedSuccess(this.data);

  final T data;
}

class Failure<T> extends Result<T> {
  const Failure(this.message, [this.failCause]);

 

  final String message;
  final Cause? failCause;

  @override
  String toString() {
    return 'Failure{message: $message, failCause: $failCause}';
  }
}

class Cause {
  const Cause(this.error, [this.stackTrace]);

  final dynamic error;
  final StackTrace? stackTrace;

  @override
  String toString() {
    return 'Cause{error: $error, stackTrace: $stackTrace}';
  }
}

typedef CacheResult<T> = Success<T>;

void main() {
  final r = CacheResult(1);
  final r2 = Success(2);
  
  print("With typedef (do not work)");
  print(r.isTypeDefCacheResult);
  print(r2.isTypeDefCacheResult);
  
  final r3 = CachedSuccess(1);
  final r4 = Success(2);
  print("\nWith class (does work)");
  print(r3.isCached);
  print(r4.isCached);
}