Discussion :

[Garulfo]

Ok... vous allez peut-être me trouver niaiseux : depuis le temps que je fais du ocaml (en amateur certes, mais ça fait un bout de temps quand même) je n'avais jamais remarqué que ça n'existait pas.

Question numéro 1 : Existe-t-il des substituts ?

Juste au cas où :

• Apply : prend une fonction et une liste d'arguments et applique la fonction à la liste de ces arguments. Intuitivement on dirait que c'est ça
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  let rec apply f = function
      | [] -> f
      | h::t -> apply (f h) t

  mais sans même le tester, je sais que ça ne typecheckera pas puisque ça fait parti de ces fonctions qui ne peuvent pas typechecker . Je suppose que le préprocesseur permet (peut-être) de faire ça.
  
• Eval : prend une liste de symbole et l'évalue comme une expression... certes les symboles n'existent même pas dans ocaml... mais on pourrait se débrouiller avec un constructeur de symbole. Toujours est-il que je suppose qu'on pourrait se débrouiller avec le préprocesseur pour ça aussi non ?

Donc... ma question numéro 2 : où trouver un bon manuel du préprocesseur ? Parce que sans vouloir paraître médisant, certaines parties du manuel officiel sont à chier ou très mal faites (à mon goût certes).

N.B. je pense que c'est là que se trouve la force de PLT Scheme : les macros sont tellement simples à mettre en œuvre que s'en est hallucinant.

[LLB]

Normalement, tu devrais pouvoir te passer de ça dans la plupart des cas. Tu peux expliquer dans quel cas tu en aurais besoin ?


Un problème, c'est que le préprocesseur a été complètement réécrit pour la version 3.10, et je ne sais pas si les anciens tutoriels sont toujours utiles. Ces deux pages présentent un certain nombre de liens :
http://www.ocaml-tutorial.org/camlp4_3.10
http://en.wikipedia.org/wiki/Camlp4


Bien sûr, F# permet d'avoir apply (via introspection) et eval (via les quotations).

[gorgonite]

menhir : http://pauillac.inria.fr/~fpottier/menhir/manual.pdf

sinon je me demande si l'on ne pourrait pas jouer avec un module afin d'obtenir une fonction apply au moyen de types fantomes

un peu comme ici : http://till-varoquaux.blogspot.com/2...tom-types.html

[gasche]

gorgonite : il me semble qu'en toute généralité ce n'est clairement par possible puisque le langage des types, par construction, n'est pas Turing complet, et donc ne pourra jamais évaluer autant d'expressions que OCaml.

Si vous voulez jouer avec plusieurs niveaux d'évaluation, il faut essayer l'extension multi-stage d'OCaml, MetaOCaml . Ça a l'air très intéressant et rigolo, mais je n'ai jamais essayé.

