用关联二元运算链接元素
我是一名中间策划者，但只是一名haskell初学者。 这是我的问题：
假设你有一个关联的二元操作，说(>>=) 。 是否存在一个多变量函数p ，使得p (>>=) hgfe = h >>= g >>= f >>= e ？
我在问这个问题，因为这个问题说如果二进制操作接受相同类型的输入是可能的。 我想知道这是否可以推广。
编辑1：我尝试修改http://okmij.org/ftp/Haskell/vararg-fn.lhs（可变数量的可变类型参数部分）中的代码，但进展甚微。
编辑-2：简化代码。
{-# LANGUAGE FunctionalDependencies, FlexibleInstances #-}
module Main where
class Lfold f a b | b -> a where
lfold :: (a -> (f a) -> (f a)) -> (f a) -> a -> b
instance Lfold f a (f a) where
lfold op rid x = op x rid
instance Lfold f a b => Lfold f a (a -> b) where
lfold op rid x y = lfold op (op x rid) y
test :: [String]
test = lfold (:) [] "a" "b" "c"
main :: IO ()
main = putStrLn $ show test
是的，你可以创建这样的功能。 然而，它非常丑陋，您需要明确输入您要传递的每个参数，以使编译器找到正确的实例。
从你链接的多变量函数模板开始，我到达了
{-# LANGUAGE FlexibleInstances, InstanceSigs, MultiParamTypeClasses #-}
class ImplicitChain m a r where
p :: m a -> r
instance Monad m => ImplicitChain m a (m a) where
p :: m a -> m a
p x = x
instance (Monad m, ImplicitChain m b r) => ImplicitChain m a ((a -> m b) -> r) where
p :: m a -> (a -> m b) -> r
p x f = p (x >>= f)
h :: Int -> [Int]
h = replicate 2
g :: Int -> [Int]
g = (:[])
f :: Int -> [Int]
f = flip enumFromTo 2
test :: [Int]
test = p [1::Int] h g f
但是你问我们是否可以做更通用的，所以二元操作也是一个论点。 是：
{-# LANGUAGE FlexibleInstances, InstanceSigs, MultiParamTypeClasses, UndecidableInstances #-}
class ImplicitVariadic a b r where
p :: (a -> b -> a) -> r
instance ImplicitVariadic a b (a -> a) where
p :: (a -> b -> a) -> a -> a
p _ x = x
instance (ImplicitVariadic a b (a -> r)) => ImplicitVariadic a b (a -> b -> r) where
p :: (a -> b -> a) -> a -> b -> r
p f x y = p f (f x y)
你不能（至少，不容易），因为你需要知道你提前有多少个参数。 因为Haskell中的所有函数都会自动执行curried，所以每个函数只需要一个参数并返回一个值。 即使是一个简单的二元运算符也只需要一个参数（第一个操作数）并返回一个带有一个参数（第二个操作数）并返回结果的函数。 那是，
a + b == (+) a b
== ((+) a) b
你的想象函数p从它的第一个参数中是没有办法知道将会给出多少其他参数的。 也就是说， p的类型应该是什么？
p :: (a -> a -> a) -> a -- zero arguments?
p :: (a -> a -> a) -> a -> a -- one argument?
p :: (a -> a -> a) -> a -> a -> a -- two arguments?
p :: (a -> a -> a) -> a -> a -> a -> a -- three arguments?
相反，你所能做的最好的就是使用折叠，它需要一个操作和一个操作数列表。
foldr (+) 0 [h, g, f, e] == h + g + f + e + 0 -- explicit first argument of 0
foldr1 (+) [h, g, f, e] == h + g + f + e -- assumes a list of at least one value
通过“不容易”了解我的意思，看看Text.Printf模块中printf的实现。 即使这样也不是一个好例子，因为第一个参数包含二进制操作本身不包含的信息（格式字符串中占位符的数量）。