Haskell 是哈斯克尔'；s`Const`函子类似于范畴论中的常数函子？_Haskell_Functor_Category Theory_Phantom Types

Haskell 是哈斯克尔'；s`Const`函子类似于范畴论中的常数函子？

haskell

Haskell 是哈斯克尔'；s`Const`函子类似于范畴论中的常数函子？,haskell,functor,category-theory,phantom-types,Haskell,Functor,Category Theory,Phantom Types,我知道Haskell中的许多名字都受到范畴理论术语的启发，我正试图准确地理解类比的起点和终点类别Hask 我已经知道了，因为一些关于严格/懒惰和seq的技术细节，但现在我们暂且不谈。为清楚起见的对象是具体类型，即类型*。这包括像Int->[Char]这样的函数类型，但不包括像Maybe:：*->*这样需要类型参数的任何类型。但是，具体类型可能是Int:：*属于Hask。类型构造函数/多态函数更像自然变换（或从Hask到自身的其他更一般的映射），而不是态射 Hask的态射是Haskell函数

我知道Haskell中的许多名字都受到范畴理论术语的启发，我正试图准确地理解类比的起点和终点

类别

Hask

我已经知道了，因为一些关于严格/懒惰和

seq

的技术细节，但现在我们暂且不谈。为清楚起见

的对象是具体类型，即类型
```
*
```
。这包括像
```
Int->[Char]
```
这样的函数类型，但不包括像
```
Maybe:：*->*
```
这样需要类型参数的任何类型。但是，具体类型
```
可能是Int:：*
```
属于
```
Hask
```
。类型构造函数/多态函数更像自然变换（或从
```
Hask
```
到自身的其他更一般的映射），而不是态射
```
Hask
```
的态射是Haskell函数。对于两种具体类型
```
A
```
和
```
B
```
，hom集合
```
hom（A，B）
```
是具有签名
```
A->B
```
的函数集合
函数组合由
```
f给出。g
```
。如果我们担心严格，我们可能需要严格或小心函数的定义

函子

s是Hask中的内函子我不认为上面的技术细节与我下面的困惑有任何关系。我想我明白这意味着什么。也就是说，如果我们有

类函子（F:：*->*），其中
fmap:：（a->b）->F a->F b
--可能会将类型T发送到（可能是T）
数据可能是a=无|只是a
实例函子可能在哪里
fmap f（正好x）=正好（fx）
fmap uuo无=无

函子

实例

可能

以以下方式对应于从

Hask

到

Hask

的函子：

对于
```
Hask
```
中的每个具体类型
```
a
```
，我们指定具体类型
```
可能是a
```

对于

Hask

中的每一个态射

f:：A->B

，我们分配态射

可能A->可能B

，它不发送

任何内容↦ 没有

和

只有x↦ 只有（f x）

常数（内）函子 C类上的函数是一个函子

ΔC:C→ C

将C类的每个对象映射到固定对象

C∈C

和C到恒等态射的每个态射

id\u C:C→ c

用于固定对象

常量

函子

考虑一下。为了清楚起见，我将在这里重新定义它，区分类型构造函数

Konst:：*->*->*

和数据构造函数

Const:：For all a，b。a->Konst a b

newtype Konst a b=Const{getConst:：a}
实例函子（Konst m），其中
fmap:：（a->b）->Konst m a->Konst m b
fmap u（常数v）=常数v

此类型检查是因为数据构造函数

Const

是多态的：

v:：a
（Const v）：：全部b。康斯特a b酒店

我可以相信

konstm

是

Hask

类别中的内函子，因为在

fmap

的实现中

在左侧，
```
Const v
```
显示为
```
Konst ma
```
，由于多态性，这是正常的
在右侧，
```
Const v
```
显示为一个
```
Konst mb
```
，由于多态性，这是正常的

但是如果我们试着把

konstm::*->*

看作范畴论意义上的常量函子，我的理解就会崩溃