Garulfo : si tu veux utiliser apply, c'est à priori un problème de conception. Par ailleurs, en vérité il n'existe pas de bonne documentation de Camlp4 >= 3.10. L'endroit le plus complet est sans doute la wiki Gallium, et sinon il faut lire du code, que ce soit du code d'extensions (le mieux pour voir comment faire, si ça t'intéresse les miennes sont principalement ici) ou de Camlp4 lui-même (en particulier le fichier Calmp4Parsers/Camlp4OCamlRevisedParser.ml est intéressant).
Tu peux aussi générer toi-même de la documentation sur les signatures des modules Camlp4, mais c'est inutile puisque je l'ai mise sur le net.

Par contre, je te conseille de te familiariser avec le langage avant de te mettre à tripoter la syntaxe. Ce n'est pas pour médire, mais j'ai l'impression qu'actuellement tu es beaucoup trop "déformé" par le lisp/scheme : essayer de se rapprocher de ce qu'on connaît par des manipulations syntaxiques compliquées au lieu d'apprendre la manière "ocamlienne" de faire, ce n'est sans doute pas la bonne solution.

[SpiceGuid]

+1
Il ne faut surtout pas chercher de mauvais substituts qui pourraient faire illusion un moment.

Visiblement tu as de bonnes raisons de penser que apply-eval-call/cc te sont indispensables.
Si tu pouvais l'expliquer en 4 ou 5 lignes maximum qui s'adressent à un public 'débutant', ce serait bien pour la FAQ

[gasche]

Par ailleurs, il existe des implémentations de call/cc (ou de call/cc delimités ou quoi, j'y connais rien à ces machins là) en OCaml, et sinon on peut faire des continuations à la main et/ou avec une monade.

[Garulfo]

Merci à tous.

J'ai besoin d'un eval car le but est d'utiliser dans une spécification des prédicats dont on ne connaît pas au moment de compiler l'interpréteur leur arité. Certes, j'ai pensé à ça par mon habitude de Scheme... et là je cherche un moyen de faire autrement puisque je suis sous OCaml. Quelque soit le langage, j'ai toujours le même problème. En Java, j'étais passé par la compilation d'un morceau de code et son intégration. Il n'y a pas d'erreur de conception en soi. En Scheme il est plaisant de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
(define (append-map f L) (apply append (map f L)))

Pas que ce ne soit pas faisable en ocaml ^_^.

Pour ici, il faut que je me trouve une alternative, plus longue plus complexe. En Scheme, j'aurais créé mon expression et injecté mon morceau de code dans le système. Ici il faudrait recompiler à chaque fois ou... ou je sais pas. On ne sait pas à la compilation quels seront les fonctions utilisées et leurs définitions. Alors soit je me crée en plus un interpréteur de prédicat, soit je demandais à l'utilisateur de me l'écrire en OCaml et j'injectais le code en cours de route — ce qui pose des problèmes de typages et qui forcément doit être vu autrement. Et j'avoue que ça me fait chier de faire un évaluateur ocaml. Recompiler est un peu idiot, car on perd le bénéfice de faire un interpréteur

En Scheme, avec le nom name et une liste args d'argument (généré, donc de bonne taille) je ferais qqchose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
(load "function-def.txt") ;; contient les définitions

(define (compute-function n L)
  (eval `(,(string->symbol n) ,@L))
)

(compute-function name args)

et le tour est joué.

Est-ce que ce que je vous dis vous parle ? Comprenez-vous ou suis-je nébuleux? Je travaille sur ce genre de chose depuis 8 ans maintenant, et je pourrais être un peu trop dans mon monde.

Voyez-vous des moyens autres ?

Pour l'instant on recompile... le minimum... mais on recompile.

SpiceGuid: pour la FAQ j'y pense... c'est juste que là j'ai un projet qui ne peut pas attendre.

bluestorm: en quoi le call/cc m'aiderait? je pense bien savoir l'utiliser, mais je ne vois pas le rapport.

[Garulfo]

[...]
Bien sûr, F# permet d'avoir apply (via introspection) et eval (via les quotations).

Comment t'essayes de m'acheter :O !!
Ça va finir par marcher -_-

[Garulfo]

Si certains s'intéressent aux méthodes formelles et aux algèbres de processus, je pourrais leur montrer un peu plus ce que je fais. Mais l'interpréteur que je prépare change pour l'instant beaucoup puisqu'il en est dans ces prémisses.

[gorgonite]

sinon je me demande si l'on ne pourrait pas jouer avec un module afin d'obtenir une fonction apply au moyen de types fantomes
un peu comme ici : http://till-varoquaux.blogspot.com/2...tom-types.html

echec cuisant

en revanche, on peut faire ainsi... ça compile, mais je n'ose pas exécuter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
let rec apply (f:'a->'b) (g:'a list) = 
  match g with
    |[] -> f
    |h::t ->
      let tmp : 'a->'b = Obj.magic (f h) in
      apply tmp t
;;
 
let add x y =  x + y ;;
 
let tmp : int = Obj.magic (apply add [1;2]) ;;
 
let _ = Printf.printf "%d\n" tmp ;;
 
let apply_map f l = apply (^) (List.map f l) ;;
 
let tmp : string = Obj.magic (apply_map string_of_int [4;2]) ;;
 
print_string tmp

ça ne plante pas à l'exécution... mais ça doit tenir du miracle

Si certains s'intéressent aux méthodes formelles et aux algèbres de processus, je pourrais leur montrer un peu plus ce que je fais. Mais l'interpréteur que je prépare change pour l'instant beaucoup puisqu'il en est dans ces prémisses.

bien sûr que ça nous intéresse

[alex_pi]

en revanche, on peut faire ainsi...

AAAAAAAAAAAAAAAAHHHHHHH, espèce de gros cochon va !!

[gorgonite]

AAAAAAAAAAAAAAAAHHHHHHH, espèce de gros cochon va !!

ben j'ai jamais dit que c'était propre... je voulais juste réussir à le faire malgré tout

[gasche]

J'ai besoin d'un eval car le but est d'utiliser dans une spécification des prédicats dont on ne connaît pas au moment de compiler l'interpréteur leur arité. Certes, j'ai pensé à ça par mon habitude de Scheme... et là je cherche un moyen de faire autrement puisque je suis sous OCaml.

Je vois deux possibilités.

Soit tu n'as pas besoin que les prédicats soient "codés en OCaml", c'est à dire que tu n'utilises pas toute la puissance du langage mais seulement un sous-ensemble (par exemple tes prédicats peuvent être inductivement définis). Dans ce cas tu peux les "réifier" en les représentants par des structures de données au lieu d'une fonction : tu peux alors construire tes prédicats, les manipuler et ensuite les évaluer. Si les prédicats te le permettent c'est à priori une bonne solution, parce que la structure exposée par la réification correspondra probablement mieux à ton problème que "les fonctions ocaml" en général, et tu auras sans doute accès par la suite à des manipulations plus puissantes.

Si tu as vraiment besoin de la puissance de tout le langage, tu dois pouvoir passer par des wrappers : en annotant tes fonctions pour préciser leur arité, on doit pouvoir les transformer (avec peut-être un zeste de magie, mais rien de plus fondamentalement dangereux que tes manipulations non-typées en scheme) en quelque chose de plus flexible. Le mieux serait évidemment de trouver une solution pour préserver les informations de typage. C'est peut-être possible (et je pense que c'est généralement possible) mais là ça dépend trop de la situation concrète, on n'a pas assez d'informations pour le dire.

(Pour le call/cc, ça n'a aucun rapport, je répondais juste à SpiceGuid)

[InOCamlWeTrust]

Dans ce cas tu peux les "réifier" en les représentants par des structures de données au lieu d'une fonction : tu peux alors construire tes prédicats, les manipuler et ensuite les évaluer.

Moi je dis +1 aussi. C'est aussi ce que l'on fait dans les vrais compilos : on réifie tout et n'importe quoi.

[SpiceGuid]

À mon avis il voudrait pouvoir réifer la totalité du langage.
Dans ce cas inutile de lui faire perdre son temps, Scheme est fait pour ça.

[gasche]

Petit détail pour faire chier : il ne pourrait pas réifier la "totalité" du langage, parce qu'alors il aurait (en ayant en pratique codé un interpréteur OCaml à l'intérieur de son programme) reproduit le système de typage, et obtiendrait donc des fonctions typées, encore une fois non appelables génériquement (il aurait juste retrouvé le problème initial, au dessus d'un interpréteur). Sa question suppose à priori que le langage réifié, quelle que soit son expressivité, soit non typé : il ne devra jamais réifier tout OCaml, par contre il est possible que cela le conduise à réifier un Scheme au dessus de son programme caml

Je pense cependant qu'il est peu probable que son langage à réifier soit si complexe (... ou alors il faudra m'expliquer pourquoi les prédicats des méthodes formelles et algèbres de processus ont besoin d'une gestion des chaînes de caractères).
De plus, comme gorgonite l'a acrobatiquement illustré, il est possible au besoin de ne pas passer par la réification, en "tuant" le système de typage OCaml localement (ce qui est, du point de vue d'un camlien, mieux que l'usage partout d'un langage non typé comme Scheme).
Enfin, je pense qu'il est possible de faire ce qu'il veut ("pouvoir charger et manipuler des prédicats depuis des fichiers externes") en conservant le typage, mais c'est peut-être plus subtil à concevoir (et peut-être impossible) et en tout cas on n'a pas assez d'informations pour le savoir actuellement.

[Garulfo]

[...]Dans ce cas tu peux les "réifier" en les représentants par des structures de données au lieu d'une fonction [...]

Moi je dis +1 aussi. C'est aussi ce que l'on fait dans les vrais compilos : on réifie tout et n'importe quoi.

À mon avis il voudrait pouvoir réifer la totalité du langage.
Dans ce cas inutile de lui faire perdre son temps, Scheme est fait pour ça.

[...] il ne devra jamais réifier tout OCaml, par contre il est possible que cela le conduise à réifier un Scheme au dessus de son programme caml

Vous avez compris que je ne voulais justement pas me taper un interpréteur a priori ? Bon je vois que je n'aurais peut-être pas trop le choix d'en faire un mini. Mais ça me tente pas trop. Pour l'instant je garde ma solution:
fonctions offertes — de type int list -> bool — dans une hashtbl ; nécessité de recompiler si on en ajoute. Peut-être est-ce que pour l'objectif actuel cela suffira.

Je pense cependant qu'il est peu probable que son langage à réifier soit si complexe (... ou alors il faudra m'expliquer pourquoi les prédicats des méthodes formelles et algèbres de processus ont besoin d'une gestion des chaînes de caractères).[...]

Tu as raison... et tort. Tu as raison si ce que je voulais faire de ma spéc c'était l'utiliser pour faire de la vérification de modèle par exemple... ou spécifier un morceau de comportement. Dans le cadre actuel de ce que je fais depuis deux semaines, je ne fais qu'un framework pour tester les algos sur le système réel (qui actuellement est en Java... mais qui sait).

Cependant ce n'est pas l'objectif de nos spécs. L'objectif ultime est d'en faire des programmes automatiquement générés. Dans ce cadre, il faut pouvoir manipuler les chaînes de caractères, les listes d'élements, les graphes, les ... etc.

Plus d'info dans ces docs: Projet APIS – AAAI Projet APIS – RCSI

[Garulfo]

En tout cas... je pense que vous avez répondu à mes questions.

Pour l'instant je garde mon approche et, comme je le disais, il est possible qu'elle suffisse pendant un bout. Si on veut aller plus loin, je pense qu'il n'y aura pas d'autre choix que de passer par une interprétation complète de toute façon, puisqu'il y a un « langage » développé pour les fonctions.

Une partie de travail a déjà été faite dans une maîtrise.

J'espérais simplement pouvoir simplement injecter du code comme ça se fait si aisément avec un évaluateur métacirculaire. Le typage m'a tué !

Problème résolu en tout cas, j'ai toute les infos nécessaires.

[alex_pi]

On dit "le typage m'a tuer" :-D

[Garulfo]

On dit "le typage m'a tuer" :-D

Oui j'y ai pensé. -_- Mais je n'arrive plus à faire des fautes volontaires sans sentir mon cœur se déchirer depuis que je suis sur les jurys.