通过在Haskell中部分应用来减少列表

Question

Is there some more powerful version of map for functions with multiple arguments? Thus the length of the reduced list would be length of original / number of arguments ...

tuple a b = (a, b)
map' tuple [1, 2, 3, 4]
> [(1, 2), (3, 4)]

mul a b c = a * b * c
map' mul [1, 2, 3, 4, 5, 6]
> [3, 120]

I tried to write myself one, but it seems impossible to accept function of any number of arguments.

I would like to have generic version for variable number of arguments, because writing one myself every time takes some time and it won't use loop fusion.

Answer 1

The simplest solution is to just generate a helper function for each arity that you need, eg for arity 3 functions:

map3 :: (a -> a -> a -> b) -> [a] -> [b]
map3 f (x : y : z : rest) = f x y z : map3 f rest
map3 f _ = []

Put these in a utility module so you can import them as needed. If you want to get sophisticated you can generate them using TemplateHaskell, CPP macros, or even type-classes, but be careful about turning this simple exercise into a yak shaving party.

Your example:

interact $ unlines . fmap foo . tuple . lines

could then be expressed as:

interact $ unlines . map2 foo . lines

assuming that foo has the signature foo :: String -> String -> String

Answer 2

I disagree with the spirit of defining something like this, but just for the hasochism of it, I'm trying my hand at it. Here is a solution that works, but only for monomorphic types. I'm working on seeing if I can convert it to something involving type families that also doesn't need to be littered with type annotations.

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

class Consumer f a b where
  consume :: f -> [a] -> Maybe (b,[a])

instance {-# OVERLAPPABLE #-} Consumer b a b where
  consume b xs = Just (b,xs)

instance {-# OVERLAPPING #-} Consumer f a b => Consumer (a -> f) a b where
  consume f [] = Nothing
  consume f (x:xs) = consume (f x) xs

map' :: Consumer f a b => f -> [a] -> [b] 
map' f xs = case consume f xs of
                Nothing -> []
                Just (b,xs') -> b : map' f xs'

And testing it out

> map' ((+) :: Int -> Int -> Int) ([1,2,3,4] :: [Int]) :: [Int]
[3,7]
> map' (id :: Int -> Int) ([1,2,3,4] :: [Int]) :: [Int]
[1,2,3,4]

EDIT

After some thought, I don't think that a better solution is possible (without dependent types). The reason I have to add type annotations everywhere is that I have no way of informing GHC that the two consumer instances I've provided are actually the only instances I will ever want (are closed type classes even a thing?) and I can't etch out functional dependencies. This second problem is also why I can't rewrite this as a type family. On a side note though, annotating the function arguments can look a lot nicer now that we have TypeApplications : map' ((+) @Int) ([1..9] :: [Int]) .