Would there be any problems if there were an artificial "<-" type constructor in Haskell which was basically: type a <- b = b -> a but not a type synonym so you could define it to be instances of classes, but then those get applied "backwards" to ->? Okay, that made no sense. I'll try again. Type lambda = bad (undecidable). What about only type lambda on function types and not even type lambda; simply allow partial application to the second argument *only* on ->? This would solve my problem and I believe that of an earlier poster who wanted to define catamorphisms (I think; don't feel like checking), but couldn't because of this restriction. Is this still "too loose" to be made to work? -- Hal Daume III "Computer science is no more about computers | hdaume@isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume On Mon, 22 Apr 2002, Simon Peyton-Jones wrote:

Hal,

[I think this sort of question would be better on the haskell-cafe list.]

I don't think what you want can be done directly. It's the old thing about not having lambdas at the type level. You want:

instance Eq a => Coll (\x. x -> Bool) a where ...

and you just can't do that. You *can* abstract the second argument of (->):

instance Eq a => Coll ((->) Bool) a where ...

but not the first. It's a well known shortcoming in Haskell, that you can partially apply type constructors, but you can't do argument permutation.

I know of no good solution. Adding type lambdas in their full glory makes type inference pretty much impossible. What we'd like is a compromise. Maybe someone can invent one. But take care. The ground is littered with corpses.

Simon

| -----Original Message----- | From: Hal Daume III [mailto:hdaume@ISI.EDU] | Sent: 23 April 2002 01:30 | To: Jorge Adriano | Cc: Haskell Mailing List | Subject: Re: defining (-> Bool) as a set | | | Yeah, both options suggested are valid, of course. But I | really don't want to have a constructor and I'm using Edison | where Coll is defined something like: | | class Coll c e where | empty :: c e | insert :: c e -> e -> c e | | etc., which precludes the fun dep solution. | | - Hal | | -- | Hal Daume III | | "Computer science is no more about computers | hdaume@isi.edu | than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume | | On Tue, 23 Apr 2002, Jorge Adriano wrote: | | > | > > class Collection e ce | ce -> e where | > > empty :: ce | > > insert :: e -> ce -> ce | > > member :: e -> ce -> Bool | > > | > > instance Eq a => Collection a (a -> Bool) where | > > empty = (\x -> False) | > > insert e f = (\x -> if x == e then True else f x) | > > member e f = f e | > | > This is way better than my solution... | > | > I had never used multi-parameter classes before, so I forgot the | > functional | > dependency (right name? the "|ce->e"), and there was | obviously no need for my | > extra constructor. | > | > J.A. | > | | _______________________________________________ | Haskell mailing list | Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell |