? Que faire avec CamL ? - Page 2

C géré comment les arguments optionnels en OCaml ?

Et sinon un des trucs les plus chiants du Caml Light c les structures qui sont hyper mal foutues (les namespaces des différentes structures passent leur temps à se battre), je ne sais pas si c résolu en OCaml...

ben là par exemple si je veux invoquer ma fonction je peux faire :

let incr i = i + 1 and cond i = i < 144 in
boucleforalaC ~incr ~cond ~init:0 (function i -> print_endline "Hello World !")

c'est à dire que tu utilises les arguments "labellisés" dans n'importe quel ordre, soit avec ~label:valeur, soit directement avec ~label si l'identifiant 'label' est défini. Si tu ne spécifies pas un des arguments, il est remplacé par la valeur par défaut que j'ai mise à la déclaration de la fonction dès que l'application est complète. Comme il faut que caml sache quand l'application est complète, il est obligatoire que la fonction prenne un dernier argument non labellisé, ici body. Cet argument est souvent tout simplement ().
Si tu ne spécifies *pas* de valeur par défaut, la variable prend alors dans le corps de la fonction un type 'a option avec la valeur par défaut None.
Enfin, si tu écris une fonction qui prend un paramètre optionnel et que tu veux le repasser tel quel à une autre fonction, tu remets le point d'interrogation, par exemple :
let g ?(param = 0) x = x + param
let f ?par () = g ?param 42

#f ();;
- : int = 42
#f ~param:17 ();;
- : int = 59

Voilà en gros (euh, même en détail d'ailleurs ).
Pour les structures, c'est pareil en ocaml (deux types structures différents ne peuvent pas avoir des membres de même nom, sauf s'ils ne sont pas dans le même module), mais par contre les objets n'ont pas cette contrainte.

Je peux pas vérifier là mais

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

il va croire que tu fais (boucle i) + 1 donc il va sûrement dire que boucle renvoie un entier. Enfin dans le doute j'aurais mis boucle (i + 1).

Moui et tu aurais eu raison ^^
sinon effectivement il va pas être très content

Caml pawaaa
Ca fait longtemps que j'en ai pas fait...

Sally> c'est un peu gore les arguments par défaut, apparemment... il faut dire que la curryfication ne s'y porte vraiment pas bien.

[nosmile]C'est lourd à déclarer, par contre c'est pratique à utiliser après.
Dans lablgtk c'est carrément indispensable vue la tronche des fonctions gtk à 650 arguments, mais si tu regardes comment c'est implémenté il a utilisé des wrappers dans tous les sens. Par exemple voici ce que contient gaux.ml :

(* $Id: gaux.ml,v 1.1 2000/05/26 03:53:20 garrigue Exp $ *)

(* Option handling *)

let may ~f x =
  match x with None -> ()
  | Some x -> let _ = f x in ()

let may_map ~f x =
  match x with None -> None
  | Some x -> Some (f x)

let default x ~opt =
  match opt with None -> x | Some y -> y

let may_default f x ~opt =
  match opt with None -> f x | Some y -> y

Après dans property t'as ça :

  let may_cons prop x l =
    match x with Some x -> param prop x :: l | None -> l
  let may_cons_opt prop x l =
    match x with Some _ -> param prop x :: l | None -> l

etc., et au bout du compte dans gButton t'as ça :

let button ?label =
  Button.make_params [] ?label ~cont:(
  pack_return (fun p -> new button (Button.create p)))

ce qui te donne la fonction destinée à l'utilisateur de la bibliothèque, dont voici le type :

val button :
  ?label:string ->
  ?use_mnemonic:bool ->
  ?stock:GtkStock.id ->
  ?relief:Tags.relief_style ->
  ?packing:(widget -> unit) -> ?show:bool -> unit -> button

et dont en gros les seuls paramètres que tu vas utiliser couramment sont label et packing, éventuellement show.
Donc c'est lourd à mettre en place mais c'est pratique quand c'est fait ; autrement dit, c'est bien surtout quand tu écris une grosse bibliothèque compliquée.

Sally ./25 > De tête ?

Vi ^^ (en fait ça se voit parce que caml nomme les variables de type dans l'ordre où elles apparaissent, mais pas moi)

Excusez le remontage sauvage mais voilà, j'ai appris deux trois trucs, genre le filtrage...

Mais là je bloque : on écrit à la fac une heure hms dans le format hmmss. Ainsi 24556 signifie 2 heures 45 minutes 56 secondes. Est-ce que ma fonction qui convertit les notations hms en notation en secondes va bien, quoiqu'un peu capillo-tractée ?

let hms_to_s = fun hms -> (hms/10000)*3600+(hms mod 60)+(((hms-((hms/10000)*10000))/100)*60;;

hms_to_s 24556;;
- : int = 9700 et des poussières

ben a priori ça marche mais j'aurais plutôt fait :
let hms_to_s hms = hms / 10000 * 3600 + hms mod 10000 / 100 * 60 + hms mod 100
je ne comprends pas pourquoi tu te compliques la vie sur ton dernier terme...

A priori j'aurais plutôt pris en argument un triplet...

c'est plus logique, évidemment, mais il faut voir d'où il le sort son argument...

L'argument ? Bah... Euh... C'est eux qui nous imposent un format d'heure à la noeud...

Excusez le remontage sauvage, mais voilà deux tps de caml que j'ai faits :

http://gilou82.free.fr/Vrac/Nullissime.txt


http://gilou82.free.fr/Vrac/nul2.txt
Voilà.

oué...

Et ? tu veux des commentaires ?
bon j'ai vaguement regardé et j'en ai un comme ça : tu devrais curryfier tes fonctions à plusieurs arguments (ie let memes_parents = fun a b -> et non let memes_parents = fun (a, b) ->)

Des commentaires ? Heu ben oui... J'ai oublié de préciser

Mais je savais pas que ça marchait "fun a b"... Disons qu'on nous demande de manier obligatoirement des paires Faudrait que je retrouve les énoncés de mes tp