[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: -- (:) From: kahl@c... Subject: Re: [Caml-list] Haskell class type simulation
<johan.baltie@wanadoo.fr> wrote:
>
> I'm currently looking for a way to simulate the Haskell "class type" notion
> in OCaml i.e. the same kind of :
>
> class Eq a where
>     (==), (/=) :: a -> a -> Bool
>
> class (Eq a) => Ord a where
>     compare                :: a -> a -> Ordering
>     (<), (<=), (>=), (>)   :: a -> a -> Bool
>     max, min               :: a -> a -> a
>
> For me it's a bit like module signature with an abstract type and an
> "extending" semantic and a type constraint.

We looked the other way in:

@InProceedings{Kahl-Scheffczyk-2001,
author = 	 {Wolfram Kahl and Jan Scheffczyk},
title = 	 {Named Instances for Haskell Type Classes},
booktitle = 	 {Proc.\null{} Haskell Workshop 2001},
year = 	 {2001},
editor = 	 {Ralf Hinze},
volume = 	 {59},
number = 	 {2},
series = 	 ENTCS,
abstract = {Although the functional programming language Haskell
has a powerful type class system,
users frequently run into situations
where they would like to be able to define or adapt
instances of type classes
only \emph{after} the remainder of a component has been produced.
essentially only allows late binding
of type class constraints on free type variables,
and not on uses of type class members
at variable-free types.

In the current paper we propose a language extension that
enhances the late binding capabilities of Haskell type classes,
and provides more flexible means for type class instantiation.
The latter is achieved via \emph{named instances}
that do not participate in automatic context reduction,
but can only be used for late binding.
By combining this capability with the automatic aspects
of the Haskell type class system,
we arrive at an essentially conservative extension
that greatly improves flexibility of programming
using type classes and opens up new structuring principles

We exemplify our extension
through the sketch of some applications
and show how our approach could be used
to explain or subsume other language features
as for example implicit parameters.
We present a typed lambda-calculus for our extension
and provide a working prototype type checker on the basis of
Mark Jones' Typing Haskell in Haskell''.}
}

Best regards,

Wolfram

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners