Scala 什么是；“煤球”；在编程环境中是什么意思？

我在函数编程和PLT圈中多次听到“coalgebras”一词，特别是当讨论对象、comonads、lens等时。用谷歌搜索这个术语会得到一些页面，这些页面给出了这些结构的数学描述，这对我来说几乎是不可理解的。有谁能解释一下coalgebras在编程环境中的含义，它们的意义是什么，以及它们与对象和余元的关系吗？

阅读教程论文应该会让你对计算机科学中的余代数有一些了解

下面是一篇引文，让你相信

一般来说，某些编程语言中的程序处理数据。在 计算机科学的发展在过去的几十年里，一个抽象的 对这些数据的描述是可取的，例如，以确保一个人的程序不依赖于它所操作的数据的特定表示。而且，这种抽象性有助于正确性证明。
这种愿望导致了代数方法在计算机科学中的应用，在一个称为代数规范或抽象数据类型理论的分支中。研究的对象是数据类型本身，使用从代数中熟悉的技术概念。计算机科学家使用的数据类型通常由给定的（构造函数）操作集合生成，正是由于这个原因，代数的“初始性”起着如此重要的作用。
事实证明，标准代数技术在捕获计算机科学中使用的数据结构的各个基本方面是有用的。但事实证明，很难用代数方法描述计算中出现的一些固有的动力学结构。这种结构通常涉及一种状态概念，这种概念可以通过各种方式进行转换。这种基于状态的动态系统的形式化方法通常使用自动机或过渡系统，如早期的经典参考。
在过去十年中，人们逐渐认识到，这种基于状态的系统不应该被描述为代数，而是所谓的协代数。这些是代数的形式对偶，在本教程中将以一种精确的方式给出。代数的“初始性”的对偶性质，即终结性，对于这类共代数至关重要。这种最终的共代数所需要的逻辑推理原则不是归纳，而是共归纳

---

序曲，关于范畴理论。 范畴论应该是函子的更名理论。 因为类别是定义函子必须定义的。 （此外，为了定义自然变换，必须定义函子。）

什么是函子？ 这是一个从一个集合到另一个集合的转换，保持了它们的结构。 （关于更多细节，网上有很多很好的描述）

什么是F-代数？ 这是函子的代数。 这只是研究函子的普遍性

如何将其与计算机科学联系起来？ 程序可以被看作是一组结构化的信息。 程序的执行对应于对这组结构化信息的修改。 执行应该保留程序结构，这听起来不错。 然后，可以将执行视为函子对这组信息的应用。 （定义程序的那个）

为什么是F-co-代数？ 程序本质上是双重的，因为它们是由信息描述的，并根据信息进行操作。 然后，主要可以通过两种方式查看组成程序并对其进行更改的信息

• 可定义为程序正在处理的信息的数据
• 可定义为程序共享的信息的状态

那么在这个阶段，我想说

• F-代数是研究作用于数据宇宙的函数变换（定义见此处）
• F-co-代数是研究作用于状态宇宙的函数变换（定义见本文）

在程序的生命周期中，数据和状态共存，并且它们相互完成。 它们是对偶的。

代数 我认为首先应该理解代数的概念。这只是代数结构的推广，如群、环、幺半群等等。大多数情况下，这些东西都是以集合的形式介绍的，但由于我们是朋友，所以我将讨论Haskell类型。（我忍不住用了一些希腊字母，尽管它们让一切看起来都很酷！）

那么，代数就是一种具有某些函数和恒等式的类型

τ
。这些函数采用不同数量的
τ
类型的参数，并生成
τ
：未加载波，它们看起来都像
（τ，τ，…，τ）→ τ
。它们还可以具有“恒等式”——
τ
元素，这些元素对某些函数具有特殊行为

最简单的例子是幺半群。幺半群是任何类型的
τ
，具有函数
mappend∷ (τ, τ) → τ
和一个恒等式
mzero∷ τ
。其他的例子包括像群这样的东西（除了有一个额外的
反转外，它们就像幺半群一样）∷ τ → τ
函数）、环、格等

