Fwd: [Haskell-beginners] help with types and composition

[Alexander Dunlap]

Oops...wrong list address...sorry


---------- Forwarded message ----------
From: Alexander Dunlap <alexander.dunlap at gmail.com>
Date: Thu, Jul 2, 2009 at 8:54 PM
Subject: Re: [Haskell-beginners] help with types and composition
To: Britt Anderson <britt at uwaterloo.ca>, haskell-beginners at haskell.org


On Thu, Jul 2, 2009 at 10:54 AM, Britt Anderson<britt at uwaterloo.ca> wrote:
> I would like to write a function that takes two lists of numbers and returns
> a number. For simplicity, let's assume an integer, i.e.
> myfunc:: [Integer]->[Integer]->Integer
> But I can't quite get things right when trying to
> define myfunc = ...
>  and making the arguments implicit.
>
> My difficulty might be seen with the following two functions,
> let,
>
> f1 = (zipWith ($)) . (map  (*))
>
> f2 = sum
>
>
> if I set the types such that f1 returns [Integer] and sum accepts [Integer]
> it seems that somehow I should be able to compose them in to a single
> function that takes two lists and returns the number, but f1 . f2 and
> numerous variations don't work. I can curry some list l and f1 . (f2 l)
> works, but is there a way to get f1 and f2 combined into a function that
> accepts two lists?
>
>
> My problem is not really about writing the function but about composition. I
> can write the function with arguments or a local lambda  that suits my
> practical purpose. But the fact that I think I should be able to compose f1
> . f2 somehow reveals a conceptual misunderstanding that I hope someone will
> help me clear up.
>
> Thank you,
> Britt Anderson
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>

Try

(f2 .) . f1

. The type of (f2 .) is (a -> [Integer]) -> a -> Integer and the type
of (.) is (b -> c) -> (a -> b) -> (a -> c) so for the second (.), b ::
([Integer] -> [Integer]), c :: ([Integer] -> Integer) and a ::
[Integer] so the final type is [Integer] -> [Integer] -> Integer. (It
might be easier to work out the types yourself if you can - my
description is doubtless rather difficult to follow.)

A word of caution, though - most Haskellers in my experience prefer to
not do this type of composition; they find it clearer to specify one
or both of the arguments explicitly.

Hope that helps you,

Alex