Re: [Haskell-beginners] Understanding the type signature of flip$id

Hi Christian, As a beginner I think it's easier to read the intention of 'flip ($)' rather than flip$id, where I found it used to resolve command line arguments. Thanks for that. Jeff On 2 March 2011 18:51, Christian Maeder wrote:

Maybe "flip ($)" is clearer? ($) is identity over function types.

If you have the (first) argument you could use a section like "($ a)" and avoid flip.

C.

Am 02.03.2011 06:33, schrieb Jeff Lasslett:

...

Thanks Daniel,

I think I follow what you've written.

(b -> c) -> (b -> c) is the same as (b -> c) -> b > c

and when that is flipped: b -> (b- > c) -> c

Is that right?

Thanks, Jeff

On 2 March 2011 11:23, Daniel Fischer wrote:

...

On Wednesday 02 March 2011 00:43:23, Jeff Lasslett wrote:

...

 I just don't understand how passing id to flip results in the following type signature:

Prelude> :t flip$id flip$id :: b -> (b -> c) -> c

I do understand what flip has done to map here:-

Prelude> :t flip$map flip$map :: [a] -> (a -> b) -> [b]

map take a function and a list and produces a new list.  If map is passed to flip the result is a function that takes a list, then a function and results in a new list.

How do we go from flip having this signature:

Prelude> :t flip flip :: (a -> b -> c) -> b -> a -> c Prelude>

and id having

Prelude> :t id id :: a -> a Prelude>

to flip$id looking like flip$id :: b -> (b -> c) -> c   ???

Thanks, Jeff

The point is that the type of id has to be unified with the type of flip's (first) argument.

flip :: (a -> b -> c) -> (b -> a -> c) id :: t -> t

So we have to unify (a -> b -> c) and (t -> t). Fully parenthesized, a -> b -> c is a -> (b -> c). Now unification yields

t = a -- id's arg must have the same type as the flip's argument's arg

and

t = (b -> c) -- id's result must have the same result as flip's argument's result

From that follows a = (b -> c) and *id can be passed to flip only at a more restricted type than id's most general type, namely at the type id :: (b -> c) -> (b -> c)*

So,

flip (id :: (b -> c) -> b -> c) :: b -> (b -> c) -> c