I am looking for collaborators for the following project:

I am considering to create a Ruby-like language in Ocaml.

The main difference would be that it would be compiled
while assuring type safety.

It would be both interpreted (first pass), then a selected
subset of methods are mapped to Ocaml classes and
they get compiled.  It would be completely reflexive,
so the first pass would be able to modify the syntax tree
in any possible way.

So, the language would basically operate on itself as
a preprocessor (without type checks), then the second
phase would be done with exact type checking.

The Ruby (I don't plan to implement the whole language
at first, just the most important part of it.) classes
are mapped to Ocaml classes. The implementation
would only use a small part of Ocamls features.

Anyway, you would be able to program without writing
supplying ANY type information, just like in a scripting
language, but the compiler would detect
all possible type problems. Of course, that means that
every single data (integers,floats, etc.) are wrapped
by Ocaml classes, which would effect the run-time
compared to native Ocaml code considerable. However,
according to my preliminary test, they it would be still much
faster then a Ruby (or Python) code. The main advantage
of the approach is the additional safety of type checking.

The advantage over OCaml would be: easier to learn for
beginners. Full scale polymorphism and overloading.
Of course, you can achieve the same effect right now,
but it would simplify things quite a bit.

The front-end and the back-end would make heavy use
of CamlP4.

I would start with actual coding if I find someone somone
seriously interested.

-------------------
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