在这个例子中，我们将使用Option数据类型。

trait HKT3<A, B, C> {
    type Target2;
}

impl<A, B, C> HKT3<A, B, C> for Option<A> {
    type Target2 = Option<B>;
}

由于Applicative实现了Fantasy Land规范中的ap和Pure的of，我们必须像下面这样实现类型

// Apply
trait Apply<A, F, B> : Functor<A, B> + HKT3<A, F, B>
    where F: FnOnce(A) -> B,
{
    fn ap(self, f: <Self as HKT3<A, F, B>>::Target2) -> <Self as HKT<A, B>>::Target;
}

impl<A, F, B> Apply<A, F, B> for Option<A>
    where F: FnOnce(A) -> B,
{
    fn ap(self, f: Self::Target2) -> Self::Target {
        self.and_then(|v| f.map(|z| z(v)))
    }
}

// Pure
trait Pure<A>: HKT<A, A> {
    fn of(self) -> <Self as HKT<A, A>>::Target;
}

impl<A> Pure<A> for Option<A> {
    fn of(self) -> Self::Target {
        self
    }
}

// Applicative
trait Applicative<A, F, B> : Apply<A, F, B> + Pure<A>
    where F: FnOnce(A) -> B,
{
} // Simply derives Apply and Pure

impl<A, F, B> Applicative<A, F, B> for Option<A>
    where F: FnOnce(A) -> B,
{
}

然后我们可以像这样使用Option Applicative

let x = Option::of(Some(1)).ap(Some(|x| x + 1));
assert_eq!(x, Some(2));

同态

一个保持其定义域结构不变的功能。请参阅范畴定义以获取更多信息。

前几个（内映射、同态和同构）比其他部分更容易理解。其余部分需要F-代数的概念。更简单的Haskell声明列在参数形态的维基百科上，但这些概念还没有扩展到更一般的范畴论。简而言之，F-代数的观点是将代数对象的集合论定义重新定义为纯粹的范畴论基础：将思想从包含元素的集合转移到具有形态的对象集合。然而，这里的一些思想尚未被推广到这种运动。

自同态

输入类型与输出类型相同的函数。

// uppercase :: &str -> String
let uppercase = |x: &str| x.to_uppercase();

// decrement :: i32 -> i32
let decrement = |x: i32| x - 1;

同构

两种对象之间可逆的变换对。

例如，二维坐标可以存储为i32向量[2,3]或结构体{x: 2, y: 3}。

#[derive(PartialEq, Debug)]
struct Coords {
    x: i32,
    y: i32,
}

let pair_to_coords = | pair: (i32, i32) | Coords { x: pair.0, y: pair.1 };
let coords_to_pair = | coords: Coords | (coords.x, coords.y);
assert_eq!(
    pair_to_coords((1, 2)),
    Coords { x: 1, y: 2 },
); // passes
assert_eq!(
    coords_to_pair(Coords { x: 1, y: 2 }),
    (1, 2),
); // passes

同构在使结构相同方面至关重要。由于我们知道上面的结构体与一对相同，所有存在于对上的函数都可以存在于结构体上。如果f是同构，g是陪域上的内映射：f^-1g f将扩展g以应用于定义域。

同态

同态只是一个保持结构的映射。它是形态的旧术语。实际上，函子只是范畴之间的同态，因为它在映射下保持原始范畴的结构。

assert_eq!(A::of(f).ap(A::of(x)), A::of(f(x))); // passes
assert_eq!(
    Either::of(|x: &str| x.to_uppercase(x)).ap(Either::of("oreos")),
    Either::of("oreos".to_uppercase),
); // passes

累积

一个reduceRight函数，它将一个函数应用于累加器以及数组中的每个值（从右到左），以将其缩减为单个值。

let sum = |xs: Vec<i32>| xs.iter().fold(0, |mut sum, &val| { sum += val; sum });

assert_eq!(sum(vec![1, 2, 3, 4, 5]), 15);

反子

一个unfold函数。 unfold是fold的反义词。它从一个单值生成一个列表。

let count_down = unfold((8_u32, 1_u32), |state| {
    let (ref mut x1, ref mut x2) = *state;

    if *x1 == 0 {
        return None;
    }

    let next = *x1 - *x2;
    let ret = *x1;
    *x1 = next;

    Some(ret)
});

assert_eq!(
    count_down.collect::<Vec<u32>>(),
    vec![8, 7, 6, 5, 4, 3, 2, 1],
);

合子

anamorphism和catamorphism的组合。

Apomorphism

它是paramorphism的反义词，就像anamorphism是catamorphism的反义词一样。与paramorphism一样，您结合访问累加器和已累积的内容，apomorphism让您有提前返回的潜力。

集合等价类

这是一个具有等价关系的集合。

一个具有equals函数的对象，该函数可以用于比较同一类型的其他对象。

它必须遵守以下规则才能成为Setoid

1. a.equals(a) (自反性)
2. a.equals(b) 和 b.equals(c)，那么 a.equals(c) (对称性)
3. a.equals(b) 和 b.equals(c)，那么 a.equals(c) (传递性)

将Vector转换为Setoid

请注意，我将Self / self当作a来处理。

trait Setoid {
    fn equals(&self, other: &Self) -> bool;
}

impl Setoid for Vec<i32> {
    fn equals(&self, other: &Self) -> bool {
        self.len() == other.len()
    }
}

assert_eq!(vec![1, 2].equals(&vec![1, 2]), true); // passes

在Rust标准库中，已经提供了Eq，它与本节讨论过的Setoid类似。此外，Eq还有equals实现，它涵盖了Rust中已经存在的一系列数据结构。

序号

实现Ord规定的对象或值，也实现了Setoid规定。

Ord对象或值必须满足以下规则，对所有a、b或c都适用。

1. 完备性：a <= b或b <= a
2. 反对称性：a <= b和b <= a，则a == b
3. 传递性：a <= b和b <= c，则a <= c

可以在以下链接找到Rust文档中关于Ord的说明：Ord

半群

具有combine函数的对象，可以将它与相同类型的另一个对象组合。

它必须遵守以下规则才能成为Semigroup

1. a.add(b).add(c)等价于a.add(b.add(c))（结合性）

use std::ops::Add;

pub trait Semigroup<M>: Add<M> {
}

assert_eq!(
    vec![1, 2].add(&vec![3, 4]),
    vec![1, 2, 3, 4],
); // passes

assert_eq!(
    a.add(&b).add(&c),
    a.add(&b.add(&c)),
); // passes

可折叠

具有可以将该对象转换成其他类型的foldr/l函数的对象。我们使用rats作为例子，但该包只实现了fold_right。

fold_right等价于Fantasy Land Foldable的reduce，其过程如下

fantasy-land/reduce::Foldable f=>f a~> ((b,a) ->b,b) ->b

use rats::foldable::Foldable;
use rats::kind::IntoKind;
use rats::kinds::VecKind;

let k = vec![1, 2, 3].into_kind();
let result = VecKind::fold_right(k, 0, | (i, acc) | i + acc);
assert_eq!(result, 6);

如果您要手动实现Foldable，它的特质如下

use crate::hkt::HKT;
use crate::monoid::Monoid;

pub trait Foldable<A, B>: HKT<A, B> {
    fn reduce<F>(b: B, ba: F) -> <Self as HKT<A, B>>::Target
    where
        F: FnOnce(B, A) -> (B, B);

    fn fold_map<M, N, F>(m: M, fa: F) -> M
    where
        M: Monoid<N>,
        F: FnOnce(<Self as HKT<A, B>>::URI) -> M;

    fn reduce_right<F>(b: B, f: F) -> <Self as HKT<A, B>>::Target
    where
        F: FnOnce(A, B) -> (B, B);
}

透镜

一个lens是一个类型，它将某些其他数据结构的getter和不可变setter配对。

trait Lens<S, A> {
    fn over(s: &S, f: &Fn(Option<&A>) -> A) -> S {
        let result: A = f(Self::get(s));
        Self::set(result, &s)
    }
    fn get(s: &S) -> Option<&A>;
    fn set(a: A, s: &S) -> S;
}

#[derive(Debug, PartialEq, Clone)]
struct Person {
    name: String,
}

#[derive(Debug)]
struct PersonNameLens;

impl Lens<Person, String> for PersonNameLens {
    fn get(s: &Person) -> Option<&String> {
       Some(&s.name)
    }

    fn set(a: String, s: &Person) -> Person {
        Person {
            name: a,
        }
    }
}

对于给定的数据结构具有get和set对，可以启用一些关键功能。

let e1 = Person {
    name: "Jason".to_string(),
};
let name = PersonNameLens::get(&e1);
let e2 = PersonNameLens::set("John".to_string(), &e1);
let expected = Person {
    name: "John".to_string()
};
let e3 = PersonNameLens::over(&e1, &|x: Option<&String>| {
    match x {
        Some(y) => y.to_uppercase(),
        None => panic!("T_T") // lol...
    }
});

