[Haskell-cafe] Newbie: Applying Unknown Number Arguments to A Partial Function

Jeremy Shaw jeremy.shaw at linspireinc.com
Fri May 19 14:49:38 EDT 2006


You can do it -- but it may not be very useful in its current
form. The primary problem is, "What is the type of 'f'?"

> applyArgument f [arg] = f arg  -- NOTE: I changed (arg) to [arg]
> applyArgument f (arg:args) = applyArgument (f arg) args

Looking at the second line, it seems that f is a function that takes a
value and returns a function that takes a value and returns a function
that takes a value, etc. Something like:

f :: a -> (a -> (a -> (a -> ...)))

This is called an 'infinite type' and is not allowed in haskell (or
ocaml by default) because it allows you to introduce type errors that
the compiler can not catch:


If you introduce a wrapper type, you can make the type checker happy:

newtype F a = F { unF :: a -> F a }

applyArgument :: F a -> [a] -> F a
applyArgument (F f) [arg] = f arg
applyArgument (F f) (arg:args) = applyArgument (f arg) args

Of course, your final result is still something of type 'F a' -- so it
is probably not very useful -- because all you can do is apply it more
more things of type a and get more things of type 'F a'.

One option would be to modify the function to return a result and a

newtype F a = F { unF :: a -> (a, F a) }

applyArgument :: F a -> [a] -> a
applyArgument (F f) [arg] = fst (f arg)
applyArgument (F f) (arg:args) = applyArgument (snd (f arg)) args

Then you define a function like this (a simple sum function in this

f :: (Num a) => a -> (a, F a)
f a' = (a', F $ \a -> f (a + a'))

example usage:

*Main> applyArgument (snd (f 0)) [1,2,3]

Here is another variation that allows for 0 or more arguments instead
of 1 or more:

newtype F a = F { unF :: (a, a -> F a) }

applyArgument :: F a -> [a] -> a
applyArgument (F (result, _)) [] = result
applyArgument (F (_ , f)) (arg:args) = applyArgument (f arg) args

f :: (Num a) => a -> F a
f a' = F (a', \a -> f (a + a'))


At Fri, 19 May 2006 02:25:31 +0000,
Aditya Siram wrote:
> I am trying to write a function 'applyArguments' which takes a function and 
> a list and recursively uses element each in the list as an argument to the 
> function. I want to do this for any function taking any number of arguments.
> applyArgument f (arg) = f arg
> applyArgument f (arg:args) = applyArgument (f arg) args
> This has failed in Hugs, so my question is: Can I conceptually do this? If 
> so, what is the type signature of this function?
> Deech
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

More information about the Haskell-Cafe mailing list