Flutter自定义路径绘制插件rop的使用

Flutter自定义路径绘制插件rop的使用

在Flutter中，rop插件（Railway Oriented Programming for Dart）是一个强大的库，用于以结构化且流畅的方式处理错误。它通过使用Result<T>结构来实现这一点，使得成功和失败的路径可以清晰地分离。

安装

首先，在你的项目中添加rop依赖：

dart pub add rop

然后，在你的Dart文件中导入rop库：

import 'package:rop/rop.dart';

核心结构

Result<T>

Result<T>是一个泛型类，代表一个操作的结果。它可以包含两种类型的结果：

• 成功：包含一个类型为T的值。
• 失败：包含一个错误列表（List<RopError>）。

静态方法

• Result.success(T value) – 创建一个成功的结果。
• Result.failure(List<RopError> errors) – 创建一个包含多个错误的失败结果。
• Result.singleError(String message) – 创建一个包含单个错误的失败结果。

例如：

final success = Result.success(42);
final failure = Result.singleError('Processing error');

可用扩展

1. bind

bind 方法用于链式调用依赖的方法。如果结果是成功的，则执行下一步。

Result<U> bind<U>(Result<U> Function(T) fn)

// 示例：
Result<int> doubleIfPositive(int value) => 
    value > 0 ? Result.success(value * 2) : Result.singleError('Not positive');

final result = Result.success(5).bind(doubleIfPositive);
print(result.value); // 10

2. bindAsync

bindAsync 是bind的异步版本。

Future<Result<U>> bindAsync<U>(Future<Result<U>> Function(T) fn)

// 示例：
Future<Result<int>> asyncDouble(int value) async =>
    Result.success(value * 2);

final result = await Result.success(5).bindAsync(asyncDouble);

3. map

map 方法用于将成功的结果中的值进行转换。

Result<U> map<U>(U Function(T) mapper)

// 示例：
final result = Result.success(5).map((x) => 'Value: $x');

4. mapAsync

mapAsync 是map的异步版本。

Future<Result<U>> mapAsync<U>(Future<U> Function(T) mapper)

// 示例：
Future<String> asyncStringify(int value) async => 'Value: $value';
final result = await Result.success(5).mapAsync(asyncStringify);

5. combine

combine 方法用于将两个结果组合在一起，前提是两者都成功。

Result<Tuple2<T, U>> combine<U>(Result<U> other)

// 示例：
final result1 = Result.success(10);
final result2 = Result.success(20);
final combined = result1.combine(result2);

6. traverse

traverse 方法用于将一个Result<T>列表转换为Result<List<T>>。

Result<List<T>> traverse()

// 示例：
final results = [
  Result.success(1),
  Result.success(2),
  Result.success(3)
];
final traversed = results.traverse();

7. then

then 方法用于在结果成功时执行某个动作。

Result<T> then(void Function(T) action)

// 示例：
Result.success(5).then((value) => print('Value: $value'));

8. fallback & fallbackAsync

fallback 和 fallbackAsync 方法用于在结果失败时提供替代结果。

Result<T> fallback(Result<T> Function() alternative)
Future<Result<T>> fallbackAsync(Future<Result<T>> Function() alternative)

// 示例：
final result = Result.singleError('Error').fallback(() => Result.success(42));

完整示例

下面是一个完整的示例，展示了如何使用rop库来验证用户输入并处理各种情况。

Future<void> main() async {
  final result = await validateUserInput('new_user', 'password123')
      .bind(validatePasswordStrength)
      .bindAsync(checkIfUserExists)
      .bindAsync(saveUser);
  handleResult(result);

  final errorResult = await validateUserInput('', 'weak')
      .bind(validatePasswordStrength)
      .bindAsync(checkIfUserExists)
      .bindAsync(saveUser);
  handleResult(errorResult);

  final complexResult = await validateUserInput('user123', '')
      .bind(validatePasswordStrength)
      .bindAsync(checkIfUserExists)
      .bindAsync(saveUser)
      .fallbackAsync(() => handleErrorAndSuggestAlternative());
  handleResult(complexResult);

  final multipleValidations = await validateMultipleInputs([
    {'username': 'user123', 'password': ''},
    {'username': '', 'password': 'password123'},
    {'username': 'valid_user', 'password': 'valid_password'}
  ]);
  handleResult(multipleValidations);
}

/// 验证用户输入
Result<Map<String, String>> validateUserInput(
    String username, String password) {
  final errors = <RopError>[];

  if (username.isEmpty) {
    errors.add(RopError('用户名不能为空。'));
  }
  if (password.isEmpty) {
    errors.add(RopError('密码不能为空。'));
  }

  return errors.isEmpty
      ? Result.success({'username': username, 'password': password})
      : Result.failure(errors);
}

/// 验证密码强度
Result<Map<String, String>> validatePasswordStrength(
    Map<String, String> input) {
  final password = input['password']!;
  if (password.length < 6) {
    return Result.singleError('密码太弱。');
  }
  return Result.success(input);
}

/// 模拟异步检查用户是否存在
Future<Result<Map<String, String>>> checkIfUserExists(
    Map<String, String> input) async {
  await Future.delayed(Duration(milliseconds: 500));
  final username = input['username']!;
  if (username == 'user123') {
    return Result.singleError('用户名已存在。');
  }
  return Result.success(input);
}

/// 模拟保存用户到数据库
Future<Result<String>> saveUser(Map<String, String> input) async {
  await Future.delayed(Duration(milliseconds: 500));
  return Result.success('用户 ${input['username']} 已成功保存。');
}

/// 错误处理和建议替代方案
Future<Result<String>> handleErrorAndSuggestAlternative() async {
  print('⚠️ 发现错误：');
  print('创建临时用户...');
  await Future.delayed(Duration(milliseconds: 500));
  return Result.success('临时用户已成功创建。');
}

/// 同时验证多个输入
Future<Result<List<String>>> validateMultipleInputs(
    List<Map<String, String>> inputs) async {
  final results = inputs.map((input) {
    return validateUserInput(input['username']!, input['password']!)
        .bind(validatePasswordStrength)
        .map((validated) => '用户: ${validated['username']} 密码已验证');
  }).toList();

  return results.traverse();
}

/// 处理最终结果
void handleResult<T>(Result<T> result) {
  if (result.isSuccess) {
    print('✅ 操作成功: ${result.value}');
  } else {
    print('❌ 错误：');
    for (final error in result.errors) {
      print('- ${error.message}');
    }
  }
}