[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
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
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 at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
More information about the Haskell-Cafe
mailing list