More type design questions
Brandon Michael Moore
Mon, 18 Aug 2003 10:26:25 -0700 (PDT)
I think what you want are functional dependencies.
On Mon, 18 Aug 2003, Konrad Hinsen wrote:
> On Monday 18 August 2003 09:25, Bernard James POPE wrote:
> > The kinds are there to help the compiler check whether types are well
> > formed (including such things as instance declarations).
> > The syntax for kinds is very simple:
> Thanks for the explanation! It seems that what I need (but what apparently
> doesn't exist) is the equivalent of a lambda expression for type
> constructors, then I could write something like
> instance Vect (\a -> [Vector a]) a where
> > One way around this might be to define a new type:
> > newtype ListVector a = LV [Vector a]
> > instance Vect ListVector a where
> > (<+>) (LV l1) (LV l2) = LV $ zipWith (<+>) l1 l2
> > Though is is bit ugly to have to mention the LV constructor all the time.
> It's not just ugly, it destroys the generality of my code. I would like to be
> able to have generic list processing functions (think of "map") produce lists
> of vectors and then be able to apply the functions in class "Vect" to them.
> If I introduce a new type, then I will have to put wrapper functions in many
> places. I really want a type that is a list *and* an instance of class Vect.
> In fact, what I'd really like to have is even more general:
> instance Vect v a => Vect [Vect v a] where
> i.e. defining that a list of any Vect instance is itself a Vect instance. But
> I could live with the case that I presented initially.
The class you had,
class (Num a) => Vector v a where
<+> :: v a -> v a -> v a
<*> :: a -> va -> v a
requires that v be a type constructor that gives vectors when applied to a
ring. Using functional dependencies you can write a types class that says
a type is a vector containing elements of type a:
class (Num a) => Vector v a | v -> a where
<+> :: v -> v -> v
<*> :: a -> v -> v
The type of <+> wouldn't be allowed without the dependancy v -> a, becuase
a is never mentioned in the type so there would be no way to figure out
what instance to use. The dependancy says "knowing the v type of an
instance uniquely determines the a type". The compiler checks that your
instance declarations satisfy this, and use the information when resolving
you can still declare an instance for your vector type
instance (Num a) => Vector (Vector a) a where
<+> = ...
<*> = ...
(Notice that this declare an instance for all a)
You can also declare instances for v that are not type constructors
data Point = Point Float Float Float
instance Vector Point Float where
(Point x y z) <+> (Point x2 y2 z2) = Point (x+x2) (y+y2) (z+z2)
a <*> (Point x y z) = Point (a*x) (a*y) (a*z)
And, you can declare an instance for lists:
instance (Vector v a) => Vector [v] a where
as <+> bs = zipWith (<+>) as bs
a <*> vs = map (a<*>) vs
With GHC this requires -fglasgow-exts (and maybe -fundecidable-instances),
with Hugs you need +98.
The GHC users guide, the Haskell Wiki, and the paper "Type Classes:
Exploring the Design Space" are all good places for more information.