Haskell中可扩展状态机的无修改扩展方案及索引单子适用性问询

首先，把你给出的原始状态机代码整理成可运行的Haskell代码格式：

--------------------------------------------
-- module State where
data State = A | B Int
--------------------------------------------
-- module A where
-- import State
transitionA :: State
transitionA = B 10
--------------------------------------------
-- module B where
-- import State
transitionB :: Int -> State
transitionB i | i < 0 = A
              | otherwise = B (i-1)
--------------------------------------------
-- module StateMachine where
-- import State
-- import A
-- import B
transition :: State -> State
transition A = transitionA
transition (B i) = transitionB i

你遇到的痛点非常典型：传统ADT定义的状态机扩展性极差，每次新增状态都要修改全局类型、新增转换模块、更新模式匹配，完全违背开闭原则。而你尝试的存在类型和基础多态变体都没能彻底解决问题——那MonadIx（索引单子）能不能帮你实现「只写新转换函数就完成扩展」的目标？答案是肯定的，而且它正是为这类索引化、可扩展的计算场景设计的。

为什么MonadIx能解决你的问题？ #

MonadIx的核心是把状态追踪从值层面的ADT枚举转移到类型层面的索引标记，同时用类型类调度不同状态的转换逻辑。这意味着：

1. 不需要维护全局的State ADT，每个新状态是独立类型，无需修改现有代码；
2. 转换逻辑完全模块化，新增状态只需要实现自己的转换函数和对应的类型类实例，不用更新全局模式匹配函数。

具体实现思路 #

我们结合Haskell的类型级编程和索引单子重构你的状态机：

1. 定义状态的类型索引

用独立类型表示每个状态（带上必要参数，比如B状态的Int值可以用类型级自然数）：

{-# LANGUAGE DataKinds, KindSignatures, TypeFamilies, FlexibleInstances #-}

import GHC.TypeNats
import Control.Indexed.Monad -- 可使用hackage上的`indexed`包

-- 用类型作为状态索引
data StateIdx = S_A | S_B Nat

-- 定义每个状态的下一个状态类型（类型族）
type family NextState (s :: StateIdx) :: StateIdx where
  NextState 'S_A = 'S_B 10
  NextState ('S_B n) = If (n <= 0) 'S_A ('S_B (n - 1))

2. 为每个状态定义独立的转换函数

每个状态的转换逻辑是一个索引单子计算，只关心自身的输入和输出索引：

-- 状态A的转换：从S_A到S_B 10
transitionA :: IxMonad m => m 'S_A (NextState 'S_A) ()
transitionA = returnIx ()

-- 状态B的转换：从S_B n到对应的下一个状态
transitionB :: (IxMonad m, KnownNat n) => m ('S_B n) (NextState ('S_B n)) ()
transitionB = returnIx ()

3. 用类型类实现自动调度

定义一个类型类统一所有状态的转换逻辑，新增状态只需要添加该类的实例：

class Transition (s :: StateIdx) where
  transition :: IxMonad m => m s (NextState s) ()

-- 为状态A实现Transition
instance Transition 'S_A where
  transition = transitionA

-- 为状态B实现Transition
instance (KnownNat n) => Transition ('S_B n) where
  transition = transitionB

-- 通用的状态步进函数——永远不需要修改！
step :: (Transition s, IxMonad m) => m s (NextState s) ()
step = transition

扩展新状态有多简单？ #

假设你要新增状态C，转换逻辑是从C到A：

1. 添加状态的类型索引：data StateIdx = ... | S_C
2. 更新NextState类型族：NextState 'S_C = 'S_A
3. 编写转换函数和类型类实例：

transitionC :: IxMonad m => m 'S_C (NextState 'S_C) ()
transitionC = returnIx ()

instance Transition 'S_C where
  transition = transitionC

就这么简单！完全不需要修改之前的任何代码——没有全局ADT要改，没有模式匹配要更新，只需要实现新状态的转换逻辑。

对比你之前的方案 #

• 存在类型的循环依赖：这里状态是类型级索引，转换函数依赖索引类型，但索引类型不依赖转换函数，彻底消除循环依赖；
• 多态变体的提前声明：不需要提前枚举所有状态，每个新状态是独立类型，无需加入到某个变体集合中。

这种方式完美实现了你想要的「仅编写新转换函数即可扩展」的目标，而MonadIx正是让这种模块化索引计算变得优雅的核心工具。

内容的提问来源于stack exchange，提问作者Sam Derbyshire