`refold:: Functor s => (a -> sa, a) -> (sb -> b) -> b` 作为通用类型之间的态射

Question

各种递归方案归结为refold的特定实例

refold :: Functor s => (s b -> b) -> (a -> s a) -> a -> b
refold f g = go where go a = f (fmap go (g a))

refold的有意义的解释是什么？

数据类型data Nu f = forall a. Nu (a -> fa) a data Nu f = forall a. Nu (a -> fa) a and newtype Mu f = Mu {unMu:: forall b. (fb -> b) -> b} newtype Mu f = Mu {unMu:: forall b. (fb -> b) -> b}可以看作是余数和代数中遗忘函子的余极限和极限，而refold是它们之间的态射，但它是否阐明了refold ？

refold' :: forall s. Functor s => Nu s -> Mu s
refold' (Nu g (a :: a)) = Mu mu where

  mu :: forall b. (s b -> b) -> b
  mu f = go a where

    go :: a -> b
    go a = f (fmap go (g a))

Answer 1

我想这取决于您所说的“有意义的解释”是什么意思。

如果s是递归数据类型和核心递归余数据类型的基本函子，例如递归列表数据类型[e]的以下函子s ~ ListF e （在 Haskell 中，它也是核心递归流余数据类型）：

{-# LANGUAGE DeriveFunctor #-}
data ListF e b = Nil | Cons e b deriving (Show, Functor)

那么a -> sa类型的s -coalgebra 与起始种子a可以通过从该种子展开来生成 codata 类型[e]的值，而sb -> b类型的s -algebra 可以使用 data 的值通过折叠成b类型的值来输入[e] 。 refold函数只是结合了从a展开和折叠到b的操作。

例如，您可以通过使用起始值/代数对(a,g)从Integer种子展开来生成（有限）余数据流[10,9..1] ，如下所示：

a :: Integer
a = 10

g :: Integer -> (ListF Integer) Integer
g 0 = Nil
g n = Cons n (n-1)

并折叠一个列表以使用代数计算其Int长度：

f :: (ListF Integer) Int -> Int
f Nil = 0
f (Cons _ b) = 1 + b

refold函数只是结合了这些操作：

main = print $ refold f g a

在这种特殊情况下，它会计算 steam/list [1..10]的长度10 。

我猜直觉是，如果一个操作可以想象为一个 F-recursion 应用于同一个函子 F 的 F-corecursion，那么它就是一个refold 。

在实践中， refold不仅用作通用数据类型之间的态射，而且如果您有与函子s关联的余数据类型C的最终s-coalgebra：

eatC :: C -> ListF Integer C

以及数据类型D的初始s 代数也与函子s相关联：

makeD :: ListF Integer D -> D

那么refold makeD eatC应该是从 codata 类型C到数据类型D的自然态射。 也就是说，它应该是满足的唯一态射：

fmap h . refold makeD eatC = refold makeD eatC . fmap h

我不确定这方面是否非常有趣......

Answer 2

一些评论（我认为这是有效的 - 不要犹豫更正 - 我不是语义专家）：

• 正如@chi 建议的那样，非终止允许写任何东西。 将s作为恒等函子，然后refold读作refold:: (b -> b) -> (a -> a) -> a -> b这看起来确实像是一个悖论。 因此，对于要“逻辑地”读取的任何 haskell 类型，我们可能需要隐藏的附加条件。

我们甚至不需要递归来遇到悖论/非终止

-- N. P. Mendler. Recursive types and type constraints in second-order lambda calculus. In LICS, pages 30–36. IEEE Computer Society, 1987
data T a = C (T a -> ())

p :: T a -> (T a ->() )
p (C f) = f

w :: T a -> ()
w x = (p x) x

• 初始代数，如monads和其他概念，发生在两个层面上，一个在语言的语义中，另一个明确地在我们编写的程序中。 例如数据的语义data ListInt = [] | Int * ListInt data ListInt = [] | Int * ListInt是一个初始代数。 并且，在 haskell 中，在语义上也是一个最终的余代数。 这就是你可能听到的“Mu = Nu”，这个自相矛盾的等式恰好在 haskell 的语义中。这里的Mu与data Mu f =..无关。 当我们编写type ListInt = Fix ListIntF where data Fix f = Fix (f (Fix f))我们在程序中模拟该语义时，也会发生同样的情况，但这本身受制于 Haskell 的语义（实际上，这（初始algebra) 与语义Mu和Nu相同并且等于两者，因为 haskell 等同于它们）。 在某种程度上，通过编写data Mu f =...和data Nu f =..我们正在“窃取”（并且有义务这样做）haskell 语义的一部分，并将其与我们自己的（正确表达通用 co -cone Nu f和通用锥Mu f ），试图为递归提供嵌入（就像我们对 HOAS 所做的那样，我们从 Haskell 窃取绑定）。 但是我们不能没有悖论就逃脱，因为我们有义务窃取“Mu = Nu”。

  这导致非常有用但非常“不合逻辑”的 function 像refold

• 通过写fold: Functor s => (fa -> a) -> Fix s -> a我们假装f的初始代数总是存在，这可能转化为非终止

明确地说，我们可以用两种不同的方式来看待refold 。 有点啰嗦，但我们这里是 go：

• refold可以看作是一个合适的 function refold refold:: Functor s => (sb -> b) -> (a -> sa) -> a -> b稍后详述

• refold'可以看作是载体refold':: forall s. Functor s => Nu s -> Mu s refold':: forall s. Functor s => Nu s -> Mu s Twisted(Hask)中代数的 Mu s，其对象是Hask中的态射。 所以 refold refold'是一个 object，不是这个类别的态射。 现在，类别C （此处Hask ）中的每个函子s通过应用于箭头在Twisted(C)上引入函子s' 。 最后Twisted中的态射

   `s' refold' -(out,in)-> refold'`

  是初始代数s' ，其中out是“最终”代数Nu s -> s (Nu s) ， in是“初始”代数Mu s -> s (Mu s)

现在function refold的动作是，给定一个余数和一个代数（在Hask中，但可以在其他地方），从余数的载体返回唯一的态射，然后是refold' ，然后是初始的唯一态射代数。 这是一个正确的function ，它来自于在给定组件处选择通用 (co) 锥体的组件。

这解释了为什么当我们将最终的代数out并将初始代数in refold时，我们会返回refold'本身。 pre 和 post compose refold'的唯一态射是恒等式。

很难看出什么是什么，因为我们在Hask中工作，其中所有内容都是 function。有些态射实际上是关于我们工作的类别（可能是Hask以外的其他东西），有些态射实际上是函数，即使我们选择另一个类别。

由于不终止，知道什么是refold的解决方案必须符合 haskell 的语义，并使用完整的偏序（或以某种方式限制s ）。

所以我想refold的真正含义可以从refold'的真正含义推导出来，这只是一个初始代数，所有标准警告都来自 haskell 语义线程。