Use contents of a list as positional arguments to a single multi-argument function

Question

Is there a standard Haskell function (or pattern) to extract the contents of a list and feed them as though they are the ordered positional arguments to a function?

For example, consider the function (,) which, when given two positional arguments, will make a two-tuple from them:

(,) 3 4 --> (3,4)

Suppose instead I have these arguments given to me by some external function call that I cannot change, represented as a list [3, 4].

Is there a "contents of" operation, such that this would work:

(,) $ contents_of [3, 4]

so that the action of contents_of behaves just as though the items had been placed in source code with spaces between them as function application?

For example, (,) $ contents_of [1] should be the curried function ((,) 1) which then takes one more argument to complete creating the tuple.

One thought I had was to try to fold the function over the list, with the fold function expressing currying:

foldr (\x y -> y x) (,) [3, 4]

but looking at the type signature of foldr:

foldr :: (a -> b -> b) -> b -> [a] -> b

makes this seem difficult. b here would need to be the function type itself, but then by the time it has been applied to the arguments it won't be a function with the same type signature as b any longer, leading to type issues in the fold.

This is similar in spirit to the Python *args construct.

I'm not concerned with the strictness properties this might imply -- just whether something like this is possible in standard Haskell.

Answer 1

It is possible to represent N-ary functions like so:

data FunN r a = FunN Int (a -> FunN r a) | FNil r

Then convert plain functions into FunN:

f2FunN :: (FunN (a->b) a) -> FunN b a
f2FunN (FNil g)   = FunN 1 (FNil . g)
f2FunN (FunN n g) = FunN (n+1) (f2FunN . g)

Then apply a list of arguments:

a :: FunN b a -> [a] -> b
a (FNil r)   []    = r
a (FunN _ f) (x:t) = a (f x) t
a _          _     = error "wrong arity"

For example:

Prelude> a (f2FunN $ f2FunN $ FNil (+)) [1,2]
3
Prelude> a (f2FunN $ FNil (+)) [1] 2
3
Prelude> a (f2FunN $ f2FunN $ FNil (+)) [1,2,3]
*** Exception: wrong arity
Prelude> a (f2FunN $ f2FunN $ FNil (+)) [1]
*** Exception: wrong arity

But of course you need to know the arity of the function at compile time - so that you know how many times you can wrap the function with f2FunN.

Answer 2

As I explained in the comments above, I don't think this is possible with the standard list. So let's introduce a new list where each element in the list can be a different type, and this is encoded in the type of the list:

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

data Nil
data TList a b where
    TEmpty :: TList Nil Nil
    (:.) :: c -> TList d e -> TList c (TList d e)
infixr 4 :.

TEmpty here is analogous to [], and :. to :. So we could have a list of an Int, and a couple of Bools: 31 :. True :. False :. TEmpty. The type of this list is TList Int (TList Bool (TList Bool (TList Nil Nil))).

We can now introduce a typeclass which provides a function which can be used to apply any arbitrary function to the list in the way you propose, given that the types match.

class TApplies f h t r where
    tApply :: f -> TList h t -> r

instance TApplies a Nil Nil a where
    tApply a _ = a

instance TApplies f h t r => TApplies (a -> f) a (TList h t) r where
    tApply f (e :. l) = tApply (f e) l

We can now use tApply to do something like what you want. Note that something like the following will not compile:

tApply (+) $ 1 :. (2 :: Int) :. TEmpty

We have to explicity type annotate everything:

tApply ((+) :: Int -> Int -> Int) $ (1 :: Int) :. (2 :: Int) :. TEmpty :: Int

This gives 3 as we might expect. I'm not sure how to get around this necessity; I expect some clever use of FunctionalDependencies would do the trick.

Answer 3

I use usually match patterns like

let (a:b:c:_) = args
in  func a b c

or inlined

(\(a:b:c:_) -> func a b c) args

if you really want do that you can create one operator to "inyect" element lists to any function

showAdd2 <<< args

but I think is not very usable...

