什么是索引 monad？
What is indexed monad?
什么是 indexed monad 以及这个 monad 的动机？
我读到它有助于跟踪副作用。但是类型签名和文档并没有把我带到任何地方。
什么是它如何帮助跟踪副作用的示例（或任何其他有效示例）？
作为一个简单的场景，假设您有一个状态 monad。状态类型是一个复杂的大类型，但所有这些状态都可以分为两组：红色和蓝色状态。仅当当前状态为蓝色状态时，此 monad 中的某些操作才有意义。其中，一些会使状态保持蓝色 (blueToBlue)，而另一些会使状态变为红色 (blueToRed)。在常规的 monad 中，我们可以写
blueToRed :: State S ()
blueToBlue :: State S ()
foo :: State S ()
foo = do blueToRed
blueToBlue
触发运行时错误，因为第二个操作需要蓝色状态。我们想静态地防止这种情况。索引 monad 实现了这个目标：
data Red
data Blue
-- assume a new indexed State monad
blueToRed :: State S Blue Red ()
blueToBlue :: State S Blue Blue ()
foo :: State S ?? ?? ()
foo = blueToRed `ibind` \_ ->
blueToBlue -- type error
由于blueToRed（Red）的第二个索引与blueToBlue（Blue）的第一个索引不同而触发类型错误。
作为另一个示例，使用索引 monad，您可以允许状态 monad 更改其状态的类型，例如你可以
data State old new a = State (old -> (new, a))
您可以使用上面的方法构建一个状态，它是一个静态类型的异构堆栈。操作的类型为
push :: a -> State old (a,old) ()
pop :: State (a,new) new a
作为另一个例子，假设你想要一个受限的 IO monad，它不
允许文件访问。您可以使用例如
openFile :: IO any FilesAccessed ()
newIORef :: a -> IO any any (IORef a)
-- no operation of type :: IO any NoAccess _
通过这种方式，具有类型 IO ... NoAccess () 的操作静态地保证是无文件访问的。相反，IO ... FilesAccessed () 类型的操作可以访问文件。拥有索引 monad 意味着您不必为受限 IO 构建单独的类型，这将需要在两种 IO 类型中复制每个非文件相关的函数。
索引 monad 不是特定的 monad，例如状态 monad，而是带有额外类型参数的 monad 概念的一种概括。
而 "standard" monadic 值具有 Monad m => m a 类型，索引 monad 中的值将是 IndexedMonad m => m i j a 其中 i 和 j 是索引类型因此 i 是 monadic 计算开始时索引的类型，而 j 是计算结束时的索引类型。在某种程度上，您可以将 i 视为一种输入类型，将 j 视为输出类型。
以State为例，有状态计算State s a在整个计算过程中保持s类型的状态和returns类型a的结果].索引版本 IndexedState i j a 是一种有状态计算，其中状态可以在计算期间更改为不同的类型。初始状态的类型为 i 和状态，计算结束的类型为 j.
很少需要在普通 monad 上使用索引 monad，但在某些情况下可以使用它来编码更严格的静态保证。
一如既往，人们使用的术语并不完全一致。有多种受 monad 启发但严格来说并不完全是概念。术语“索引 monad”是用于描述此类概念的众多术语（包括“monadish”和“参数化 monad”（Atkey 对它们的名称））之一。 （另一个这样的概念，如果你感兴趣的话，是 Katsumata 的“参数效果单子”，由一个幺半群索引，其中 return 被中性索引并且 bind 在它的索引中累积。）
首先，让我们检查种类。
IxMonad (m :: state -> state -> * -> *)
也就是说，“计算”（或“动作”，如果你愿意，但我会坚持使用“计算”）的类型，看起来像
m before after value
其中 before, after :: state 和 value :: *。这个想法是捕获与具有某些 可预测 状态概念的外部系统安全交互的方法。一个计算的类型告诉你它运行的状态必须是什么 before ，它运行的状态是什么 after 以及（就像 * 上的常规单子一样）什么类型的 values 计算结果。
通常的点点滴滴 * 像 monad 和 state 像玩多米诺骨牌。
ireturn :: a -> m i i a -- returning a pure value preserves state
ibind :: m i j a -> -- we can go from i to j and get an a, thence
(a -> m j k b) -- we can go from j to k and get a b, therefore
-> m i k b -- we can indeed go from i to k and get a b
由此产生的“克莱斯利箭头”（产生计算的函数）的概念是
a -> m i j b -- values a in, b out; state transition i to j
我们得到一个组合
icomp :: IxMonad m => (b -> m j k c) -> (a -> m i j b) -> a -> m i k c
icomp f g = \ a -> ibind (g a) f
而且，一如既往，法律确实确保 ireturn 和 icomp 给我们一个类别
ireturn `icomp` g = g
f `icomp` ireturn = f
(f `icomp` g) `icomp` h = f `icomp` (g `icomp` h)
或者，在假喜剧中 C/Java/whatever，
g(); skip = g()
skip; f() = f()
{h(); g()}; f() = h(); {g(); f()}
何必呢？为交互的“规则”建模。例如，如果驱动器中没有 DVD，则无法弹出；如果驱动器中已有 DVD，则无法将 DVD 放入驱动器。所以
data DVDDrive :: Bool -> Bool -> * -> * where -- Bool is "drive full?"
DReturn :: a -> DVDDrive i i a
DInsert :: DVD -> -- you have a DVD
DVDDrive True k a -> -- you know how to continue full
DVDDrive False k a -- so you can insert from empty
DEject :: (DVD -> -- once you receive a DVD
DVDDrive False k a) -> -- you know how to continue empty
DVDDrive True k a -- so you can eject when full
instance IxMonad DVDDrive where -- put these methods where they need to go
ireturn = DReturn -- so this goes somewhere else
ibind (DReturn a) k = k a
ibind (DInsert dvd j) k = DInsert dvd (ibind j k)
ibind (DEject j) k = DEject j $ \ dvd -> ibind (j dvd) k
有了这个，我们可以定义“原始”命令
dInsert :: DVD -> DVDDrive False True ()
dInsert dvd = DInsert dvd $ DReturn ()
dEject :: DVDrive True False DVD
dEject = DEject $ \ dvd -> DReturn dvd
其他人用ireturn和ibind组装而成。现在，我可以写（借用 do-符号）
discSwap :: DVD -> DVDDrive True True DVD
discSwap dvd = do dvd' <- dEject; dInsert dvd ; ireturn dvd'
但并非物理上不可能
discSwap :: DVD -> DVDDrive True True DVD
discSwap dvd = do dInsert dvd; dEject -- ouch!
或者，可以直接定义自己的原始命令
data DVDCommand :: Bool -> Bool -> * -> * where
InsertC :: DVD -> DVDCommand False True ()
EjectC :: DVDCommand True False DVD
然后实例化通用模板
data CommandIxMonad :: (state -> state -> * -> *) ->
state -> state -> * -> * where
CReturn :: a -> CommandIxMonad c i i a
(:?) :: c i j a -> (a -> CommandIxMonad c j k b) ->
CommandIxMonad c i k b
instance IxMonad (CommandIxMonad c) where
ireturn = CReturn
ibind (CReturn a) k = k a
ibind (c :? j) k = c :? \ a -> ibind (j a) k
实际上，我们已经说明了原始 Kleisli 箭头是什么（“多米诺骨牌”是什么），然后在它们之上建立了一个合适的“计算序列”概念。
请注意，对于每个索引 monad m，“无变化对角线”m i i 是一个 monad，但通常 m i j 不是。此外，值没有索引，但计算有索引，因此索引 monad 不仅仅是为其他类别实例化的 monad 的通常想法。
现在，再看看克莱斯利箭的类型
a -> m i j b
我们知道我们必须处于状态 i 才能开始，并且我们预测任何延续都将从状态 j 开始。我们对这个系统了解很多！这不是一个冒险的操作！当我们将 DVD 放入驱动器时，它会进入！ DVD 驱动器对每个命令后的状态没有任何发言权。
但在与世界互动时，通常情况并非如此。有时您可能需要放弃一些控制权，让世界为所欲为。例如，如果您是一名服务器，您可能会为您的客户提供一个选择，而您的会话状态将取决于他们的选择。服务器的“提供选择”操作不决定结果状态，但服务器应该能够继续进行。它不是上述意义上的“原始命令”，因此索引 monad 不是建模 不可预测 场景的好工具。
什么是更好的工具？
type f :-> g = forall state. f state -> g state
class MonadIx (m :: (state -> *) -> (state -> *)) where
returnIx :: x :-> m x
flipBindIx :: (a :-> m b) -> (m a :-> m b) -- tidier than bindIx
吓人的饼干？不是真的，有两个原因。第一，它看起来更像是 monad，因为它 是 monad，但超过 (state -> *) 而不是 *。第二，如果你看一下克莱斯利箭的类型，
a :-> m b = forall state. a state -> m b state
你得到带有前置条件a和后置条件b的计算类型，就像Good Old Hoare Logic一样。程序逻辑中的断言花了不到半个世纪的时间才跨越 Curry-Howard 对应关系并成为 Haskell 类型。 returnIx 的类型表示“你可以实现任何成立的后置条件，只需什么都不做”，这是“跳过”的霍尔逻辑规则。对应的组合是“;”的霍尔逻辑规则。
让我们看看 bindIx 的类型，把所有的量词都放进去。
bindIx :: forall i. m a i -> (forall j. a j -> m b j) -> m b i
这些 forall 具有相反的极性。我们选择初始状态 i，以及可以从 i 开始的计算，后置条件 a。世界选择它喜欢的任何中间状态 j，但它必须给我们后置条件 b 成立的证据，并且从任何这样的状态，我们可以继续使 b 成立。因此，按顺序，我们可以从状态 i 获得条件 b。通过释放我们对“之后”状态的控制，我们可以对 不可预测的 计算进行建模。
IxMonad 和 MonadIx 都有用。交互式计算的两种模型有效性分别关于变化的状态、可预测的和不可预测的。可预测性在你能得到时是有价值的，但不可预测性有时是生活中的一个事实。那么，希望这个答案给出了索引 monad 是什么的一些指示，预测它们何时开始有用以及何时停止。
了解索引在依赖类型中的使用方式（例如在 agda 中）可能很重要。这可以解释索引通常如何提供帮助，然后将这种经验转化为 monad。
索引允许在特定类型实例之间建立关系。然后你可以推理一些值来确定这种关系是否成立。
例如（在 agda 中）你可以指定一些自然数与 _<_ 相关，并且类型告诉它们是哪些数字。然后你可以要求给一些函数一个 witness m < n，因为只有这样函数才能正常工作——如果不提供这样的 witness，程序将无法编译。
再举一个例子，如果你对所选语言有足够的毅力和编译器支持，你可以编码该函数假定某个列表已排序。
索引 monad 允许对依赖类型系统所做的一些事情进行编码，以更精确地管理副作用。
据我所知，至少有三种定义索引 monad 的方法。
我将这些选项称为 indexed monads à la X，其中 X 涵盖了计算机科学家 Bob Atkey、Conor McBride 和 Dominic Orchard，因为我就是这样倾向于想起他们。这些结构的某些部分具有更长、更辉煌的历史，并且通过类别理论得到了更好的解释，但我首先了解到它们与这些名称相关联，并且我试图避免这个答案得到 too 深奥。
在键
Bob Atkey 的索引 monad 风格是使用 2 个额外的参数来处理 monad 的索引。
这样你就得到了人们在其他答案中反复讨论的定义：
class IMonad m where
ireturn :: a -> m i i a
ibind :: m i j a -> (a -> m j k b) -> m i k b
我们也可以像 Atkey 一样定义索引组合。我实际上从那些 in the lens codebase.
中获得了很多里程
麦克布莱德
索引 monad 的下一种形式是 Conor McBride 在他的论文 "Kleisli Arrows of Outrageous Fortune" 中的定义。他改为使用单个参数作为索引。这使得索引 monad 定义具有相当巧妙的形状。
如果我们使用参数化定义一个自然变换如下
type a ~> b = forall i. a i -> b i
那么我们可以记下 McBride 的定义为
class IMonad m where
ireturn :: a ~> m a
ibind :: (a ~> m b) -> (m a ~> m b)
这感觉与 Atkey 的完全不同，但感觉更像一个普通的 Monad，我们不是在 (m :: * -> *) 上构建 monad，而是在 (m :: (k -> *) -> (k -> *).
上构建它
有趣的是，您实际上可以通过使用巧妙的数据类型从 McBride 的索引 monad 中恢复 Atkey 的索引 monad 风格，McBride 以其独特的风格选择说您应该将其理解为“关键”。
data (:=) a i j where
V :: a -> (a := i) i
现在你可以算出来了
ireturn :: IMonad m => (a := j) ~> m (a := j)
扩展为
ireturn :: IMonad m => (a := j) i -> m (a := j) i
只能在j = i时调用，然后仔细阅读ibind可以让你回到与Atkey的ibind相同的地方。您需要绕过这些 (:=) 数据结构，但它们恢复了 Atkey 表示的功能。
另一方面，Atkey 演示文稿不够强大，无法恢复 McBride 版本的所有使用。权力已严格获得。
另一件好事是 McBride 的索引 monad 显然是一个 monad，它只是一个不同函子类别上的 monad。它适用于从 (k -> *) 到 (k -> *) 的函子类别的内函子，而不是从 * 到 * 的函子类别。
一个有趣的练习是弄清楚如何为索引的 comonads 进行 McBride 到 Atkey 的转换。我个人在 McBride 的论文中使用数据类型 'At' 作为“关键”结构。实际上，在 ICFP 2013 上，我走到 Bob Atkey 面前，提到我把他翻了个底朝天，让他变成了一件“外套”。他似乎明显感到不安。这条线在我脑海中发挥得更好。 =)
果园
最后，“索引 monad”这个名字的第三个不那么常见的声明者是 Dominic Orchard，他使用类型级别的幺半群来粉碎索引。与其详细介绍构造的细节，我将简单地 link 讨论这个话题：
https://github.com/dorchard/effect-monad/blob/master/docs/ixmonad-fita14.pdf
什么是 indexed monad 以及这个 monad 的动机？
我读到它有助于跟踪副作用。但是类型签名和文档并没有把我带到任何地方。
什么是它如何帮助跟踪副作用的示例（或任何其他有效示例）？
作为一个简单的场景，假设您有一个状态 monad。状态类型是一个复杂的大类型，但所有这些状态都可以分为两组：红色和蓝色状态。仅当当前状态为蓝色状态时，此 monad 中的某些操作才有意义。其中，一些会使状态保持蓝色 (blueToBlue)，而另一些会使状态变为红色 (blueToRed)。在常规的 monad 中，我们可以写
blueToRed :: State S ()
blueToBlue :: State S ()
foo :: State S ()
foo = do blueToRed
blueToBlue
触发运行时错误，因为第二个操作需要蓝色状态。我们想静态地防止这种情况。索引 monad 实现了这个目标：
data Red
data Blue
-- assume a new indexed State monad
blueToRed :: State S Blue Red ()
blueToBlue :: State S Blue Blue ()
foo :: State S ?? ?? ()
foo = blueToRed `ibind` \_ ->
blueToBlue -- type error
由于blueToRed（Red）的第二个索引与blueToBlue（Blue）的第一个索引不同而触发类型错误。
作为另一个示例，使用索引 monad，您可以允许状态 monad 更改其状态的类型，例如你可以
data State old new a = State (old -> (new, a))
您可以使用上面的方法构建一个状态，它是一个静态类型的异构堆栈。操作的类型为
push :: a -> State old (a,old) ()
pop :: State (a,new) new a
作为另一个例子，假设你想要一个受限的 IO monad，它不 允许文件访问。您可以使用例如
openFile :: IO any FilesAccessed ()
newIORef :: a -> IO any any (IORef a)
-- no operation of type :: IO any NoAccess _
通过这种方式，具有类型 IO ... NoAccess () 的操作静态地保证是无文件访问的。相反，IO ... FilesAccessed () 类型的操作可以访问文件。拥有索引 monad 意味着您不必为受限 IO 构建单独的类型，这将需要在两种 IO 类型中复制每个非文件相关的函数。
索引 monad 不是特定的 monad，例如状态 monad，而是带有额外类型参数的 monad 概念的一种概括。
而 "standard" monadic 值具有 Monad m => m a 类型，索引 monad 中的值将是 IndexedMonad m => m i j a 其中 i 和 j 是索引类型因此 i 是 monadic 计算开始时索引的类型，而 j 是计算结束时的索引类型。在某种程度上，您可以将 i 视为一种输入类型，将 j 视为输出类型。
以State为例，有状态计算State s a在整个计算过程中保持s类型的状态和returns类型a的结果].索引版本 IndexedState i j a 是一种有状态计算，其中状态可以在计算期间更改为不同的类型。初始状态的类型为 i 和状态，计算结束的类型为 j.
很少需要在普通 monad 上使用索引 monad，但在某些情况下可以使用它来编码更严格的静态保证。
一如既往，人们使用的术语并不完全一致。有多种受 monad 启发但严格来说并不完全是概念。术语“索引 monad”是用于描述此类概念的众多术语（包括“monadish”和“参数化 monad”（Atkey 对它们的名称））之一。 （另一个这样的概念，如果你感兴趣的话，是 Katsumata 的“参数效果单子”，由一个幺半群索引，其中 return 被中性索引并且 bind 在它的索引中累积。）
首先，让我们检查种类。
IxMonad (m :: state -> state -> * -> *)
也就是说，“计算”（或“动作”，如果你愿意，但我会坚持使用“计算”）的类型，看起来像
m before after value
其中 before, after :: state 和 value :: *。这个想法是捕获与具有某些 可预测 状态概念的外部系统安全交互的方法。一个计算的类型告诉你它运行的状态必须是什么 before ，它运行的状态是什么 after 以及（就像 * 上的常规单子一样）什么类型的 values 计算结果。
通常的点点滴滴 * 像 monad 和 state 像玩多米诺骨牌。
ireturn :: a -> m i i a -- returning a pure value preserves state
ibind :: m i j a -> -- we can go from i to j and get an a, thence
(a -> m j k b) -- we can go from j to k and get a b, therefore
-> m i k b -- we can indeed go from i to k and get a b
由此产生的“克莱斯利箭头”（产生计算的函数）的概念是
a -> m i j b -- values a in, b out; state transition i to j
我们得到一个组合
icomp :: IxMonad m => (b -> m j k c) -> (a -> m i j b) -> a -> m i k c
icomp f g = \ a -> ibind (g a) f
而且，一如既往，法律确实确保 ireturn 和 icomp 给我们一个类别
ireturn `icomp` g = g
f `icomp` ireturn = f
(f `icomp` g) `icomp` h = f `icomp` (g `icomp` h)
或者，在假喜剧中 C/Java/whatever，
g(); skip = g()
skip; f() = f()
{h(); g()}; f() = h(); {g(); f()}
何必呢？为交互的“规则”建模。例如，如果驱动器中没有 DVD，则无法弹出；如果驱动器中已有 DVD，则无法将 DVD 放入驱动器。所以
data DVDDrive :: Bool -> Bool -> * -> * where -- Bool is "drive full?"
DReturn :: a -> DVDDrive i i a
DInsert :: DVD -> -- you have a DVD
DVDDrive True k a -> -- you know how to continue full
DVDDrive False k a -- so you can insert from empty
DEject :: (DVD -> -- once you receive a DVD
DVDDrive False k a) -> -- you know how to continue empty
DVDDrive True k a -- so you can eject when full
instance IxMonad DVDDrive where -- put these methods where they need to go
ireturn = DReturn -- so this goes somewhere else
ibind (DReturn a) k = k a
ibind (DInsert dvd j) k = DInsert dvd (ibind j k)
ibind (DEject j) k = DEject j $ \ dvd -> ibind (j dvd) k
有了这个，我们可以定义“原始”命令
dInsert :: DVD -> DVDDrive False True ()
dInsert dvd = DInsert dvd $ DReturn ()
dEject :: DVDrive True False DVD
dEject = DEject $ \ dvd -> DReturn dvd
其他人用ireturn和ibind组装而成。现在，我可以写（借用 do-符号）
discSwap :: DVD -> DVDDrive True True DVD
discSwap dvd = do dvd' <- dEject; dInsert dvd ; ireturn dvd'
但并非物理上不可能
discSwap :: DVD -> DVDDrive True True DVD
discSwap dvd = do dInsert dvd; dEject -- ouch!
或者，可以直接定义自己的原始命令
data DVDCommand :: Bool -> Bool -> * -> * where
InsertC :: DVD -> DVDCommand False True ()
EjectC :: DVDCommand True False DVD
然后实例化通用模板
data CommandIxMonad :: (state -> state -> * -> *) ->
state -> state -> * -> * where
CReturn :: a -> CommandIxMonad c i i a
(:?) :: c i j a -> (a -> CommandIxMonad c j k b) ->
CommandIxMonad c i k b
instance IxMonad (CommandIxMonad c) where
ireturn = CReturn
ibind (CReturn a) k = k a
ibind (c :? j) k = c :? \ a -> ibind (j a) k
实际上，我们已经说明了原始 Kleisli 箭头是什么（“多米诺骨牌”是什么），然后在它们之上建立了一个合适的“计算序列”概念。
请注意，对于每个索引 monad m，“无变化对角线”m i i 是一个 monad，但通常 m i j 不是。此外，值没有索引，但计算有索引，因此索引 monad 不仅仅是为其他类别实例化的 monad 的通常想法。
现在，再看看克莱斯利箭的类型
a -> m i j b
我们知道我们必须处于状态 i 才能开始，并且我们预测任何延续都将从状态 j 开始。我们对这个系统了解很多！这不是一个冒险的操作！当我们将 DVD 放入驱动器时，它会进入！ DVD 驱动器对每个命令后的状态没有任何发言权。
但在与世界互动时，通常情况并非如此。有时您可能需要放弃一些控制权，让世界为所欲为。例如，如果您是一名服务器，您可能会为您的客户提供一个选择，而您的会话状态将取决于他们的选择。服务器的“提供选择”操作不决定结果状态，但服务器应该能够继续进行。它不是上述意义上的“原始命令”，因此索引 monad 不是建模 不可预测 场景的好工具。
什么是更好的工具？
type f :-> g = forall state. f state -> g state
class MonadIx (m :: (state -> *) -> (state -> *)) where
returnIx :: x :-> m x
flipBindIx :: (a :-> m b) -> (m a :-> m b) -- tidier than bindIx
吓人的饼干？不是真的，有两个原因。第一，它看起来更像是 monad，因为它 是 monad，但超过 (state -> *) 而不是 *。第二，如果你看一下克莱斯利箭的类型，
a :-> m b = forall state. a state -> m b state
你得到带有前置条件a和后置条件b的计算类型，就像Good Old Hoare Logic一样。程序逻辑中的断言花了不到半个世纪的时间才跨越 Curry-Howard 对应关系并成为 Haskell 类型。 returnIx 的类型表示“你可以实现任何成立的后置条件，只需什么都不做”，这是“跳过”的霍尔逻辑规则。对应的组合是“;”的霍尔逻辑规则。
让我们看看 bindIx 的类型，把所有的量词都放进去。
bindIx :: forall i. m a i -> (forall j. a j -> m b j) -> m b i
这些 forall 具有相反的极性。我们选择初始状态 i，以及可以从 i 开始的计算，后置条件 a。世界选择它喜欢的任何中间状态 j，但它必须给我们后置条件 b 成立的证据，并且从任何这样的状态，我们可以继续使 b 成立。因此，按顺序，我们可以从状态 i 获得条件 b。通过释放我们对“之后”状态的控制，我们可以对 不可预测的 计算进行建模。
IxMonad 和 MonadIx 都有用。交互式计算的两种模型有效性分别关于变化的状态、可预测的和不可预测的。可预测性在你能得到时是有价值的，但不可预测性有时是生活中的一个事实。那么，希望这个答案给出了索引 monad 是什么的一些指示，预测它们何时开始有用以及何时停止。
了解索引在依赖类型中的使用方式（例如在 agda 中）可能很重要。这可以解释索引通常如何提供帮助，然后将这种经验转化为 monad。
索引允许在特定类型实例之间建立关系。然后你可以推理一些值来确定这种关系是否成立。
例如（在 agda 中）你可以指定一些自然数与 _<_ 相关，并且类型告诉它们是哪些数字。然后你可以要求给一些函数一个 witness m < n，因为只有这样函数才能正常工作——如果不提供这样的 witness，程序将无法编译。
再举一个例子，如果你对所选语言有足够的毅力和编译器支持，你可以编码该函数假定某个列表已排序。
索引 monad 允许对依赖类型系统所做的一些事情进行编码，以更精确地管理副作用。
据我所知，至少有三种定义索引 monad 的方法。
我将这些选项称为 indexed monads à la X，其中 X 涵盖了计算机科学家 Bob Atkey、Conor McBride 和 Dominic Orchard，因为我就是这样倾向于想起他们。这些结构的某些部分具有更长、更辉煌的历史，并且通过类别理论得到了更好的解释，但我首先了解到它们与这些名称相关联，并且我试图避免这个答案得到 too 深奥。
在键
Bob Atkey 的索引 monad 风格是使用 2 个额外的参数来处理 monad 的索引。
这样你就得到了人们在其他答案中反复讨论的定义：
class IMonad m where
ireturn :: a -> m i i a
ibind :: m i j a -> (a -> m j k b) -> m i k b
我们也可以像 Atkey 一样定义索引组合。我实际上从那些 in the lens codebase.
麦克布莱德
索引 monad 的下一种形式是 Conor McBride 在他的论文 "Kleisli Arrows of Outrageous Fortune" 中的定义。他改为使用单个参数作为索引。这使得索引 monad 定义具有相当巧妙的形状。
如果我们使用参数化定义一个自然变换如下
type a ~> b = forall i. a i -> b i
那么我们可以记下 McBride 的定义为
class IMonad m where
ireturn :: a ~> m a
ibind :: (a ~> m b) -> (m a ~> m b)
这感觉与 Atkey 的完全不同，但感觉更像一个普通的 Monad，我们不是在 (m :: * -> *) 上构建 monad，而是在 (m :: (k -> *) -> (k -> *).
有趣的是，您实际上可以通过使用巧妙的数据类型从 McBride 的索引 monad 中恢复 Atkey 的索引 monad 风格，McBride 以其独特的风格选择说您应该将其理解为“关键”。
data (:=) a i j where
V :: a -> (a := i) i
现在你可以算出来了
ireturn :: IMonad m => (a := j) ~> m (a := j)
扩展为
ireturn :: IMonad m => (a := j) i -> m (a := j) i
只能在j = i时调用，然后仔细阅读ibind可以让你回到与Atkey的ibind相同的地方。您需要绕过这些 (:=) 数据结构，但它们恢复了 Atkey 表示的功能。
另一方面，Atkey 演示文稿不够强大，无法恢复 McBride 版本的所有使用。权力已严格获得。
另一件好事是 McBride 的索引 monad 显然是一个 monad，它只是一个不同函子类别上的 monad。它适用于从 (k -> *) 到 (k -> *) 的函子类别的内函子，而不是从 * 到 * 的函子类别。
一个有趣的练习是弄清楚如何为索引的 comonads 进行 McBride 到 Atkey 的转换。我个人在 McBride 的论文中使用数据类型 'At' 作为“关键”结构。实际上，在 ICFP 2013 上，我走到 Bob Atkey 面前，提到我把他翻了个底朝天，让他变成了一件“外套”。他似乎明显感到不安。这条线在我脑海中发挥得更好。 =)
果园
最后，“索引 monad”这个名字的第三个不那么常见的声明者是 Dominic Orchard，他使用类型级别的幺半群来粉碎索引。与其详细介绍构造的细节，我将简单地 link 讨论这个话题：
https://github.com/dorchard/effect-monad/blob/master/docs/ixmonad-fita14.pdf