Re: qques questions sur Lissac et... Ruby, Java, Caml...

Lisaac comme Langage ISAAC :)


(1) A première vue, du point de vue la syntaxe et du fait que tout à l'air objet pour Ruby et Lissac, Lissac me fait penser à Ruby

Est-ce que qqu'un a comparé ces deux langages ?

Pas à ma connaissance. Personnelement, je ne connais rien à ce langage.

Serait-il possible de mettre en oeuvre les optimisations de Lissac pour d'autres langages ?

Je m'étonne qu'il y ait fallu quasiment une semaine pour que quelqu'un pense enfin à poser la question.

Je pense que, sauf les fonctionalitées comme la réflexivité, etc... on pourrait tout à fait utiliser le compilateur Lisaac pour compiler du Java, du C++ (beuurk), d'autres.
Il faudrai pour cela pas mal retravailler l'objet PARSER pour lui faire bouffer la syntaxe.
J'ai un peu peur duand à la gestion des mots clé, qui sont énormes dans ces langages.
Ca serait un gros parser, mais ça passerai.

Ce qui serait marrant, c'est du Java aussi rapide que du C....


(3) Ruby connait un grand enthousiasme en ce moment via (a) le framework Ruby On Rails pour la programmation web et (b) comme candidat pour fabriquer facilement des DSL (via la métaprogrammation ?).

Si Lissac, via la compilation, enfonce Ruby (dont le coté dynamique a l'air d'avoir un cout), et supporte des fonctionnalités analogues à celles de Ruby, Lissac pourrait aussi être positionné sur les mêmes créneaux (a) et (b).

Cela a-t-il été envisagé ?

Peut être pas sous cet angle, et que par moi (les délires sur les langages du futur, c'est ma spécialité)
Mais je v étudier la question, le titre "Creating a weblog in 15 minutes" est assez bandant.

Si t'as des idées là dessus, tu es le bienvenu, les discussions sur les spécifications 0.3 et surtout 0.4 de Lisaac sont ouvertes (la 0.2 est en train d'être implémentée).
Fais moi signe ;)


(4) Lissac supporte-il le polymorphisme à la Caml ?

par exemple, en Caml, on peut écrire une fonction telle que (j'écris de mémoire) :

let rec size list = match list with
[] -> 0
| head::tail -> (size tail) + 1

et cette fonction est typé comme ['a] -> int : elle peut opérer sur des listes de n'importe quoi.

A vue de nez, ça donnerai

- size lst :LINKED_LIST[E] : INTEGER <-
(
+ result : INTEGER;
+ tmp : LINKED_LIST[E];
(lst.count <1).if {result :=0} else
{
lst.remove_first;
result := (size lst) +1;
}
result
);

Bon là je me rend compte, que j'en ai marre, je veux une fonction tail et une fonction head dans les collections.
- size lst :LINKED_LIST[E] : INTEGER <-
(
+ result : INTEGER;
+ tmp : LINKED_LIST[E];
(lst.count <1).if { result :=0;
} else { result := (size lst.tail) +1; };
result
);
C'est mieux
Ya encore du progrès à faire.
La futur version 0.2 qui sort bientôt te permettra de rendre plusieurs valeurs, comme caml, donc de faire du vrai fonctionnel.


public SortedMap<ArrayList<MBeanServerInvocationHandler>> getFoo() {
SortedMap<ArrayList<MBeanServerInvocationHandler>> foo =
new SortedMap<ArrayList<MBeanServerInvocationHandler>>();
foo.doSomething();
return foo;
}

Oui effectivement...

Section PUBLIC
- get_foo lst : SORTED_MAP[ARRAY[MBEAN] <-
(
+ foo : SORTED_MAP[ARRAY[MBEAN] := SORTED_MAP[ARRAY[MBEAN].create;
foo.do_something;
foo
}

(5) en Caml, on peut aussi faire du pattern matching, une sorte de switch, comme en C, mais amélioré car pouvant porter sur des types de données qui ne sont pas limités au type 'int'.

Est-ce possible via Lissac ?

Merci de vos éclaircissements.

Non, mais moi j'aimerai bien.
Alors comme il se trouve que Xavier Leroy et Benoit Sonntag se connaissent, j'aimerai bien que ce soit implémenté dans le compilo.
Ca va venir, je pense.

Cela dit, je pense qu'il est implémentable dans la lib un truc similaire mais un moins puissant.
Faudrait y réfléchir.
Tu me donnes une idée, merci :)

« Il n’y a pas de choix démocratiques contre les Traités européens » - Jean-Claude Junker