Haskell 这个使用RankNTypes的函子叫什么名字？

在PlayAround包中，我注意到以下类型具有有趣的特性

> {-# LANGUAGE RankNTypes #-}
> data N f r = N { unN :: forall x. f x -> (x, r) }

它是一个函子

> instance Functor (N f) where
>    fmap f (N nat) = N $ fmap (fmap f) nat
>          -- or,   = N $ \fx -> let { (x,a) = nat fx } in (x, f a)

经过几个小时的google/hoogle搜索，我放弃了寻找 包含此类型的现有模块。 这是什么类型的？如果它是众所周知的，它的名字是什么？这有用还是因为没用而被忽略

这不是我100%的原始创建，因为N是从objective包中找到的对象派生的

> data Object f g = Object {
>     runObject :: forall x. f x -> g (x, Object f g)
>   }

nf

是一个函子，当Fix应用于对象时，它产生

Object f Identity

---

下面是一个关于这种类型的事实，以及为什么我认为它很有趣

N将读卡器转换为写卡器，反之亦然。 （这里我使用（=）符号表示类型之间的同构）

N将存储区comonad转换为状态monad，但反向不是真的

> data Store s a = Store s (s -> a)
> type State s a = s -> (s, a)

N (Store s) r
 = forall x. (s, (s -> x)) -> (x, r)
 = forall x. s -> (s -> x) -> (x, r)
 = s -> (s, r)
 = State s r

N (State s) r
 = forall x. (s -> (s, x)) -> (x, r)
 = forall x. (s -> s, s -> x) -> (x, r)
 = forall x. (s -> s) -> (s -> x) -> (x, r)
 = (s -> s) -> (s, r)  -- ???

我受不了

N Maybe r
 = forall x. Maybe x -> (x, r)
 = forall x. (() -> (x, r), x -> (x, r))
 = Void     -- because (() -> (x, r)) can't be implemented

以下功能可能很有趣。我做不到，相反

> data Cofree f a = Cofree a (f (Cofree f a))
> data Free f a = Pure a | Wrap (f (Free f a))

> unfree :: Free (N f) r -> N (Cofree f) r
> unfree (Pure r) = N $ \(Cofree a _) -> (a, r)
> unfree (Wrap n_f) = N $
>   \(Cofree _ f) -> let (cofree', free') = unN n_f f
>                    in unN (unfree free') cofree'

整个帖子都是识字的Haskell（.lhs）。

我称它为“handler”函子<代码>对象在我发布目标之前，通常使用处理函数functor定义

---

是的，这个函子很有趣--

Cofree（处理程序f）

有一个公共getter，而

Free（处理程序f）

是一个公共getter。也许我应该发布处理函数…

虽然它已经得到了回答，但我自己找到了这个问题的另一个答案

Type

N

是类型类

配对的值级别表示，在下面的文章中进行了描述

> instance Pairing f g => Pairing (Free f) (Cofree g) where
>   pair = undefined -- see link above



（此处配对称为双配对）

配对和
N
是一样的
配对的定义是这样的

> class Pairing f g where
>   pair :: (a -> b -> c) -> f a -> g b -> c

f
和
nf
是配对

> instance Pairing f (N f) where
>   pair k fa nb = uncurry k $ unN nb fa

N
可以用配对来表示

> data Counterpart f r = forall g. Pairing f g => Counterpart (g r)
>
> iso1 :: N f r -> Counterpart f r
> iso1 = Counterpart
>
> iso2 :: Counterpart f r -> N f r
> iso2 (Counterpart gr) = N $ \fx -> pair (,) fx gr

有一个Free vs Cofree实例，对应于my
unfree
。
文章中还定义了其他有趣的实例

> instance Pairing f g => Pairing (Free f) (Cofree g) where
>   pair = undefined -- see link above

扩展配对到配对M到对象
前一篇文章将配对扩展为在Monad m中进行计算

> class PairingM f g m | f -> g, g -> f where
>   pairM :: (a -> b -> m r) -> f a -> g b -> m r

如果我们将PairingM重写为类似于N的形式，我们将再次得到该对象

> -- Monad m => HandlerM' f m r ~ HandlerM f m r
> data HandlerM' f m r = forall g. PairingM f g m => HandlerM' (g r)
> data HandlerM f m r = HandleM { runHandlerM :: forall x. f x -> m (x, r) }
>
> -- Fix (HandlerM f m) ~ Object f m
> -- Free (HandlerM f m) ~ (mortal Object from f to m)

我不知道它的名字，但是把它写成
（对于所有的x.fx->（，）r）x）
，它就变成了可以传递给
Control.Comonad.Cofree.wingfree
@chi在
N
中没有
g
。它在
Object f g
中设置
g~标识
。如果您从所有x的
中删除无趣的
标识
s`。fx->Identity（x，对象f Identity）
您将获得所有x的
。fx->（x，对象f）
。如果用新参数
r
替换对象f

的递归出现，则得到所有x的

。fx->（x，r）

，即

nfr

Fix（nf）

将递归引用放回

r

所在的位置。这看起来像，但混合和匹配了proFunctor和biFunctor<代码>用于所有x。fx->x是

f

的索引。另一部分是来自

forall x环境的读者。f x

，阅读

f

的结构，但不阅读其值。@Gurkenglas和@Cirdec，感谢您的评论

Ran

似乎能够表示

N

，但这不是Ran应该使用的方式（与ProFunctor一起使用，如

（>）

），而是与双Functor一起使用

（fx，a）

和

（x，b）

。如果我有误解，请纠正我，我没有学习范畴理论，但很少有人的博客文章。