Hello, 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: http://groups.google.com/group/comp.lang.functional/browse_thread/thread/364... 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 continuation: 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 case): 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] 6 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')) j. 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@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe