Casting + eta reduction

Simon Peyton-Jones simonpj at
Fri Jul 16 05:51:55 EDT 2010

now I understand. I've created a Trac ticket.  Shouldn't be hard.


From: glasgow-haskell-users-bounces at [mailto:glasgow-haskell-users-bounces at] On Behalf Of Louis Wasserman
Sent: 13 July 2010 17:46
To: Simon Peyton-Jones
Cc: glasgow-haskell-users at
Subject: Re: Casting + eta reduction

Or a different way:

I want -fdo-lambda-eta-expansion (which, if I understand correctly, actually triggers eta *reduction*) to eliminate argument casts, as well.

My motivation:  I'm working on a generalized trie library, and due to, I can't use GeneralizedNewtypeDeriving to minimize the overhead of a stack of about 20 newtypes, each with their own class instance, even if I wasn't trying to use Template Haskell, which currently has no syntax for doing GeneralizedNewtypeDeriving on multi-parameter type classes (it only derives single-argument type classes.)  As it stands, I have a lot of methods that compile to

foo f = bar (\ x -> f (x `cast` a))

and they stack 20 deep, which means I have to do 20 allocations (\ x -> f (x `cast` a)) for even the most simple methods.  What I'd like to see is this getting reduced to

foo  = bar `cast` (...)

which would reduce my overhead significantly.

Louis Wasserman
wasserman.louis at<mailto:wasserman.louis at>

On Tue, Jul 13, 2010 at 10:06 AM, Louis Wasserman <wasserman.louis at<mailto:wasserman.louis at>> wrote:
Mmmm, let's give a slightly different example:

foo :: Foo -> Int
foo (Foo a) = a + 1

bar :: Int -> Int
bar = foo . Foo

and I'd expect bar to be replaced with (foo `cast` (Int -> Int)) and inlined, eliminating an allocation.  In general, we'd get the equivalent of the no-allocation versions of GeneralizedNewtypeDeriving instances, so long as we could write them out for ourselves.

Louis Wasserman
wasserman.louis at<mailto:wasserman.louis at>

On Tue, Jul 13, 2010 at 9:09 AM, Simon Peyton-Jones <simonpj at<mailto:simonpj at>> wrote:
It compiles to

lift f d = f (d `cast` blah)

which seems fine to me.  Are you unhappy with that?


From: glasgow-haskell-users-bounces at<mailto:glasgow-haskell-users-bounces at> [mailto:glasgow-haskell-users-bounces at<mailto:glasgow-haskell-users-bounces at>] On Behalf Of Louis Wasserman
Sent: 09 July 2010 03:30
To: glasgow-haskell-users at<mailto:glasgow-haskell-users at>
Subject: Casting + eta reduction


newtype Foo = Foo Int

lift :: (Int -> a) -> Foo -> a
lift f (Foo x) = f x

Now, I'd expect this to compile with -O2 down to something like

lift f = f `cast` (Foo -> a)

but it doesn't.

It seems that GeneralizedNewtypeDeriving assumes that these two things *are* equivalent, and it just directly casts the class dictionary.  The implication would be that that GeneralizedNewtypeDeriving gives more efficient instances than you could *possibly* get if you wrote them by hand, which is very sad.

Louis Wasserman
wasserman.louis at<mailto:wasserman.louis at>

-------------- next part --------------
An HTML attachment was scrubbed...

More information about the Glasgow-haskell-users mailing list