(* Le type des dominos. *)
type domino = int * int ;;

(* Le nombre de dominos d'un jeu. *)
let nb_doms = 28 ;;

(* Retourne un tableau contenant tous les dominos du jeu. *)
let create_doms () =
  let t = Array.make 28 (0, 0) and n = ref 1 in
    for i = 1 to 6 do
      for j = 0 to i do
	t.(!n) <- (j, i) ; incr n
      done
    done ;
    t ;;

(* Un tableau de tous les dominos d'un jeu. *)
let les_dominos = create_doms () ;;

(* Le type d'une pioche. *)
type pioche = {doms : domino array ; mutable nb : int} ;;

(* La pioche dans l'état initial. *)
let la_pioche = {doms = les_dominos ; nb = nb_doms} ;;

(* (est_vide p) retourne true SSI p est la pioche vide. *)
let est_vide p = p.nb = 0 ;;

est_vide la_pioche ;;

(* (pioche p) retourne un domino tiré au hazard de la pioche p
   et le mémorise comme tiré dans p ou lève Failure "pioche" si la pioche
   est vide. *)
let pioche p =
  if p.nb = 0 then failwith "pioche"
  else (
    let n = Random.int p.nb in
    let aux = p.doms.(n) in
      p.nb <- pred p.nb ;
      p.doms.(n) <- p.doms.(p.nb) ;
      p.doms.(p.nb) <- aux ;
      aux
  ) ;;

pioche la_pioche ;;
la_pioche ;;

(* (melange p) réinitialise la pioche p : aucun domino n'est tiré. *)
let melange p = p.nb <- nb_doms ;;

melange la_pioche ;;
la_pioche ;;

(* Une liste de tirages, ordre inverse. *)
let ld =
  let rl = ref [] in
    while not (est_vide la_pioche) do
      rl := pioche la_pioche :: !rl
    done ;
    !rl ;;

la_pioche ;;
melange la_pioche ;;
la_pioche ;;

(* Une liste de tirages, ordre direct. *)
let ld1 =
  let rec aux () =
    if est_vide la_pioche then []
      (* else pioche la_pioche :: aux ()   Stack overflow ! *)
    else let d = pioche la_pioche in d :: aux ()
  in aux () ;;

la_pioche ;;
melange la_pioche ;;
la_pioche ;;