Haskell：a -> a -> ... -> b 到 [a] -> b [重复]

Question

我正在尝试将以下映射表示为 Haskell 函数：

给定两种类型 a, b 考虑函数族 F(a, b) 由类型的函数组成

f :: a -> a -> ... -> a -> b

n 重复 a，其中 n 是大于零的整数。 我想要的是将F(a, b) 中的每个函数f 映射到函数f' :: [a] -> b，这样f x1 x2 ... xr = f' [x1, ..., xr]，其中r 小于f 需要的参数数量（即我正在寻找函数listify :: F(a, b) -> ([a] -> b))。如果元素多于 f 接受参数，则应丢弃额外的元素：

f :: a -> a -> b
(listify f xs) == (listify f $ take 2 xs)

此外，如果列出的为空，则任何值都可以接受。

我当然可以为具有固定数量参数的函数实现此映射（例如：listify :: (a -> a -> b) -> ([a] -> b) 等），但我找不到一种方法来编写一个对所有人都适用的函数f 同时在 F(a, b) 中。尽管 Template Haskell 可能能够为我提供正确的工具，但我对这样的解决方案不感兴趣。我想找到一些纯粹的“类型魔术”方式来做到这一点。

有人知道这是否可能吗？有人可以指出我正确的方向吗？或者这是一个已知的“问题”，已经解决了数十亿次，而我只是找不到解决方案？

Answer 1

我们只需要在这里挑选毒药。如果我们使用不太安全的 pragma，我们可以获得更多的推理，反之亦然；有很多组合。

第一个：使用重叠实例，将非函数作为基本情况，但无法处理多态a 类型：

{-# LANGUAGE MultiParamTypeClasses, TypeFamilies, FlexibleInstances #-}

class Listify a b where
  listify :: a -> b  

instance {-# OVERLAPS #-} r ~ ([a] -> b) => Listify b r where
  listify = const

instance (Listify f r, r ~ ([a] -> b)) => Listify (a -> f) r where
  listify f (a:as) = listify (f a) as

-- listify (+) [0, 2] -- error
-- listify (+) [0, 2 :: Int] -- OK
-- listify () [] -- OK

第二种：使用重叠实例，具有作为基本情况的函数，可以处理多态类型：

{-# LANGUAGE MultiParamTypeClasses, TypeFamilies, FlexibleInstances, FlexibleContexts #-}

class Listify a b where
  listify :: a -> b  

instance {-# OVERLAPS #-} r ~ ([a] -> b) => Listify (a -> b) r where
  listify f (a:_) = f a

instance (Listify (a -> b) r, r ~ ([a] -> b)) => Listify (a -> a -> b) r where
  listify f (a:as) = listify (f a) as

-- listify (+) [0, 2] -- OK
-- listify () [] -- error, first arg must be a function

第三：使用不连贯的实例，在基本情况下具有值，可以处理多态类型：

{-# LANGUAGE MultiParamTypeClasses, TypeFamilies, FlexibleInstances #-}

class Listify a b where
  listify :: a -> b  

instance {-# INCOHERENT #-} r ~ ([a] -> b) => Listify b r where
  listify = const

instance (Listify f r, r ~ ([a] -> b)) => Listify (a -> f) r where
  listify f (a:as) = listify (f a) as

-- listify 0 [] -- OK
-- listify (+) [2, 4] -- OK

第四种：使用带有UndecidableInstances 的封闭类型族作为实例解析的帮助器，具有基本情况下的值，无法处理多态类型：

{-# LANGUAGE UndecidableInstances, ScopedTypeVariables, DataKinds,
    TypeFamilies, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts #-}

import Data.Proxy

data Nat = Z | S Nat

type family Arity f where
  Arity (a -> b) = S (Arity b)
  Arity b        = Z

class Listify (n :: Nat) a b where
  listify' :: Proxy n -> a -> b

instance r ~ (a -> b) => Listify Z b r where
  listify' _ = const

instance (Listify n f r, a ~ (a' -> f), r ~ ([a'] -> b)) => Listify (S n) a r where
  listify' _ f (a:as) = listify' (Proxy :: Proxy n) (f a) as

listify :: forall a b. Listify (Arity a) a b => a -> b
listify = listify' (Proxy :: Proxy (Arity a))

-- listify (+) [3, 4] -- error
-- listify (+) [3, 4::Int] -- OK
-- listify () [] -- OK
-- listify 0 [] -- error
-- listify (0 :: Int) [] -- OK

在我看来，除了INCOHERENT 之外，大致上这些是人们可以在野外看到的变体，因为这在库代码中极为罕见（有充分的理由）。

我个人推荐带有封闭类型族的版本，因为UndecidableInstances 和类型族作为语言扩展目前争议最小，而且它们仍然提供了相当多的可用性。

Answer 2

其实很简单，甚至不需要重叠实例：

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}

class Listifiable f a b where
  listify :: f -> [a] -> b

instance Listifiable b a b where
  listify = const

instance (Listifiable f) a b => Listifiable (a->f) a b where
  listify f (x:xs) = listify (f x) xs

那你就可以了

GHCi> listify ((+) :: Int->Int->Int) [1,2 :: Int] :: Int
3

但是对那些本地显式类型签名的需求很能说明你遇到的问题。

（FunctionalDependencies 或许可以缓解这个问题，但至少不是直接的方式。）