如何抽象不同元数的Monad Transformer liftCapability函数？

你遇到的这种重复编写不同元数lift函数的情况，在Haskell里确实很常见——好在我们可以利用类型类的抽象能力，一次性搞定所有元数的情况，不用再写一堆liftCapabilityN了！

方法一：用类型类抽象任意元数的函数 #

我们可以定义一个类型类，递归地处理不同参数个数的函数，再配合类型族提取最终的IO返回值：

首先定义辅助类型族，用来从函数类型中提取最终的IO结果类型：

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}

type family IOResult f where
  IOResult (IO a) = a
  IOResult (a -> f) = a -> IOResult f

然后定义核心的类型类：

class LiftCapability f where
  liftCap :: Has capability e => (capability -> f) -> ReaderT e IO (IOResult f)

接下来为不同的函数类型实现实例：

• 处理无额外参数的情况（对应你原来的liftCapability）：

instance LiftCapability (IO a) where
  liftCap f = do
    cap <- asks getter
    lift $ f cap

• 递归处理带参数的情况（自动适配1个、2个甚至更多参数的函数）：

instance LiftCapability f => LiftCapability (a -> f) where
  liftCap f a = liftCap (\cap -> f cap a)

现在你就可以用同一个liftCap函数处理所有元数的情况了：

-- 对应原来的liftCapability
runSimpleAction :: Has MyCap e => ReaderT e IO Int
runSimpleAction = liftCap (\cap -> simpleCapAction cap)  -- simpleCapAction :: MyCap -> IO Int

-- 对应原来的liftCapability1
runSingleArgAction :: Has MyCap e => String -> ReaderT e IO Bool
runSingleArgAction input = liftCap (\cap -> singleArgCapAction cap input)  -- singleArgCapAction :: MyCap -> String -> IO Bool

-- 对应原来的liftCapability2
runTwoArgAction :: Has MyCap e => Int -> Bool -> ReaderT e IO String
runTwoArgAction num flag = liftCap (\cap -> twoArgCapAction cap num flag)  -- twoArgCapAction :: MyCap -> Int -> Bool -> IO String

为什么你的curryN/uncurryN尝试行不通？ #

你提到的tuple包里的curryN和uncurryN需要明确的元数信息，而且无法处理0元（直接返回IO）的场景——而类型类的递归方式可以自动适配从0到任意多的参数个数，完美覆盖你的所有需求。

另一种简洁写法：利用Monad的绑定 #

如果你不想引入类型类，也可以用更紧凑的绑定写法来减少重复代码，虽然还是要手动柯里化，但比原来的多个函数要简洁：

liftC :: Has capability e => (capability -> IO a) -> ReaderT e IO a
liftC f = asks getter >>= lift . f

-- 带1个参数的版本
liftC1 :: Has capability e => (capability -> a -> IO b) -> a -> ReaderT e IO b
liftC1 f = liftC . flip f

-- 带2个参数的版本
liftC2 :: Has capability e => (capability -> a -> b -> IO c) -> a -> b -> ReaderT e IO c
liftC2 f = liftC1 . flip f

这种方式利用flip把参数顺序反转，然后复用之前的lift函数，虽然还是要写每个元数的版本，但代码量少很多。

不过相比之下，类型类的方法更“一劳永逸”，新增参数个数时完全不需要修改代码。

内容的提问来源于stack exchange，提问作者Nikita Tchayka