所有函数都在τ上运行，但可以有不同的算术运算。我们可以把它们写成
τⁿ → τ
，其中
τⁿ
映射到
n
τ
的元组。这样，将恒等式视为
τ是有意义的⁰ → τ
其中
τ⁰
只是空元组
（）
。所以我们现在可以简化代数的概念：它只是一些类型，上面有一些函数

代数只是数学中的一种常见模式
op ∷ Monoid τ ⇒ Either (τ, τ) () → τ
op (Left (a, b)) = mappend (a, b)
op (Right ())    = mempty

data MonoidArgument τ = Mappend τ τ -- here τ τ is the same as (τ, τ)
                      | Mempty      -- here we can just leave the () out

instance Functor MonoidArgument where
  fmap f (Mappend τ τ) = Mappend (f τ) (f τ)
  fmap f Mempty        = Mempty

class Functor f ⇒ Algebra f τ where
  op ∷ f τ → τ

class Functor f ⇒ CoAlgebra f τ where
  coop ∷ τ → f τ

both ∷ τ → (a, b)
both x = (f x, g x)

class C
  private
    x, y  : Int
    _name : String
  public
    name        : String
    position    : (Int, Int)
    setPosition : (Int, Int) → C

data C = Obj { x, y  ∷ Int
             , _name ∷ String }

position ∷ C → (Int, Int)
position self = (x self, y self)

name ∷ C → String
name self = _name self

setPosition ∷ C → (Int, Int) → C
setPosition self (newX, newY) = self { x = newX, y = newY }

coop ∷ C → ((Int, Int), String, (Int, Int) → C)
coop self = (position self, name self, setPosition self)

map      ∷ (α → β) → (M α → M β)
return   ∷ α → M α
join     ∷ M (M α) → M α

instance (Functor f, Functor g) ⇒ Functor (f ∘ g) where
  fmap fun x = fmap (fmap fun) x

class Functor f ⇒ Comonad f where
  coreturn ∷ f α → α
  cojoin   ∷ f α → f (f α)

data IntList = Nil | Cons (Int, IntList)

Nil  :: () -> IntList
Cons :: (Int, IntList) -> IntList

Nil  :: 1 -> IntList
Cons :: Int × IntList -> IntList

Nil|Cons :: 1 | (Int × IntList) -> IntList

data IntTree = Leaf Int | Branch (IntTree, IntTree)

Leaf   :: Int -> IntTree
Branch :: (IntTree, IntTree) -> IntTree

Leaf|Branch :: Int | (IntTree × IntTree) -> IntTree

f :: F T -> T

F1 T = 1 | (Int × T)
F2 T = Int | (T × T)

foldr (+) 0 [1, 2, 3, 4] -> 1 + 2 + 3 + 4 = 10

foldr :: ((a -> b -> b), b) -> [a] -> b

foldr ((+), 0) :: [Int] -> Int

sumFold :: IntList -> Int
sumFold Nil         = 0
sumFold (Cons x xs) = x + sumFold xs

reductor :: () | (Int × Int) -> Int
reductor ()     = 0
reductor (x, s) = x + s

(append [4, 5, 6]) [1, 2, 3] = (foldr (:) [4, 5, 6]) [1, 2, 3] -> [1, 2, 3, 4, 5, 6]

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

data IntStream = Cons (Int, IntStream)

Cons :: (Int, IntStream) -> IntStream

Cons :: Int × IntStream -> IntStream

head :: IntStream -> Int
head (Cons (x, xs)) = x

tail :: IntStream -> IntStream
tail (Cons (x, xs)) = xs

head&tail :: IntStream -> Int × IntStream
head&tail (Cons (x, xs)) = (x, xs)

g :: T -> F T

F1 T = Int × T

nats :: Int -> IntStream
nats n = Cons (n, nats (n+1))

natsBuilder :: Int -> Int × Int
natsBuilder n = (n, n+1)

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)

 let (pi : int list) = (* some function which computes the digits of
 π. *)

let print_third_element (k : int list) =   match k with
     | _ :: _ :: thd :: tl -> print thd


 print_third_element pi