Re: Méconnaissance

[^] # Re: Méconnaissance

Posté par Aluminium95 le 24 novembre 2015 à 10:47. En réponse au journal Compilateur et Monad Reader. Évalué à 1.
Je pense que le moinssage vient du fait que la notation infixe ne change pas « le problème » que j'ai soulevé (enfin, c'est un problème pour moi), qui est ici le fait de devoir construire des « lambda » à chaque appel de bind (ou >>=).

D'ailleurs, même en haskell, pour une longue composition de fonctions, où tous les résultats intermédiaires sont utilisés dans le dernier bloc, c'est vraiment plus pratique d'avoir une syntaxe plus « impérative », plutôt que a >>= (\x -> b >>= (\y -> c >>= (\z -> ...))). Enfin, c'est une question de goûts, mais la notation infixe n'est pas une réponse à ce problème.

Après, oui (comme je l'ai déjà dit dans un autre commentaire), si on fait des fonctions séparées, bien compartimentées, on a pas besoin de créer des lambdas (en fait, ce sont des fonctions normales), et c'est ce que tu proposes : « Autant dire : je compose les opérateurs ». Sauf que parfois, on construit beaucoup d'opérateurs différents ... et c'est là que la notation est pratique.

Enfin, dernier argument pour dire que « la notation infixe ne change pas ce problème » (je note quand même que j'ai précisé dans le journal que, comme toujours, j'ai pris pour seul exemple un qui pouvait se simplifier de manière triviale, et pourtant c'est 2ème commentaire à le reprendre et le simplifier ...) :
```
let ( >>= ) = bind;;
let push_var_on_stack s = get_var_addr s >>= pushq;;
(* 
 * sans la notation infixe on perd ~ 4 caractères à la louche,
 * quelle victoire !
 *)
let push_var_on_stack s = bind (get_var_addr s) pushq;;
```
Une petite remarque, comme dans 99% du temps, les fonctions retournaient un unit (et écrivaient dans la sortie le code correspondant), on peut avoir une syntaxe dans le genre : List.fold (>>) (return ()) [ a ; b ; c ; d ; e ; f], qui peut se transformer en un opérateur asm_code_block [ a ; b ; c ; d ... ], qui avec une bonne indentation permet de retrouver la « forme » du code assembleur (et une notation pseudo impérative de caml) et qui est « facilement compréhensible¹ » :
```
asm_code_block [
 popq "%rdi";
 movq "1ドル" "%rsi";
 call "printf";
 ...
] ctx
```
Donc le problème n'est pas « je ne sais pas définir un opérateur infixe en OCaml ».

PS: un autre problème est que l'évaluation n'est pas paresseuse, et donc il faudrait utiliser le module Lazy, en ajoutant une syntaxe encore plus lourde^2, parce que return (Printf.fprintf out "coucou") est différent de (fun _ -> Printf.fprintf out "coucou"), l'un écrit « coucou » à la construction, l'autre à l'exécution du « reader ».

@kantien : pourquoi pas, je ne suis jamais allé dans un meetup jusqu'à présent.

[1] : parce que cela « ressemble » à une sémantique dénotationnelle, du type [code]{contexte} = valeur,nouveau contexte
[2] : ou en utilisant des extensions de syntaxe pour que return x === return' (lazy x). Mais je viens de voir qu'un commentaire de Michaël en parlait, du coup je ne suis pas catégorique sur ce point.

[^] # Re: Méconnaissance