什么是固定对象？类型构造函数
```
Konst m
```
接受一些具体类型
```
a
```
，并给我们一个
```
Konst ma
```
，至少表面上，对于每个
```
a
```
，它是一个不同的具体类型。我们确实希望将每个类型
```
a
```
映射到固定类型
```
m
```
根据类型签名，
```
fmap
```
接受一个
```
f:：a->b
```
并给我们一个
```
konstma->konstmb
```
。如果
```
konstm
```
类似于常量函子，
```
fmap
```
需要将每个态射发送到固定类型
```
m
```
上的身份态射
```
id:：m->m
```

问题因此，以下是我的问题：

Haskell的常量函子与范畴论中的常量函子有什么相似之处

如果这两个概念是不等价的，那么是否有可能用Haskell代码来表示范畴论常数函子（称之为

SimpleConst

？我快速尝试了一下，在多态性wrt幻影类型方面遇到了与上面相同的问题：

data SimpleKonst a=SimpleConst Int
实例函子SimpleConst，其中
fmap:：（a->b）->SimpleConst a->SimpleConst b
fmap(SimpleConst x)=(SimpleConst x)

如果#2的答案是肯定的，如果是的话，在范畴论意义上，两个Haskell函数以何种方式相关？也就是说，

SimpleConst

在Haskell中是

Const

，就像常量函子在范畴论中是


幻影类型是否会对将Hask
视为一个类别造成问题？我们是否需要修改Hask的定义，使对象真正成为类型的等价类，如果不存在幻象类型参数，这些类型将是相同的

编辑：自然同构？
它看起来像多态函数getConst:：for all a，b。konstab->a
是自然同构η的候选：（konstm）⇒ Δm

从函子

Konst m

到常量函子

Δm:Hask→ Hask

，尽管我还不能确定后者是否可以在Has中表达

type CF m a = m

constIso1 :: Konst x a -> x
constIso1 (Const x) = x
constIso2 :: x -> Konst x a
constIso2 = Const

type family FunctorTyM f a :: Type
class FunctorMphM f where
  fmap' :: (a -> b) -> FunctorTyM f a -> FunctorTyM f b

data KonstFtor a
type instance FunctorTyM (KonstFtor a) b = a
instance FunctorMphM (KonstFtor a) where
  fmap' _ = id

data IdentityFtor
type instance FunctorTyM IdentityFtor a = a
instance FunctorMphM IdentityFtor where
  fmap' f = f

data ListFtor
type instance FunctorTyM ListFtor a = [a]
instance FunctorMphM ListFtor where
  fmap' f = map f

{-# LANGUAGE TypeFamilies, AllowAmbiguousTypes, TypeApplications #-}

type family FunctorTyM f a
class FunctorMphM f where ...

data KonstFtor a
...

data IdentityFtor
...

data ListFtor
...

main :: IO ()
main = do
  print (fmap' @(KonstFtor Int) (+2) 5)
  print (fmap' @IdentityFtor (+2) 5)
  print (fmap' @ListFtor (+2) [7,8,9])

5
7
[9,10,11]

data TupleFstConst a
type instance FunctorTyM (TupleFstConst a) b = (a,b)
instance FunctorMphM (TupleFstConst a) where
  fmap' f (x,y) = (x, f y)

data TupleSndConst b
type instance FunctorTyM (TupleSndConst b) a = (a,b)
instance FunctorMphM (TupleSndConst b) where
  fmap' f (x,y) = (f x, y)

data TupleFtor
type instance FunctorTyM TupleFtor a = (a,a)
instance FunctorMphM TupleFtor where
  fmap' f (x,y) = (f x, f y)

main :: IO ()
main = do
  print (fmap' @(TupleFstConst Int) (+2) (5,50))
  print (fmap' @(TupleSndConst Int) (+2) (5,50))
  print (fmap' @TupleFtor           (+2) (5,50))

(5,52) (7,50) (7,52)