{-# LANGUAGE FlexibleInstances, UndecidableInstances, ConstraintKinds, InstanceSigs, MultiParamTypeClasses #-}
class App a b c where
  (<<<) :: a -> [b] -> c

instance App (b -> b -> c) b c where -- 2-arity
  (<<<) f (a:b:_) = f a b

instance App (b -> b -> b -> c) b c where -- 3-arity
  (<<<) f (a:b:c:_) = f a b c

instance App (b -> b -> b -> b -> c) b c where -- 4-arity
  (<<<) f (a:b:c:d:_) = f a b c d

showAdd2 :: Int -> Int -> String
showAdd2 a b = show (a + b)

showAdd3 :: Int -> Int -> Int -> String
showAdd3 a b c = show (a + b + c)

main = do

    let args = [5..8] :: [Int]

        r2 = showAdd2 <<< args
        r3 = showAdd3 <<< args

    putStrLn r2
    putStrLn r3

a more usable version could be

i2 :: (b -> b -> c) -> [b] -> c
i2 f (a:b:_) = f a b

but you must to select the proper "inyector" for each case

showAdd2 `i2` [4..5]

(In Haskell the use of algebraic data types, lists and classes replace properly the need of polyvariadic functions. As @user5402 say, you should provide some explicit problem)

Answer 4

Why Lists themselves don't work

In the narrowest sense of the question,

Is there a standard Haskell function (or pattern) to extract the contents of a list and feed them as though they are the ordered positional arguments to a function?

this has a very simple answer "no". The reason why such a function does not exist is because the type signature cannot easily make sense. The type signature you're asking for is:

applyToList :: (a -> c) -> [a] -> d

where the c either has the form a -> c' (in which case we recurse the definition) or else has the type d itself. None of the Prelude functions have wacky type signatures.

If you actively ignore this and try anyway, you will get the following error:

Prelude> let applyToList f list = case list of [] -> f; x : xs -> applyToList (f x) xs

<interactive>:9:71:
    Occurs check: cannot construct the infinite type: t1 ~ t -> t1
    Relevant bindings include
    xs :: [t] (bound at <interactive>:9:52)
    x :: t (bound at <interactive>:9:48)
    list :: [t] (bound at <interactive>:9:19)
    f :: t -> t1 (bound at <interactive>:9:17)
    applyToList :: (t -> t1) -> [t] -> t -> t1
        (bound at <interactive>:9:5)
    In the first argument of ‘applyToList’, namely ‘(f x)’
    In the expression: applyToList (f x) xs

The problem here is that when the typechecker tries to unify c with a -> c it constructs an infinite type; it has a cycle-detection algorithm which stops it, so it prematurely errors out.

There is a more fundamental problem here, which is the question of what applyTo (+) [3] should yield. Here (+) has type n -> n -> n for some n. The morally right answer is (3+) :: n -> n; but if you really want to consume all of the arguments of your list you probably want it to return undefined :: n instead. The reason that you cannot use the morally right answer is because you reject the definition applyTo f = f . head (which is typeable and does the above). The problem in the abstract is that the length of [3] is not known until run-time. You could insert an arbitrary expression in there. You could try to run this on an array which has length 1 if Goldbach's conjecture is true, or else length 2 if it is not; is the type system supposed to solve Goldbach's conjecture for you?

How to make them work

That last point actually contains the solution. We need to annotate the functions with their arities:

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, FunctionalDependencies, UndecidableInstances #-}
-- no constructors; these exist purely in the type domain:
data Z
data S n

class Reducible f a x | f -> a x where applyAll :: f -> [a] -> x

newtype Wrap x n = Wrap x -- n is a so-called "phantom type" here

rewrap :: Wrap x n -> Wrap x (S n)
rewrap (Wrap x) = Wrap x

wrap0 :: x -> Wrap x Z
wrap0 = Wrap

wrap1 = rewrap . wrap0
wrap2 = rewrap . wrap1
wrap3 = rewrap . wrap2
wrap4 = rewrap . wrap3

apply :: Wrap (a -> x) (S n) -> a -> Wrap x n
apply (Wrap f) a = Wrap (f a)

instance Reducible (Wrap x Z) a x where
    applyAll (Wrap x) [] = x
    applyAll (Wrap x) _ = error "function called on too many arguments"

instance (Reducible (Wrap y n) a x) => Reducible (Wrap (a -> y) (S n)) a x where
    applyAll (Wrap f) [] = error "function called on too few arguments"
    applyAll w (x : xs) = applyAll (apply w x) xs

You can then write something like:

wrap3 (\x y z -> (x + y) * z) `applyAll` [9, 11, 2]

and it will rightly construct 40.

As you can tell, this involves a lot of baggage, but it's all necessary to tell the compiler "hey, this function is going to have three arguments so a list of length 3 is perfect for it" in a fully generic way.

Of course, writing applyAll (wrap3 ___) ___ is tedious. However, if you're trying to build a library of functions with arbitrary arities, you can probably work in some extra functions which manage those arities for you.

You may also want to annotate the length of your lists with Z, S Z, etc. -- in this case I think you can get an applyAll which does currying. Also, as another answer pointed out, you might be able to get a good distance with having multiple constructors for Wrap which move the recursion into the data type itself -- possibly being able to remove some of those nasty language extensions.

Answer 5

It's not possible to write truly arity-generic functions without dependent types or tons of extensions, but you can cheat a bit:

z :: b -> [a] -> b 
z x _ = x

s :: (b -> [a] -> c) -> (a -> b) -> [a] -> c
s h f (x:xs) = h (f x) xs
s _ _    _   = error "function called on too few arguments"

sum3 a b c   = a + b + c
tup4 a b c d = (a, b, c, d)

main = do
    print $ z               0    [1..4] -- 0
    print $ s (s (s z))     sum3 [1..4] -- 6
    print $ s (s (s (s z))) tup4 [1..4] -- (1, 2, 3, 4)
    -- print $ s (s (s (s z))) tup4 [1..3] -- runtime error

Or if you want to throw an error, if there are to many elements in a list, then change the definition of z to

z :: b -> [a] -> b 
z x [] = x
z _ _  = error "function called on too many arguments"