stableee

lib/core/utils/result.dart

@@ -0,0 +1,165 @@
+/// Result type for handling success and failure cases
+/// Uses sealed classes for exhaustive pattern matching
+sealed class Result<T> {
+  const Result();
+
+  /// Check if result is success
+  bool get isSuccess => this is Success<T>;
+
+  /// Check if result is failure
+  bool get isFailure => this is Failure<T>;
+
+  /// Get data if success, null otherwise
+  T? get dataOrNull => switch (this) {
+    Success(data: final data) => data,
+    Failure() => null,
+  };
+
+  /// Get error if failure, null otherwise
+  String? get errorOrNull => switch (this) {
+    Success() => null,
+    Failure(message: final message) => message,
+  };
+
+  /// Transform success value
+  Result<R> map<R>(R Function(T data) transform) {
+    return switch (this) {
+      Success(data: final data) => Success(transform(data)),
+      Failure(message: final msg, exception: final ex) => Failure(msg, ex),
+    };
+  }
+
+  /// Execute callback on success
+  Result<T> onSuccess(void Function(T data) callback) {
+    if (this case Success(data: final data)) {
+      callback(data);
+    }
+    return this;
+  }
+
+  /// Execute callback on failure
+  Result<T> onFailure(void Function(String message) callback) {
+    if (this case Failure(message: final message)) {
+      callback(message);
+    }
+    return this;
+  }
+
+  /// Get data or throw exception
+  T getOrThrow() {
+    return switch (this) {
+      Success(data: final data) => data,
+      Failure(message: final msg, exception: final ex) =>
+        throw ex ?? Exception(msg),
+    };
+  }
+
+  /// Get data or return default value
+  T getOrDefault(T defaultValue) {
+    return switch (this) {
+      Success(data: final data) => data,
+      Failure() => defaultValue,
+    };
+  }
+
+  /// Get data or compute from error
+  T getOrElse(T Function(String error) onError) {
+    return switch (this) {
+      Success(data: final data) => data,
+      Failure(message: final msg) => onError(msg),
+    };
+  }
+}
+
+/// Success result containing data
+class Success<T> extends Result<T> {
+  final T data;
+
+  const Success(this.data);
+
+  @override
+  String toString() => 'Success($data)';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Success<T> &&
+          runtimeType == other.runtimeType &&
+          data == other.data;
+
+  @override
+  int get hashCode => data.hashCode;
+}
+
+/// Failure result containing error message and optional exception
+class Failure<T> extends Result<T> {
+  final String message;
+  final Exception? exception;
+
+  const Failure(this.message, [this.exception]);
+
+  @override
+  String toString() =>
+      'Failure($message${exception != null ? ', $exception' : ''})';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is Failure<T> &&
+          runtimeType == other.runtimeType &&
+          message == other.message &&
+          exception == other.exception;
+
+  @override
+  int get hashCode => message.hashCode ^ exception.hashCode;
+}
+
+/// Extension for Future<Result<T>>
+extension FutureResultExtension<T> on Future<Result<T>> {
+  /// Map async result
+  Future<Result<R>> mapAsync<R>(R Function(T data) transform) async {
+    final result = await this;
+    return result.map(transform);
+  }
+
+  /// Execute callback on success
+  Future<Result<T>> onSuccessAsync(
+    Future<void> Function(T data) callback,
+  ) async {
+    final result = await this;
+    if (result case Success(data: final data)) {
+      await callback(data);
+    }
+    return result;
+  }
+
+  /// Execute callback on failure
+  Future<Result<T>> onFailureAsync(
+    Future<void> Function(String message) callback,
+  ) async {
+    final result = await this;
+    if (result case Failure(message: final message)) {
+      await callback(message);
+    }
+    return result;
+  }
+}
+
+/// Helper to wrap try-catch blocks
+Result<T> resultOf<T>(T Function() computation) {
+  try {
+    return Success(computation());
+  } catch (e) {
+    return Failure(e.toString(), e is Exception ? e : Exception(e.toString()));
+  }
+}
+
+/// Helper to wrap async try-catch blocks
+Future<Result<T>> asyncResultOf<T>(Future<T> Function() computation) async {
+  try {
+    final data = await computation();
+    return Success(data);
+  } catch (e) {
+    return Failure(e.toString(), e is Exception ? e : Exception(e.toString()));
+  }
+}