0

我是一个中级策划者，但只是一个 haskell 初学者。这是我的问题：

假设你有一个关联二元运算，说(>>=)。有这样的多元函数p吗p (>>=) h g f e = h >>= g >>= f >>= e？

我问这个问题是因为这个问题说如果二进制操作采用相同类型的输入是可能的。我想知道这是否可以概括。

EDIT-1：我尝试修改http://okmij.org/ftp/Haskell/vararg-fn.lhs中的代码（可变类型参数的可变数量部分），但进展不大。

EDIT-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
4

2 回答 2

2

是的，您可以创建这样的功能。但是它非常难看，您需要显式键入要传递的每个参数，以使编译器找到正确的实例。

从您链接的多变量函数模板开始，我到达了

{-# 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)
于 2016-09-17T18:55:36.887 回答
1

您不能（至少，不容易），因为您需要提前知道有多少参数。因为 Haskell 中的所有函数都是自动柯里化的，所以每个函数都只接受一个参数并返回一个值。即使是一个简单的二元运算符也接受一个参数（第一个操作数）并返回一个函数，该函数接受一个参数（第二个操作数）并返回一个结果。那是，

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中的实现。即使这也不是一个很好的例子，因为第一个参数携带的信息（格式字符串中的占位符的数量）是单独的二进制操作所不具备的。

于 2016-09-17T15:43:12.960 回答