Flutter插件fpdt的使用方法

Flutter插件 fpdt 的使用方法

Flutter插件fpdt概述

fpdt 是一个用于 Dart 语言的函数式编程工具包。它包括各种函数和单子（monads），可以帮助开发者更方便地进行函数式编程。

包含的功能

• 函数扩展：chain 和 compose
• Option
• Either
• Task
• TaskEither
• TaskOption
• State
• Reader
• ReaderTask
• ReaderTaskEither
• StateReaderTaskEither
• 不可变数据结构，依赖于：fast_immutable_collections
• 可迭代扩展帮助器
• Unit
• StateMachine 和 StateRTEMachine 用于互操作性

注意：在达到版本 0.1.0 之前，API 将保持不稳定状态。

文档

API 文档可以在以下链接查看：

• https://pub.dev/documentation/fpdt/latest/

example/ 和 test/ 目录也可以帮助你了解如何使用该库。

示例代码

import 'package:fpdt/fpdt.dart';
import 'package:fpdt/either.dart' as E;
import 'package:fpdt/option.dart' as O;

void main() async {
  // 使用 Imperative 风格的验证函数
  String? validateHelloImperative(String? s) {
    if (s == null) return null;

    s = s.trim();
    if (s.isEmpty) return null;

    if (!s.startsWith('hello')) return null;

    return '$s - valid!';
  }

  assert(validateHelloImperative('   hello!') == 'hello! - valid!');
  assert(validateHelloImperative('   hi!') == null);
  assert(validateHelloImperative('   ') == null);
  assert(validateHelloImperative(null) == null);

  // 使用 Functional 风格的验证函数
  Option<String> validateHelloFunctional(String? s) => O
      .fromNullable(s)
      .chain(O.map((s) => s.trim()))
      .chain(O.filter((s) => s.isNotEmpty))
      .chain(O.filter((s) => s.startsWith('hello')))
      .chain(O.map((s) => '$s - valid!'));

  assert(validateHelloFunctional('   hello!') == O.some('hello! - valid!'));
  assert(validateHelloFunctional('   hi!') == O.none());
  assert(validateHelloFunctional('   ') == O.none());
  assert(validateHelloFunctional(null) == O.none());

  // 使用 Composition 风格的验证函数
  final maybeString = O
      .fromNullableWith<String>()
      .compose(O.map((s) => s.trim()))
      .compose(O.filter((s) => s.isNotEmpty));

  final maybeHelloString = maybeString.compose(O.filter((s) => s.startsWith('hello')));

  final validateHelloCompose = maybeHelloString.compose(O.map((s) => '$s - valid!'));

  assert(validateHelloCompose('   hello!') == O.some('hello! - valid!'));
  assert(validateHelloCompose('   hi!') == O.none());
  assert(validateHelloCompose('   ') == O.none());
  assert(validateHelloCompose(null) == O.none());

  // 使用 `maybeString` 函数来解析整数
  final maybeInt = maybeString.compose(O.chainNullableK(int.tryParse));

  assert(maybeInt('123') == O.some(123));
  assert(maybeInt('hello') == O.none());
  assert(maybeInt(null) == O.none());

  // 使用 Either 处理错误
  Either<ArgumentError, String> validateHelloFunctionalE(String? s) => E
      .fromNullable(s, () => ArgumentError.notNull('s'))
      .chain(E.map((s) => s.trim()))
      .chain(E.filter(
        (s) => s.isNotEmpty,
        (s) => ArgumentError.value(s, 's', 'was empty'),
      ))
      .chain(E.filter(
        (s) => s.startsWith('hello'),
        (s) => ArgumentError.value(s, 's', 'does not start with hello'),
      ))
      .chain(E.map((s) => '$s - valid!'));

  assert(validateHelloFunctionalE('    hello') == E.right('hello - valid!'));
  assert(validateHelloFunctionalE('    hello')
          .chain(E.getOrElse((left) => 'Error was: $left')) ==
      'hello - valid!');
  assert(validateHelloFunctionalE(null)
          .chain(E.getOrElse((left) => 'Error was: $left')) ==
      'Error was: Invalid argument(s) (s): Must not be null');

  // 使用 Composition 风格的 Either 验证函数
  final maybeStringE = E
      .fromNullableWith<ArgumentError, String>(
          () => ArgumentError.notNull('string'))
      .compose(E.map((s) => s.trim()))
      .compose(E.filter(
        (s) => s.isNotEmpty,
        (s) => ArgumentError.value(s, 's', 'was empty'),
      ));

  final maybeHelloStringE = maybeStringE.compose(E.filter(
    (s) => s.startsWith('hello'),
    (s) => ArgumentError.value(s, 's', 'does not start with hello'),
  ));

  final validateHelloComposeE = maybeHelloStringE.compose(E.map((s) => '$s - valid!'));

  assert(validateHelloComposeE('   hello') == E.right('hello - valid!'));
  assert(E.isLeft(validateHelloComposeE(null)));

  // 使用 Either 版本的 `maybeInt` 函数
  final maybeIntE = maybeStringE.compose(E.chainNullableK(
    int.tryParse,
    (s) => ArgumentError.value(s, 's', 'did not contain an int'),
  ));

  assert(maybeIntE('    1234 ') == E.right(1234));
}