[Haskell-cafe] Are associated types synonyms like type classes?
Brian Smith
brianlsmith at gmail.com
Sat Sep 2 14:19:17 EDT 2006
Bulat, Stefan,
My question wasn't clear. I understand already that classes with associated
types are are alternative to MPTC with fundeps.
When using AT then we have to decide what part of the abstraction is the
class and what part is the associated type. Sometimes this seams arbitrary.
If we have:
class A a where
type B b
f :: a -> B b
instance A Int where
type B = Bool
f = (==0)
Can't we also rewrite it as:
class B b where
type A a
f :: A a -> b
instance B Bool where
type A = Int
f = (==0)
What is the practical difference between class A and class B? With class A
we can define instances so that f is overloaded (Int -> Bool), (String ->
Bool), (Bool -> Bool) by defining instances of A for Int, String, and Bool,
but we cannot overload it more (Int -> String), (Int -> Int) because we can
only have on "instance A Int". The converse is true for class B. Is that the
only difference?
If so, then why do we have "associated types" instance of "associated
classes" like this?:
class A a where
class B b where
f :: a -> b
instance A Int where
instance B Bool where
f = (==0)
The made-up syntax I presented in my previous message was just a different
way of writing the above (which is also made-up syntax):
class A a, B b where f :: a -> b
instance A Int, B Bool where f = (==0)
class Elem elem, Collect collect where
empty :: collect
insert :: elem -> collect -> collect
toList :: collect -> [elem]
Thanks for your help,
Brian
On 9/1/06, Bulat Ziganshin <bulat.ziganshin at gmail.com> wrote:
>
> Hello Brian,
>
> Friday, September 1, 2006, 8:32:55 PM, you wrote:
>
> > I read the easy parts of the "Associated Types with Class" and
> > "Associated Type Synonyms" papers. An associated type synonym seems
> > to kind of work similarly to a restricted form of class. In what way
> > are the two following examples different?
>
> > -- define a class with a type synonym, and a set of operations
> > class A a where
> > type B b
> > foo :: a -> B b
>
> > instance A Int where
> > type B = Bool
> > foo = (==0)
>
> > -- define two classes, and an function that .
> > class A a, B b where
> > foo :: a -> b
>
> > instance A Int, B Bool where
> > foo = (==0)
>
> where you've find such unusual syntax? :) GHC/Hugs supports
> multi-parameter type classes (MPTC):
>
> class AB a b where
> foo :: a -> b
>
> instance AB Int Bool where
> foo = (==0)
>
> AT replaces MPTC with FD (functional dependency), which allows to
> specify which type parameter of MPTC is detremined by another one, i.e.:
>
> class AB a b | a->b where ....
>
> for further details about MPTC+FD see chapter 7.1.1 in the
> http://cvs.haskell.org/Hugs/pages/hugsman/exts.html
>
>
>
> > Also, has anybody written a paper on the differences between
> > typeclasses + associated types and ML's module system + overloading?
>
> "ML Modules and Haskell Type Classes: A Constructive Comparison"
>
> http://www.informatik.uni-freiburg.de/~wehr/diplom/Wehr_ML_modules_and_Haskell_type_classes.pdf
>
>
> --
> Best regards,
> Bulat mailto:Bulat.Ziganshin at gmail.com
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org//pipermail/haskell-cafe/attachments/20060902/9ff03517/attachment.htm
More information about the Haskell-Cafe
mailing list