defining (-> Bool) as a set
Hal Daume III
hdaume@ISI.EDU
Fri, 26 Apr 2002 12:14:26 -0700 (PDT)
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
> |
>