F代数和F代数是数学结构，有助于推理归纳类型（或递归类型）。
F代数
我们首先从F代数开始。我将尝试变得尽可能简单。
我猜你知道什么是递归类型。例如，这是整数列表的类型：
data IntList = Nil | Cons (Int, IntList)
很明显，它是递归的-实际上，其定义是针对自身的。它的定义由两个数据构造函数组成，它们具有以下类型：
Nil :: () -> IntList
Cons :: (Int, IntList) -> IntList
请注意，我已经写类型Nil的() -> IntList，不是简单的IntList。从理论上讲，这些实际上是等价的类型，因为()类型只有一个居民。
如果我们以更理论的方式编写这些函数的签名，我们将得到
Nil :: 1 -> IntList
Cons :: Int × IntList -> IntList
其中1是一个单元组（具有一个元件组）和A × B操作的两组矢量积A和B（即，对一组(a, b)，其中a通过的所有元素进入A和b经过的所有元素B）。
两套脱节工会A和B是一组A | B是集工会{(a, 1) : a in A}和{(b, 2) : b in B}。本质上，它是一组来自所有元素A，并B属于两种，但每个“标记”这个元素A或者B，所以当我们选择的任何元素来自A | B我们会立刻知道此元素是否来自何处A或B。
我们可以“连接” Nil和Cons函数，因此它们将形成一个在集合上工作的单个函数1 | (Int × IntList)：
Nil|Cons :: 1 | (Int × IntList) -> IntList
确实，如果将Nil|Cons函数应用于()值（显然属于1 | (Int × IntList)集合），那么它的行为就好像是Nil; 如果Nil|Cons应用于类型的任何值(Int, IntList)（此类值也在集合中1 | (Int × IntList)，则行为与Cons。
现在考虑另一种数据类型：
data IntTree = Leaf Int | Branch (IntTree, IntTree)
它具有以下构造函数：
Leaf :: Int -> IntTree
Branch :: (IntTree, IntTree) -> IntTree
也可以加入一个功能：
Leaf|Branch :: Int | (IntTree × IntTree) -> IntTree
可以看出，这两个joined函数的类型相似：它们看起来都像
f :: F T -> T
where F是一种转换，它采用我们的类型并给出更复杂的类型，它由x和|，T类型以及可能的其他类型组成。例如，for IntList和IntTree F如下所示：
F1 T = 1 | (Int × T)
F2 T = Int | (T × T)
我们可以立即注意到，任何代数类型都可以用这种方式编写。实际上，这就是为什么将它们称为“代数”的原因：它们由许多其他类型的“和”（联合）和“乘积”（叉乘积）组成。
现在我们可以定义F代数。F-代数只是一对(T, f)，其中T是某种类型，f是type 的函数f :: F T -> T。在我们的示例中，F代数是(IntList, Nil|Cons)和(IntTree, Leaf|Branch)。但是请注意，尽管这种类型的f功能是按照每个F相同的，T并且f自己可以随心所欲。举例来说，(String, g :: 1 | (Int x String) -> String)或(Double, h :: Int | (Double, Double) -> Double)对于一些g和h也F-代数对应F.
然后，我们可以介绍F代数同态，然后介绍具有非常有用的性质的初始F代数。实际上，(IntList, Nil|Cons)是初始的F1代数，(IntTree, Leaf|Branch)也是初始的F2代数。我不会提供这些术语和属性的确切定义，因为它们比所需的更为复杂和抽象。
尽管如此，例如(IntList, Nil|Cons)F代数这一事实使我们能够fold在这种类型上定义类似函数。如您所知，fold是一种将一个递归数据类型转换为一个有限值的操作。例如，我们可以将整数列表折叠为一个值，该值是列表中所有元素的总和：
foldr (+) 0 [1, 2, 3, 4] -> 1 + 2 + 3 + 4 = 10
可以在任何递归数据类型上归纳此类操作。
以下是foldr功能的签名：
foldr :: ((a -> b -> b), b) -> [a] -> b
请注意，我已经使用花括号将前两个参数与最后一个参数分开。这不是真正的foldr函数，但是它是同构的（也就是说，您可以轻松地从另一个函数中获取一个，反之亦然）。部分应用foldr将具有以下签名：
foldr ((+), 0) :: [Int] -> Int
我们可以看到这是一个接受整数列表并返回单个整数的函数。让我们根据IntList类型定义此类函数。
sumFold :: IntList -> Int
sumFold Nil = 0
sumFold (Cons x xs) = x + sumFold xs
我们看到，这个功能由两个部分组成：第一部分定义这个函数的行为Nil的一部分IntList，而第二部分定义的函数的行为Cons的一部分。
现在假设我们不是用Haskell编程，而是使用某种允许直接在类型签名中使用代数类型的语言（嗯，从技术上讲，Haskell允许通过元组和Either a b数据类型使用代数类型，但这会导致不必要的冗长）。考虑一个函数：
reductor :: () | (Int × Int) -> Int
reductor () = 0
reductor (x, s) = x + s
可以看出，它reductor是type的函数F1 Int -> Int，就像F代数的定义一样！实际上，这对(Int, reductor)是F1代数。
因为IntList是初始F1-代数，对于每种类型T和每个功能r :: F1 T -> T存在的功能，称为catamorphism为r，它转换IntList到T，并且这样的功能是唯一的。事实上，在我们的例子为catamorphism reductor是sumFold。请注意reductor和sumFold的相似之处：它们的结构几乎相同！在reductor定义中，s参数用法（其类型对应于T）对应于计算结果的使用sumFold xs中sumFold的定义。
只是为了使其更清楚并帮助您了解图案，这是另一个示例，我们再次从生成的折叠功能开始。考虑append将第一个参数附加到第二个参数的函数：
(append [4, 5, 6]) [1, 2, 3] = (foldr (:) [4, 5, 6]) [1, 2, 3] -> [1, 2, 3, 4, 5, 6]
这在我们的外观IntList：
appendFold :: IntList -> IntList -> IntList
appendFold ys () = ys
appendFold ys (Cons x xs) = x : appendFold ys xs
同样，让我们尝试写出减速器：
appendReductor :: IntList -> () | (Int × IntList) -> IntList
appendReductor ys () = ys
appendReductor ys (x, rs) = x : rs
appendFold是appendReductor转化IntList为的变形IntList。
因此，从本质上讲，F代数允许我们在递归数据结构上定义“折叠”，即，将我们的结构缩小至一定值的运算。
F-coalgebras
F-代数是F-代数的所谓“双重”术语。它们使我们能够定义unfolds递归数据类型，即从某种值构造递归结构的方法。
假设您具有以下类型：
data IntStream = Cons (Int, IntStream)
这是一个无限的整数流。其唯一的构造函数具有以下类型：
Cons :: (Int, IntStream) -> IntStream
或者，就集合而言
Cons :: Int × IntStream -> IntStream
Haskell允许您对数据构造函数进行模式匹配，因此您可以定义在IntStreams上运行的以下函数：
head :: IntStream -> Int
head (Cons (x, xs)) = x
tail :: IntStream -> IntStream
tail (Cons (x, xs)) = xs
您自然可以将这些函数“连接”为type的单个函数IntStream -> Int × IntStream：
head&tail :: IntStream -> Int × IntStream
head&tail (Cons (x, xs)) = (x, xs)
注意函数的结果如何与我们的IntStream类型的代数表示相一致。对于其他递归数据类型，也可以执行类似的操作。也许您已经注意到了这种模式。我指的是类型的功能族
g :: T -> F T
哪里T是某种类型。从现在开始，我们将定义
F1 T = Int × T
现在，F-coalgebra是一对(T, g)，其中T是类型，g是type 的函数g :: T -> F T。例如，(IntStream, head&tail)是F1代数。再次，就像在F代数中一样，g并且T可以是任意的，例如，(String, h :: String -> Int x String)F1代数也是h。
在所有F代数中，有所谓的末端F代数，它是初始F代数的对偶。例如，IntStream是终端F-coalgebra。这意味着，对于每种类型T和每个函数p :: T -> F1 T，都有一个称为anamorphism的函数，该函数转换T为IntStream，并且该函数是唯一的。
考虑以下函数，该函数从给定的整数开始生成连续的整数流：
nats :: Int -> IntStream
nats n = Cons (n, nats (n+1))
现在让我们检查一个函数natsBuilder :: Int -> F1 Int，即natsBuilder :: Int -> Int × Int：
natsBuilder :: Int -> Int × Int
natsBuilder n = (n, n+1)
同样，我们可以看到nats和之间有一些相似之处natsBuilder。这与我们之前观察到的减速器和折痕的连接非常相似。nats是的变形natsBuilder。
另一个示例是一个函数，该函数接受一个值和一个函数，并将该函数的连续应用程序流返回到该值：
iterate :: (Int -> Int) -> Int -> IntStream
iterate f n = Cons (n, iterate f (f n))
其构建器功能如下：
iterateBuilder :: (Int -> Int) -> Int -> Int × Int
iterateBuilder f n = (n, f n)
然后iterate是的变形iterateBuilder。
结论
因此，简而言之，F代数允许定义折叠，也就是将递归结构缩减为单个值的运算，而F代数允许相反的事情：从单个值构造一个[潜在]无限的结构。
实际上，在Haskell中，F代数和F代数是重合的。这是一个非常好的属性，这是每种类型中都存在“底部”值的结果。因此，在Haskell中，可以为每种递归类型创建折叠和展开。但是，其背后的理论模型比我上面介绍的模型更复杂，因此我特意避免了它。
希望这可以帮助。
）