Data Result #

A lightweight, type-safe alternative to Either/Result types for Dart and Flutter.

Installation #

dependencies:
  data_result: ^1.0.0

Quick Start #

Create your result type by extending DataResult:

import 'package:data_result/data_result.dart';

class ApiResult<T> extends DataResult<T, String> {
  ApiResult.success(super.data) : super.success();
  ApiResult.failure(super.error) : super.failure();
}

Use it in your functions:

Future<ApiResult<User>> fetchUser(int id) async {
  try {
    final response = await http.get(Uri.parse('api.example.com/users/$id'));
    if (response.statusCode == 200) {
      return ApiResult.success(User.fromJson(response.body));
    }
    return ApiResult.failure('HTTP ${response.statusCode}');
  } catch (e) {
    return ApiResult.failure('Network error: $e');
  }
}

Handle the result:

final result = await fetchUser(123);

result.when(
  success: (user) => print('User: $user'),
  error: (error) => print('Error: $error'),
);

API #

Create Results:

• YourResult.success(data) - Success result
• YourResult.failure(error) - Failure result

Check Status:

• result.isSuccess - Check if successful
• result.data - Get success data (or null)
• result.failure - Get failure data (or null)

Handle Results:

• result.when(success: ..., error: ...) - Handle both cases
• result.whenOrNull(success: ..., failure: ...) - Handle one case

Examples #

Validation:

class ValidationResult<T> extends DataResult<T, List<String>> {
  ValidationResult.success(super.data) : super.success();
  ValidationResult.failure(super.errors) : super.failure();
}

ValidationResult<String> validateEmail(String email) {
  final errors = <String>[];
  if (email.isEmpty) errors.add('Email required');
  if (!email.contains('@')) errors.add('Invalid email');

  return errors.isEmpty
    ? ValidationResult.success(email)
    : ValidationResult.failure(errors);
}

Database:

class DbResult<T> extends DataResult<T, String> {
  DbResult.success(super.data) : super.success();
  DbResult.failure(super.error) : super.failure();
}

DbResult<User> saveUser(User user) {
  try {
    database.insert(user);
    return DbResult.success(user);
  } catch (e) {
    return DbResult.failure('Save failed: $e');
  }
}

Comparison with Either Packages #

Packages like dart_either, dartz, and fpdart are powerful functional programming libraries with advanced features. data_result takes a different approach focused on simplicity and clarity.

When to Choose data_result #

data_result is perfect when you want:

• Clear, self-documenting code with success/failure naming
• Minimal learning curve for your team
• Zero dependencies
• Simple error handling without FP complexity

// Clear naming - no memorization needed
class ApiResult<T> extends DataResult<T, String> {
  ApiResult.success(super.data) : super.success();
  ApiResult.failure(super.error) : super.failure();
}

ApiResult<User> result = ApiResult.success(user);
result.when(
  success: (user) => handleSuccess(user),  // Instantly clear
  error: (error) => handleError(error),
);

When to Choose Either Packages #

Either packages are great when you need:

• Advanced functional programming patterns (monad comprehensions, traverse, etc.)
• Rich API with 50+ methods for complex transformations
• Integration with FP ecosystems
• Team familiar with FP concepts like Left/Right

// Functional programming approach
Either<String, User> result = Either.right(user);
result.fold(
  ifLeft: (error) => handleError(error),
  ifRight: (user) => handleSuccess(user),
);

Key Differences #

The Bottom Line #

Both approaches are valid:

• Choose Either packages if you're doing functional programming and need advanced features
• Choose data_result if you want clear, simple error handling that any developer can understand

data_result exists because not every project needs the complexity of full Either monads. Sometimes you just want clean, readable error handling.

License #

MIT License - see LICENSE file.