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]

[...]
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 !!