Flutter核心功能扩展插件func_dart_core的使用

功能Dart（Functional Dart）

功能Dart是一个鼓励函数式编程原则的Dart库。受TypeScript中的fp-ts库启发，功能Dart旨在为Dart开发者带来一套全面的功能编程（FP）工具。

目录：

1. 什么是函数式编程？
2. 为什么选择功能Dart？
   • 模块与类：使用模块的优势
   • 使用类来定义类型
   • 一致命名与处理模块导入时的冲突
3. 高阶类型（HKT）
4. 避免使用dynamic
5. Dart中的联合类型：模拟代数数据类型
   • 其他语言中的表示方式
   • Dart中的Option类型
   • Dart和其他语言中的Either类型
6. 函数构造中的匹配顺序
7. [缺乏如isRight, isLeft, isNone, 和 isSome等函数细化](#缺乏如isRight, isLeft, isNone, 和isSome等函数细化)
   • Dart的类型系统限制
   • 通过扩展实现isLeft的安全性问题
   • 推荐的替代方案

什么是函数式编程？

函数式编程是一种将计算视为数学函数评估的编程范式，并避免改变状态和可变数据。它强调应用函数，与强调状态变化的过程化编程风格形成对比。

函数式编程提供了许多好处，例如增加了模块性和可预测性。它非常适合管理需要并发处理、数据操作和测试的复杂应用程序。

为什么选择功能Dart？

功能Dart旨在为Dart开发者提供一套用于编写函数式代码的工具。它通过促进不可变性、函数组合和类型安全来创建一个更安全且可预测的编码环境。

功能Dart目前包括了许多在函数式编程中常见的强大灵活的结构和函数，包括：

• Eq 和 Ord 接口，分别表示相等性和排序。
• Semigroup 和 Monoid 接口，用于抽象“连接”操作。
• 数字、字符串和布尔值实例，用于上述接口。
• 用于操作和组合的谓词和函数。
• 其他辅助函数和类，以帮助函数式编程。

模块与类：使用模块的优势

• 分组：模块提供了一个清晰的结构，自然地将相关的函数和类型分组。
• 可读性：没有类约束，模块提供了一个直接且简化的阅读体验，顶级实体一目了然。
• 功能一致性：对于函数式编程结构（如Monad），使用一致的名称（如map、flatMap、ap）跨模块使用，有助于熟悉性。
• 不强制包含：避免将相关方法包装在类中。模块绕过了这一限制。
• 别名驱动的导入：在Dart中，可以使用一条语句导入整个模块，并使用别名来管理函数名称冲突。
• 状态管理：模块擅长处理无状态、纯函数，促进透明性并减少副作用。
• 可扩展性：扩展模块而不会意外覆盖或遮蔽。

使用类来定义类型

我们的库利用类来定义复杂的类型数据结构，比如Option类型：

• 明确的变体：类明确地区分不同的变体，如Some和None。
• 类型安全：它们引入了强大的类型检查能力。
• 行为封装：每个变体都可以有其独立的方法或属性。

一致命名与处理模块导入时的冲突

在函数式编程（FP）领域，一些结构如Monad通常具有共同的功能。为了简化体验并提供一致的接口，我们的库在不同的模块中使用标准化的函数名称，如map、ap和flatMap。

虽然这种命名约定有助于那些熟悉FP的人获得更直观的体验，但它也意味着当你处理多个结构时，函数名称会重叠。为了解决这个问题，可以利用Dart的别名功能。

假设你正在同时使用Option和Either结构：

import 'package:func_dart_core/option.dart' as option;
import 'package:func_dart_core/either.dart' as either;

// 使用Option模块的函数
option.map(someValue, someFunction);

// 使用Either模块的函数
either.map(anotherValue, anotherFunction);

通过前缀函数名称为其对应的模块别名，你可以确保清晰并防止命名冲突。这种方法不仅保持了一致命名的好处，还授予你在多Monad场景中无需混淆即可操作的灵活性。

高阶类型（HKT）

在Dart中，由于缺乏对高阶类型的原生支持，创建像Functor、Applicative或Monad这样的类型安全的功能编程结构变得困难。例如，不进行类型下转换，就不可能确保ap函数返回的是Applicative<B Function(A)>。

该库优先考虑类型安全，而不是完美地遵循像Functor、Applicative或Monad这样的抽象概念。

考虑到当前Dart语言特性，特别是它缺乏对高阶类型的原生支持，当我们尝试实现像Functor、Applicative或Monad这样的功能编程结构时，必须做出一些权衡。具体来说，这转化为实现像map、flatMap和ap这样的方法作为独立函数，而不是作为这些类的方法或共享抽象接口的一部分。虽然这种方法偏离了传统的面向对象编程风格，但它提供了一种函数式编程风格的体验，并增强了Dart类型系统的类型安全性。

避免使用dynamic

功能Dart的一个显著特征是其有意避免使用Dart的dynamic类型。以下是这为什么重要的原因：

1. 类型安全：使用静态类型可以在编译时进行检查，及早发现开发生命周期中的潜在错误。这减少了运行时错误的风险，使你的代码库更加健壮可靠。
2. 可读性和清晰性：显式的类型声明充当隐式文档。这使得代码更具可读性，因为开发人员可以快速理解数据的结构和性质，而不必深入到实现细节。
3. 性能优势：通过避免dynamic，Dart编译器可以更好地进行运行时优化。这导致代码不仅更安全而且更快。
4. 更平滑的重构：强类型确保重构过程中的错误较少。如果在代码其他地方误用了类型，更改类型会导致编译时错误，这使得更容易发现问题并修复。
5. 增强的开发体验：现代IDE和编辑器使用类型信息提供更精确的自动完成建议，使开发过程更加流畅和直观。

通过促进强类型，功能Dart确保开发者不太可能遇到意料之外的运行时问题，从而使应用程序更易于维护和健壮。这种做法结合函数式编程的原则，为在Dart中开发复杂应用程序提供了一个结构化且可靠的框架。

Dart中的联合类型：模拟代数数据类型

代数数据类型（ADTs）是许多函数式编程语言的关键特性，允许根据其他类型定义复合类型。联合类型是ADTs的一个子集，让开发人员表达一个值可以是几种可能变体之一。这种功能对于确保类型安全、建模特定领域的难题和减少运行时错误非常有价值。

然而，Dart不像它的某些同行那样原生支持ADTs。这需要工作流绕过，当开发人员想要利用联合类型的力量时。

其他语言中的表示方式

Haskell（Maybe类型）：

data Maybe a = Just a | Nothing

TypeScript：

type Option<A> = None | Some<A>;

Rust（Option类型）：

enum Option<T> {
    Some(T),
    None,
}

Dart中的Option类型

sealed class Option<A> {
  const Option();
}

class Some<A> extends Option<A> {
  final A value;
  Some(this.value);
}

class None<A> extends Option<A> {
  const None();
}

为什么None有一个泛型类型？

1. 确保统一性：允许Some<T>和None<T>之间的互换。
2. 维护类型安全：避免dynamic带来的陷阱。
3. 利用类型推断：Dart的类型推断工作得非常高效。
4. 保持功能方法的一致性：确保Option上的方法具有一致的行为。

Dart和其他语言中的Either类型

Either类型表示可以是两种不同类型的值：

type Either<E, A> = Left<E> | Right<A>

在Dart中，由于缺乏联合类型：

abstract class Either<E, A> { ... }

class Left<E, A> extends Either<E, A> {
  final E value;
  ...
}

class Right<E, A> extends Either<E, A> {
  final A value;
  ...
}

结论

func_dart_core 库提供了直观且安全的模拟常见联合类型的工具。

函数构造中的匹配顺序

浏览此代码库会发现特定的模式匹配惯例，选择这些惯例是为了清晰和可预测性：

• Either：

  • 在这个库中，Either 构造表示可能会失败的计算。一致地，“左边”象征着错误或失败情形，“右边”则表示成功。
  • 当用Either进行模式匹配时，首先检查“左边”（错误）情况。这种做法确保在开始时明确处理错误，提高流程的可读性。

• Option：

  • Option 实现可以看作一个容器，要么持有值（Some），要么不持有（None）。
  • 在模式匹配过程中，首先评估None情况，强调处理值可能缺失的情况的重要性。

• 谓词：

  • 虽然Either和Option严格遵守惯例，但谓词的方法提供了更多的灵活性。
  • 不过，整个库中保持了一致的评估顺序，以保持清晰性。

通过遵循这些惯例，这个库提供了一种连贯且直观的体验，允许开发者专注于他们的逻辑和功能，而不是结构的复杂性。

缺乏如isRight, isLeft, isNone, 和 isSome等函数细化

许多函数式编程库提供了如isRight, isLeft, isNone, 和 isSome这样的细化函数。然而，在这个库中，这些细化函数明显不存在。以下是原因。

Dart的类型系统限制

Dart不像一些具有更高级类型细化能力的语言（例如TypeScript或Haskell）那样，不基于谓词在条件块内细化类型。

例如，考虑以下模式：

if (isLeft(myEither)) {

    return Left(myEither.value);  // 类型错误

}

即使isLeft返回true，Dart的类型系统也不会在块内细化myEither的类型。这意味着你无法访问.value。

通过扩展实现isLeft的安全性问题

一个扩展将提供一种方便的方式来处理Either类型。然而，这不是类型安全的。原因如下：

extension EitherExtensions<A, B> on Either<A, B> {
  bool get isLeft => this is Left<A, B>;

  A get left {
    if (this is Left<A, B>) {
      return (this as Left<A, B>).value;
    }
    throw Exception("Trying to access leftValue of a Right Either variant.");
  }
}

虽然isLeft获取器告诉你Either是否为Left变体，但left获取器将返回Left的值而没有任何内在的安全检查。如果你不小心或不知道地调用left在一个Right实例上，将会导致运行时异常。

这种设计有可能引入错误和意外崩溃，特别是如果没有在访问leftValue之前采取适当的预防措施。尽管异常消息很清晰，但依靠运行时异常进行流程控制通常是不被推荐的，因为它违背了编写可预测和安全代码的原则。

推荐的替代方案

处理数据结构（如Either和Option）中的变体可以通过多种方式，每种方式都有其自身的优点。

1. 直接类型检查（命令式方法）

处理变体的基本方法是通过直接类型检查。

对于Either：

if (myEither is Left<ErrorType, SuccessType>) {
  // 处理Left变体
  var left = myEither.value;
} else if (myEither is Right<ErrorType, SuccessType>) {
  // 处理Right变体
  var right = myEither.value;
} else {
  throw AssertionError('Unreachable code');
}

对于Option：

if (myOption is Some<ValueType>) {
  var value = myOption.value;
} else if (myOption is None<ValueType>) {
  // 处理None情况
} else {
  throw AssertionError('Unreachable code');
}

2. 穷尽的开关语句（结构化命令式方法）

通过Dart的穷尽switch，你可以以更结构化的方式确保所有变体都被处理。

对于Either：

switch (myEither) {
  case Left(value: var leftValue):
    // 处理Left变体
    break;
  case Right(value: var rightValue):
    // 处理Right变体
    break;
}

对于Option：

switch (myOption) {
  case Some(value: var optionValue):
    // 处理Some变体
    break;
  case None():
    // 处理None变体
    break;
}

3. 匹配函数（声明式函数式方法）

对于声明式、函数式的方法，使用match函数。这种方法抽象了类型检查的机制，从而产生更易读和可组合的代码。

对于Either：

eitherModule.match(
  (left) => /* 处理Left */,
  (right) => /* 处理Right*/
);

对于Option：

optionModule.match(
  (val) => /* 处理Some */,
  () => /* 处理None */
);

为什么使用函数式方法？

函数式方法如match旨在清晰和可组合。它们使你的意图明确，并确保处理所有可能的情况。这减少了样板代码，使你的代码更不易出错，并提高了可读性。对于熟悉函数式编程或希望在Dart中利用函数式范式的人来说，match函数是一个熟悉且强大的工具。

使用

查看示例文件夹。

安装

要在项目中添加功能Dart，请在pubspec.yaml中包含以下内容：

dependencies:
  func_dart_core: latest_version