Reprise du message précédent :
Un 2ème chrisbk

ptain mais nan, tu vois bien qu'il aime le C

n'ai pas peur, j'aime bcp le C, il n'y a qu'un chrisbk. Mais je suis d'accord sur le fait que qsort soit pas top-top en C. Enfin il ont été sympa de le mettre parce qu'il me semble que c'est le seul algo générque en C ANSI.

up

Mais non, pas up.

Viens pas polluer  

Je viens pas polluer, je te demande de ne pas upper ce topic pour rien. Il n'a pas plus de raison d'être en première page qu'un autre.

Si on en croit les benchs, il est méchamment optimisé le compilo Digital Mars.  

Qui se craque pour le tester et dire aux autres si ils devraient passer au D ?

Les jeux de shoot ci-dessous sont écrits en D avec la SDL.
http://www.asahi-net.or.jp/~cs8k-cyu/index_e.html
 
J'ai essayé Torus Trooper, c'est pas mal (touches flèches et W ou X pour tirer et commencer la partie) et gunroar. De bons shooter. Le source (absolument pas commenté, comme il se doit) est inclus dans le download.
 
Y'a pas à dire, ça a l'air d'être du sérieux, ce langage.  

Oui, je connais Torus Trooper et Tumiki Fighter (TF est 'achement bien, extrèmement original)

ca fait 2 ans que je vous dit que le D ca tape

par contre l'api est toujours aussi mauvaise

Es ce que quelqu'un peu me donner des conseils:
 
Je suis sous netBSD et je voudrai coder en camel avec un sub shell. Pour voir mes elaluations dans un shell et non pas a la suite du code.
Je sais que emacs peu le faire avec un certain mod tuareg... mais je n'arrive pas a l'utiliser....... quelqu'un sait-il comment? il y a peu etre une subtilite dans tuareg.....?

Bah pour tuareg tu met les fichiers *.el que tu as téléchargé dans un dossier (celui que tu veux ça doit pas poser de problème, dans /site-lisp/ par exemple).
 
Et puis dans ton .emacs tu met :

 
Si tu as mis les *.el dans un dossier bien à part il faudra surement l'ajouter au load-path.
 
Moi j'ai toutes mes extensions que j'ai ajouté (pas les c-mode et compagnie) sur windows dans C.emacs.d/ext/ et sous linux dans /home/user-login-name/.emacs.d/ext/ :

 
Après si tout se passe bien quand tu ouvre un fichier *.ml alors dans les menu du haut tu devrais en avoir un nommé Tuareg, et si tu fait C-c C-b puis Return, ça devrait évaluer le buffer et te mettre le resultat dans un nouveau buffer en dessous.

Bonjour,
  Vouloir faire un tuto reste tout de même une bonne initiative, mais nécessite beaucoup de boulot. N'hésite pas à mettre des exemples pour vulgariser le texte et aider à la compréhension de ceux-ci. Mais bon, j'ai pas trop de conseils à donner, je ne suis pas expert.
  Par contre, j'ai trouvé ça : http://webperso.easyconnect.fr/goutelle/CAML.htm
 Peut-être cela t'intéressera ?
Courage.

dsl si le tuto avance lentement j'ai peu de temps a y consacrer je suis en prepa MP

c'est sympa les topics-bisounours .
 
C'est un langage marrant, qui commence à prendre un peu dans les usines. J'ai un pote qui fait du calcul formel (pour l'industrie) avec ça.
 
le caml a aussi des inconvénient non-négligeables : les types faibles (avec l'underscore) qui sont une chierie à expliquer aux débutants, une grammaire bloat à cause de la croissance des fonctionnalités au départ (notatoin objet, variants, paramètres optionnels etc.) avec P4 et grammaire révisée ça va mieux.  
 
Enfin il ne faut pas oublier que le but de caml n'est pas la perf (l'unique objectif est "jamais pire que 2 fois plus lent que le C), et qu'il a été décidé que certains efforts d'optimisation ne seront pas effectués.
 
Un autre inconvient, le lièvre a été levé récement, c'est que pour avoir de la perf, ben il faut utiliser un style d'écriture proche ... du C (très impératif).

et on apprend a faire que du recursif

alors que ça ne se justifie que dans 1/10ème des cas, puisque les vrais utilisent fold_left pour les pbs terminaux et les fold_right pour les problèmes non-terminaux, et ceux qui veulent de la perf et qui peuvent utilisent for.

je met un drapal vu que j'ai ce cours en licence info

Moi je suis en sup et j'aime bien ce langage aussi    bien qu'un e capricieux

quelqu'un aurait une sorte de tuto pour s'initier au typage? j'entends par la comprendre le typage de caml, comment il type les expréssions qu'on lui envoit

Moi j'utilise Objective Caml
 
Ben ouais, c'est quand même ce qui se fait de mieux dans le monde du langage de programmation !
 
Cependant, pour s'en rendre compte, forcément, c'est pas trop évident...
 

 
---
 

 
En gros : il prend un max d'informations à partir de l'analyse de ton programme. À partir de ces informations, il fait ce qu'on appelle de l'inférence de types...
 
 
Par exemple, il sait que tous les entiers s'écrivent comme ça :  
[0-9]+ | 0[xX][a-zA-Z0-9]+ | 0[o][0-7]+ | 0[bB][01]+  
 
Et quand il voit une expression comme ça par exemple :
let f a = 1 + a ;;
Il voit que f est une fonction à 1 argument, donc de type " 'a -> 'b " au départ
Il voit que (+) est de type "int -> int -> int"
Il voit que 1 est de type "int"
Il voit que a est de type " 'a " d'après ce que j'ai dit 3 lignes plus haut
Il voit que a doit être de type int d'après le type de (+)
Il regarde si 'a et int sont compatible : oui ils sont compatibles
Donc le type de la fonction f devient int -> 'b
Il voit que (+) a ses 2 arguments qui sont du bon type. Il voit que quand il a ses 2 arguments, il retourne une valeur de type int.
Donc 1 + a est de type int, qui est le type du résultat.
Il regarde si 'b et int sont compatible : oui ils sont compatibles.
Donc le résultat de f appliqué à un argument de type int est de type int.
Donc f est de type int -> int
 
 
Bon voilà en gros comment il fait : c'est super con... Mais heureusement que c'est la machine qui le fait parce que ce genre de calculs est mal géré par le cerveau humain...    
 
 
 
Un exemple plus compliqué pour la route :
 
let rec iter f l = match l with
 | [] -> ()
 | hd::tl -> f hd ; iter f tl  
;;
 
 
iter est de type 'a
iter est une fonction et attend 2 arguments, donc il est de type ('b -> 'c -> 'd) qui vaut donc 'a (ils sont compatibles)
f est de type 'b
l est de type 'c
le corps de iter est de type 'c
on filtre l avec une liste vide : l est une liste : l est de type 'e list qui vaut donc 'c
cette branche du filtrage rend () qui est de type unit.
donc 'd vaut unit.
on filtre l avec une tete de liste et une queue de liste : l est une liste de type 'f list qui vaut donc 'e list qui lui-même vaut 'c
cette branche du filtrage rend une séquence :
 - on regarde le 1er élément de la séquence qui est f hd.
   f est donc une fonction qui attend un argument.
   f est donc de type 'g -> 'h qui vaut 'b
 - on regarde le 2nd élément de la séquence qui est iter f tl.
   iter attend 2 arguments et est donc de type 'i -> 'j -> 'k qui vaut donc 'b -> 'c -> 'd.
   f est donc de type 'j = 'c = 'g -> 'h
   tl est donc de type 'c = 'j = 'e list = 'f list  
 
(iter f tl) est de type unit tout comme l'autre branche, donc 'd = unit
 
bref... je vais pas faire le détail des unifications de types...
 
On arrive à la fin, on dit que iter est de type  
  ('a -> 'b) -> 'a list -> unit
 
List.iter est de type ('a -> unit) -> 'a list -> unit parce que on force son argument a avoir ce type là.
 
---
Pour savoir si 2 types sont unifiables, on regarde si l'un est un inclus dans l'autre.
 
'a contient 'b -> 'c
mais ne contient pas 'a -> 'a
'a contient tous les types de base (int, float, string, 'b array, 'b list,...) mais ne contient pas 'a list.
 
et caetera...  

fold_right peut s'avérer plus rapide qu'une boucle for dans la mesure ou empiler peut être plus performant que boucler...
 
de toutes façons, les appels terminaux quand ils sont bien détectés et optimisés sont transformés en "for"...  

 
effectivement cette partie n'a pas de rapport avec le mode tuareg
 
-----
 

c'est-à-dire qu'il t'évite d'écrire des conneries sans te prévenir    
 
tu n'auras jamais une erreur de type à l'exécution... ça protège de beaucoup d'erreurs
 
en C, si tu fais une erreur de type non détectée (la plupart ne sont pas détectées puisque la plupart du temps on utilise des casts...), ben tu te ramasses soit un segmentation fault, soit un comportement totalement incontrôlé...  

ok merçi

Bonjour!
 
En cour d'info on commence le caml! Mais vu que les prof sont pas au top je voudrai savoir où je pourrais trouver des tutos (en fraçais si c'est possible).
 
En même temps si vous avez des références de livre à acheter que vous trouvez bien pouvez vous me les indiquer?
 
Merci!

peut etre sur le site de l'inria ?
 
sinon aussi peut etre http://www.univ-valenciennes.fr/RO [...] /DA-OCAML/

Je voudrai  savoir comment on fait pour changer du int en string par exemple.  
Merci!

string_of_int ?
 

# string_of_int;;
- : int -> string = <fun>

Sa marche pas !!

J'ai rien dit c'est moi qui sé pas écrire

'ffectivement

Est-ce que quelqu'un peut m'expliquer quel est l'utilité du filtrage par cas en caml. Je comprend meme pas la définition

c'est un peu comme le switch-case du C, les même applications. ou quand tu aurais mis plein de if ... else if .... else if ... en C.
 
c'est très basique.
Comme on utilise beaucoup o'caml pour réécrire des graphes, on s'en sert souvent pour des structure du type "si j'ai un noeud de type machin, alors que créé un noeud de type bidule".

 
 
Le filtrage d'OCaml permet entre autres de déstructurer des données très facilement.
 
Deux exemples :
1. les arbres :
 

 
2. sur les listes :
 

 
etc...
 
Sur des structures de données arborescentes, OCaml est un langage dans lequel  il est très facile et très rapide de coder de quoi travailler dessus.
Si on prend un langage comme Java, il faut définir des hiérarchies de classes super complexes pour faire au final des choses pas si complexes.
Si on prend un langage comme C, on est poussé à utiliser du transtypage (cast) absolument pas sûr.
Si on prend un langage comme C++, on patiente longtemps à la compilation (ou bien on va dormir)...

Merci pour ces réponses
 
Autre question, comment on fait pour créer plusieurs fonctions avec une seule instructions. (un seul ;; je veux dire)
 

 
Le AND fonctionne pas visiblement, comment faire ?

let rec f1 = ...
and f2 = ...  
and f3 = ...
 
sans mettre de "in" comme tu le fais. Le "rec" permet de dire que les fonctions se connaissent.

Le "rec" c'est pas pour les fonctions récursives seulement ?