? Que faire avec CamL ? - Page 1

J'ai DL CamL light et j'ai essayé de faire deux trois trucs que j'ai appris à la fac :

let x=5;;
if x=5 then x=2 else x=1;;

quit;;

T'as appris à faire ça à la fac ? change de fac.
hum sinon quelle est ta question ?
1/ quit n'existe pas. C'est exit (0) (ou pas de 0 mais ça correspond à une erreur en principe).
2/ Tu es sûr que tu veux utiliser caml light et pas ocaml ? caml light est vieux, obsolète et lent. (et buggé je crois bien).
3/ = est une comparaison, pas une affectation.
4/ si tu fais let x = 5, tu déclares une constante. Pour faire une variable, c'est let x = ref 5, tu accèdes ensuite au contenu de la variable par !x et tu peux lui affecter une valeur avec :=
tu dois pouvoir trouver des tutos de caml via leur site http://caml.inria.fr si tu veux (probablement même qu'il y en a en français). Même sans faire de tuto, tu devrais au moins lire l'introduction du manuel, qui te décrit la syntaxe du langage... c'est utile de connaître la syntaxe, mine de rien.

Sally
: 3/ = est une comparaison, pas une affectation.

Le let obligatoire, c'est comme dans les très vieilles versions de BASIC obsolètes depuis au moins 10 ans.

4/ si tu fais let x = 5, tu déclares une constante. Pour faire une variable, c'est let x = ref 5,

tu accèdes ensuite au contenu de la variable par !x

Et avec ça, telchar veut encore me faire croire qu'il n'y a pas de symboles contre-intuitifs en Caml?

et tu peux lui affecter une valeur avec :=

En d'autres mots, il faut utiliser un autre opérateur pour les assignements (:=) que pour l'initialisation (let ... =).

1>Bah, ué, c'est comme ça qu'ils voient le caml... Si ce que j'apprends est totalement faux, alors là je mepose des questions...

1, 3,4/ J'ai essayé de taper les trois sus-cités avec un test de concaténation de chaîne et il se trouve que ça a marché
2/ A la fac ils ont camL Light. On travaillera uniquement en mode interactif ce qui est une erreur pour moi, j'aurais aimé travailler en classique (compile et exécute).

Ma question c'est qu'est-ce qu'on peut faire comme prog abouti avec ce "langage" ?

Remarque ça dépend ce que tu veux faire après tout, ton code n'est pas faux (à part que quit n'existe pas)
en fait "if x = 5 then x = 2 else x = 1" est une expression valide de type booléen, qui est exactement équivalente à "x = 1" (donc en l'occurence ça vaut false).

Ce que ça dit précisément, c'est : si x vaut 5, alors renvoie-moi le booléen "x = 2", sinon renvoie-moi le booléen "x = 1".

Mais si c'est bien une affectation que tu voulais faire, alors il faut utiliser une référence et :=

Bah en fait, j'ai tapé ces lignes au feeling juste pour me familiariser avec ce que je vais utiliser à la fac... Pour l'instant, c'est _un poil_ limité ce que je fais. Peut-être qu'avec le temps (Si j'ai le temps ), ça viendra...

Sally> "quit" existe (au moins en Caml Light), mais pour l'appeler, c'est "quit()"

Kevin > dans les déclarations '=' n'est pas un opérateur, ça fait juste partie de la syntaxe de la déclaration.
let xxx = yyy
type xxx = yyy
class xxx = yyy
etc.
C'est très différent de l'affectation d'une valeur à une référence (où := est vraiment un opérateur). D'ailleurs x := 1 est une expression alors que let x = 1 n'en est pas une (c'est une déclaration).

naPO > 1/ peut-être que quit existe en caml light alors.

Sinon, pour tenter rapidement de répondre à ta question :
http://freshmeat.net/browse/983/
http://caml.inria.fr/users_programs-eng.html
(je sais pas dans quelle mesure c'est à jour, et c'est sûrement pas complet, mais bon...)

Sinon ce qui existe (même en ocaml), c'est '#quit', mais ce n'est pas du caml, c'est une directive de l'interpréteur interactif (comme #load).

Merci du conseil, je verrai ça ^^

Si j'ai écrit "quit", c'est parce que quand je ferme via la croix en haut à droite, caml écrit automatiquement quit();;...

Sinon, encore merci du conseil

Sally> non, quit() existe bien en Caml Light...

Je ne le nie pas

Sally
: naPO > 1/ peut-être que quit existe en caml light alors.

Le let obligatoire, c'est comme dans les très vieilles versions de BASIC obsolètes depuis au moins 10 ans.

Etant donné que ce n'est pas le même usage, je ne vois pas très bien l'intérêt de ta remarque....

S'il fallait bannir des langages modernes tous les mots utilisés dans les langages dépassés, je ne vois pas bien ce qui resterait...

Et avec ça, telchar veut encore me faire croire qu'il n'y a pas de symboles contre-intuitifs en Caml?

Où vois tu donc un symbole contre intuitif ?
C'est tout à fait semblable au * des pointeurs en C, et je suppose que tu trouves ce symbole merveilleusement naturel...

En d'autres mots, il faut utiliser un autre opérateur pour les assignements (:=) que pour l'initialisation (let ... =).

Dans la structure "let pattern = valeur", le "=" n'est pas un opérateur mais un simple mot de la syntaxe. (Mais Sally l'a déjà expliqué)

:=, par contre, est une fonction infixée du type 'a ref -> 'a -> unit

