Clean 2.0

[Nick Kallen]

> > Would a member Clean team be kind enough to enumerate the (intended) new
> > features of Clean 2.0?
>
> New:
> - multi-parameter type constructor classes
> - dynamic types, dynamic linking
> - small stuf, among which new scope rules for modules

I'd be interested in hearing about the small stuff when you guys have time!
:)

> > Also:
> > - What features have been considered but decided against?
>
> Apart from the things above we first want to have a compiler with the
> same features as the old compiler albeit the new compiler is written in
> Clean.
> The new compiler should enable us to add new features more quickly.
> Once the new compiler is stable we will add some other stuf.
> We of course also have a long list of thing we would like to add or
> change.
> We are open for suggstions, but our first priority is to get the new
> system stable.

Having the Clean compiler written in Clean sounds great. I'm curious as to
what speed penalties (or gains!) you've encountered with this? It has been
requested before that you guys provide a parser and an evaluator. I'm
wondering if this will become something you'll do after the new compiler is
written? There are at least three advantages I can think of:

- If you guys provided an extensible grammar and parser, we could play
around with simple transformational programming and using Clean for DSLs
- An evaluator would allow embedded scripting languages in programs. This is
useful (for example) in the spreasheet program that's part of the Clean
book.
- The IDE could do some Reall Nifty Stuff.
- This would be a good example of the utility of Dynamic types: eval ::
String -> Dynamic.

> > - Would you guys be interested in hearing a wish lish for Clean
> 2.0/3.0(?)

Subtyping would be awesome.

http://research.microsoft.com/Users/luca/Papers/StructuralSubtyping.pdf

I believe this is extremely useful for "programming in the large." Combined
with higher order polymorphism traditional (stateless) class-based object
orientation can be implemented:
http://www.cis.upenn.edu/~bcpierce/papers/compobj.ps.gz
and http://www.cis.upenn.edu/~bcpierce/papers/oop.ps.gz

Subtyping is a somewhat conservative addition to the type system because it
keeps the system decidable *in practice*. Higher Order polymorphism is also
to some extent decidable in practice; Pierce uses it, for example in his
Pict programming language.