On May 19, 2006, at 2:49 PM, Jeremy Shaw wrote:
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/3646ef7e64124301/2a3a33bfd23a7184
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
This seems like it is just an ugly way to spell 'foldl'. Is there
something fundamentally different about this approach, besides the
slightly odd typing? I understand its relation to the OP, but I'm
just curious now...
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
Rob Dockins
Speak softly and drive a Sherman tank.
Laugh hard; it's a long way to the bank.
-- TMBG
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
