• [^] # Re: Représentations intermédiaires du compilateur OCaml

    Posté par . En réponse au journal Malfunction: réutiliser la représentation intermédiaire du compilateur OCaml. Évalué à 1.

    C'est un langage intermédiaire, pas un langage de surface pour les utilisateurs.

    Oui, donc il faut encore plus une syntaxe spécifiée, c'est à dire, avec une spécification. Parce que bon, dépendre d'un truc qui peut casser à tout moment je trouve que c'est pas super. Ou alors il faut que ocaml puisse garantir une certaine stabilité de cette représentation intermédiaire, ce qui apparement n'est pas à l'ordre du jour.

    C'est en fait le point clef d'utiliser un scheme plutôt qu'une représentation qui de l'avis même de l'auteur, n'aurait jamais du être exposée en dehors du compilateur.

    De plus, j'ai l'impression que du confonds la syntaxe de malfunction et la syntaxe de Lambda. Qui sont apparemment deux langages différents, par exemple quand tu parles de

    Du moment que la syntaxe est non-ambiguë, clairement définie et facile à produire et à lire, ça pourrait être du XML ça n'aurait aucune importance.

    C'est à propos de Malfunction, et non pas de Lambda. Or, la question porte justement sur le fait de remplacer Lambda par un scheme ... donc cette remarque n'a strictement aucun intérêt (elle ne porte pas sur le bon objet).

    Ensuite, j'ai l'impression que l'objectif n'est pas bien défini. Parce que d'un côté tu dis

    Beuh, encore une fois le but c'est d'obtenir facilement un compilateur décent pour un langage expérimental à moindre coût,

    Et ensuite

    Imagine que j'ai un programme OCaml qui veut appeler une fonction Links

    Ce qui veut dire que même une fois que ton langage devient « mûr » tu veux continuer à utiliser cette architecture ? Même si de ton propre avis

    si pour cela il faut piper dans un fichier texte au milieu, je ne vois pas vraiment le soucis

    Ce qui (pour moi) sous-entends que c'est une phase « alpha », prototype, enfin, quelque chose de pas propre. Et quand on voudra le faire proprement, voilà ce qu'il va se passer :

    manipuler directement la compilation (mais encore une fois elle n'est pas stable)

    Ah, bah, on repose sur un truc instable, génial.

    Lambda a bien une représentation des valeurs qui permet de manipuler les types sommes (puisque c'est la représentation intermédiaire du compilateur OCaml, qui en a)

    Je veux bien te croire sur parole (étant donné qu'il n'existe pas de spécification du langage), mais cet argument est quand même bien foireux, je te le refais

    ASM x86 a bien une représentation des valeurs qui permet de manipuler les types sommes (puisque c'est la représentation du compilateur OCaml, qui en a)

    Hophophop, voilà ! Bon, j'ai retiré « intermédiaire » et changé le nom ... Soit ce que tu dis est qu'il est possible de le faire simplement, ce qui est le cas dans à peu près n'importe quel langage (même x86) soit tu dis qu'il existe une syntaxe spéciale, et alors l'argument n'a aucune valeur.

    Je ne vois pas vraiment l'intérêt.

    C'est minime, c'est juste que bon, tu n'as pas à construire :

    1. Un lexer
    2. Un parser
    3. Un programme qui va compiler un AST vers un autre langage

    En plus, le fait que tout soit « au même niveau » permet aux gens d'ajouter si besoin des syntaxes à ton langage de macros, ou d'en changer le sens plutôt facilement, en restant dans un même langage, plutôt que de devoir utiliser du ocaml pour changer le fonctionnement d'un langage (malfunction) et la manière dont il se compile vers un troisième (Lambda).

    Après c'est vrai que c'est beau en théorie, mais qu'en pratique c'est peut être pas idéal du tout. Il faudrait en parler avec l'auteur pour savoir quelles étaient les raisons de son choix.

    Imagine que j'ai un programme OCaml qui veut appeler une fonction Links (ou Eff ou Idris) ou l'inverse. Je peux vérifier que les types sont à peu près cohérents (les deux langages n'ont pas les mêmes types mais il y a sous-ensemble commun qui garantissent à peu près les mêmes comportements), compiler les deux vers Lambda et les lier ensemble.

    On ne peut pas le faire en utilisant un programme C intermédiaire ? Ça revient presque au même (parce que la glue et l'analyse de type tu la feras quand même). C'est plus complexe techniquement, certes.