assert_eq!(*name.unwrap(), e1.name); // passes
assert_eq!(e2, expected); // passes
assert_eq!(e3, Person { name: "JASON".to_string() }); // passes

lenses也是可组合的。这允许轻松地进行深层次数据的不可变更新。

struct FirstLens;

impl<A> Lens<Vec<A>, A> for FirstLens {
  fn get(s: &Vec<A>) -> Option<&A> {
     s.first()
  }

  fn set(a: A, s: &Vec<A>) -> Vec<A> {
      unimplemented!() // Nothing to set in FirstLens
  }
}

let people = vec![Person { name: "Jason" }, Person { name: "John" }];
Lens::over(composeL!(FirstLens, NameLens), &|x: Option<&String>| {
  match x {
      Some(y) => y.to_uppercase(),
      None => panic!("T_T")
  }
}, people); // vec![Person { name: "JASON" }, Person { name: "John" }];

进一步阅读

• 一个简单的lens入门
• Monocle Scala

类型签名

Rust中的每个函数都会指明它们的参数类型和返回值类型。

// add :: i32 -> i32 -> i32
fn add(x: i32) -> impl Fn(i32)-> i32 {
    move |y| x + y
}

// increment :: i32 -> i32
fn increment(x: i32) -> i32 {
    x + 1
}

如果函数接受另一个函数作为参数，它会被括号包裹。

// call :: (a -> b) -> a -> b
fn call<A, B>(f: &Fn(A) -> B) -> impl Fn(A) -> B + '_ {
    move |x| f(x)
}

字母a、b、c、d用于表示参数可以是任何类型。以下版本的map接受一个将类型为a的值转换成类型b的函数a，一个类型为a的值的数组，并返回一个类型为b的值的数组。

// map :: (a -> b) -> [a] -> [b]
fn map<A, B>(f: &Fn(A) -> B) -> impl Fn(A) -> B + '_ {
    move |x| f(x)
}

进一步阅读

• Mostly Adequate Guide
• 什么是Hindley-Milner？

代数数据类型

由将其他类型组合在一起制成的复合类型。两种常见的代数类型类别是sum和product。

求和类型

类型和是两种类型组合成另一种类型。之所以称为和，是因为结果类型的可能值数量是输入类型的总和。

Rust 有 enum，在 ADT 中字面上表示 sum。

enum WeakLogicValues {
   True(bool),
   False(bool),
   HalfTrue(bool),
}
// WeakLogicValues = bool + otherbool + anotherbool

积类型

积类型以您可能更熟悉的方式组合类型。

struct Point {
    x: i32,
    y: i32,
}
// Point = i32 x i32

之所以称为积，是因为数据结构可能的总值是不同值的乘积。许多语言都有元组类型，这是积类型的简单表达。

另请参阅 集合论

进一步阅读

• 4 种不同语言中的 ADT
• 和积类型以及 Π 类型是什么

选项

Option 是一个 和类型，有两种情况通常称为 Some 和 None。

Option 对于组合可能不返回值的函数很有用。

let mut cart = HashMap::new();
let mut item = HashMap::new();
item.insert(
    "price".to_string(),
    12
);
cart.insert(
    "item".to_string(),
    item,
);

fn get_item(cart: &HashMap<String, HashMap<String, i32>>) -> Option<&HashMap<String, i32>> {
    cart.get("item")
}

fn get_price(item: &HashMap<String, i32>) -> Option<&i32> {
    item.get("price")
}

使用 and_then 或 map 来顺序执行返回 Option 的函数

fn get_nested_price(cart: &HashMap<String, HashMap<String, i32>>) -> Option<&i32> {
    return get_item(cart).and_then(get_price);
}

let price = get_nested_price(&cart);

match price {
    Some(v) => assert_eq!(v, &12),
    None => panic!("T_T"),
}

Option 也称为 Maybe。 Some 有时称为 Just。 None 有时称为 Nothing。

函数式编程参考

• Scala with Cats
• Haskell 编程
• 程序员范畴论
• 范畴论笔记

Rust 语言中的函数式编程开发

• 高阶多态 RFC
• Rust中的currying
• Rust 中的自动柯里化

我对这个项目的看法

请注意，该项目并没有涵盖每个定义及其代码示例，因为它不值得在这个词汇表中投入太多时间。我已额外努力添加了补充的外部参考，您可以查阅以进行进一步学习。