Oui, je n'avais pas le temps de m'attarder sur tes trolls tout à l'heure, mais si utiliser '!' pour le déréférencement n'est certes pas particulièrement intuitif, je ne vois vraiment pas en quoi c'est *contre*-intuitif... c'est un symbole arbitraire, voilà tout... j'ajouterai que l'avantage qu'il a sur '*' est de ne rien signifier d'autre . C'est important puisqu'en caml, plutôt que de déduire des types des opérandes la nature de l'opérateur, le compilateur déduit de l'opérateur employé les types des opérandes, ce qui permet entre autres d'intercepter beaucoup plus d'erreurs bêtes et de les signaler avec des messages d'erreur bien plus clairs. Aucun opérateur n'a plusieurs significations.

le caml c du caca

mézankor?

or ce que dit montreuillois c'est du caca, donc montreuillois finira par se calmer

let slap = ref fun x -> x in
!slap "vince";;
• Hippopotame slaps "vince";; around a bit with a large trout !

- : string = "vince"

Et ça?

let a x y = y x in
let b x y = x y a in
let c x y = x b y in
let d x y = x y c in
let e x y = x d y in
let f x y = x y e in
f;;

Aucun opérateur n'a plusieurs significations.

prefix <;;
- : 'a -> 'a -> bool = <fun>
Ca n'a qu'une seule signification

En effet, ça n'a qu'une signification!

Hippohmu
: C'est tout à fait semblable au * des pointeurs en C, et je suppose que tu trouves ce symbole merveilleusement naturel...

Je n'ai pas besoin de déréférencer un pointeur pour accéder à une variable (non-constante) en C!

En Caml non plus.

Hippohmu :
Et ça?

let a x y = y x in
let b x y = x y a in
let c x y = x b y in
let d x y = x y c in
let e x y = x d y in
let f x y = x y e in f;;

- : ('a -> (((('e -> (((('i -> ('k -> ('k -> 'l) -> 'l) -> 'j) -> 'i -> 'j) -> 'g -> 'h) -> 'g -> 'h) -> 'f) -> 'e -> 'f) -> 'c -> 'd) -> 'c -> 'd) -> 'b) -> 'a -> 'b = <fun>

Kevin > je ne vois pas le rapport avec ta remarque précédente, mais c'est effectivement une des innombrables différences entre le caml et le C : si tu veux pouvoir modifier une variable, il faut utiliser une référence ou un champ mutable d'une structure.

"Tout est référence." == "Tout est lent."

Dans un langage fonctionnel pur, il n'y a aucun effet de bord. En particulier, on ne peut pas affecter une valeur à une variable après sa déclaration (et donc il n'y a pas de variables, seulement des constantes).

Caml est un langage fonctionnel impur : pour des raisons de commodité, on autorise certains effets de bord. Toutefois, les variables restent toutes constantes, et ne peuvent pas être réaffectées. Si on veut une variable qui puisse "varier", ce doit être une référence (c'est à dire grosso modo un pointeur : le pointeur est constant, mais la valeur qu'il pointe ne l'est pas), ou bien un champ mutable.

Bien sûr, Kevin, qui est hermétique à tout style de programmation qui s'écarte du pur impératif, va trouver ça dément.

Mais non Kevin, 1/ les benchs montrent que tout n'est pas lent, même si évidemment c'est *légèrement* plus lent que du C et aussi plus lent que de l'asm, c'ets plus rapide que pratiquement tout le reste, et 2/ tout n'est pas référence, tu ne t'en rends peut-être pas compte à cause de tes habitudes de programmeur C mais on n'a pas si souvent que ça besoin de variables modifiables ! (et les boucles for sont une construction particulière qui n'utilise pas de références). Et puis en C aussi, tout ce qui n'est pas numérique est référence (ce n'est pas *obligatoire* mais bon en gros c'est ça).

25>

1) Pourquoi tout serait référence? On en a besoin d'assez peu, sur la totalité des variables.

2) Non, ça n'est pas lent.






J'oubliais aussi que les structures comme for ... = ... to ... do ... done s'autorisent à modifier une variable.

Une petite remarque en passant : il existe une construction syntaxique spéciale pour la boucle for car elle est souvent utilisée, mais il est intéressant de voir que

for i = 0 to n do <expr> done

est parfaitement équivalent à

let rec boucle i = (if i <= n then <expr>; boucle i + 1) in boucle 0

et que cette deuxième version n'utilise pas davantage de référence

D'ailleurs imaginons que Kevin râle en disant que quand même, en C, on a un truc plus souple avec la syntaxe for (initialisation; condition; incrémentation) (syntaxe àmha débile en ce qu'elle permet les pires abus, mais là n'est pas la question). Eh bien en caml on peut faire ceci (tiens je vais mettre des arguments optionnels tant qu'à faire, hystoire de se rapprocher vraiment du for du C... bon c'est carrément un gadget inutile en l'occurrence mais c'est pas grave ) (attention les args optionnels n'existent pas en caml-light ^^) :

let boucleforalaC ~init ?(cond = function _ -> true) ?(incr = function x -> x) body =
  let rec do_boucle i = (if cond i then body i; do_boucle (incr i)) in do_boucle init

et je précise que la variable de boucle i peut être *n'importe quoi*, si on veut ça peut être un triplet d'un nombre, un booléen et une liste par exemple
Vous voyez bien que la conclusion s'impose : caml powa.

Ah oui, et je re-fais remarquer que je n'ai pas utilisé une seule référence dans ma fonction ²