Probleme – Les exceptions ne servent pas qu'aux erreurs

1 et 2. Les deux versions, instrumentées par un compteur pour rendre les accès visibles.

let visitees = ref 0
let lire m i j = incr visitees; m.(i).(j)

(* cherche_complet m v : Some (i, j) tel que m.(i).(j) = v, ou None. *)
let cherche_complet m v =
  let trouve = ref None in
  for i = 0 to Array.length m - 1 do
    for j = 0 to Array.length m.(i) - 1 do
      if lire m i j = v then trouve := Some (i, j)
    done
  done;
  !trouve

exception Trouve of int * int

(* cherche_exception m v : Some (i, j) pour la PREMIERE occurrence de v
   dans l'ordre lexicographique des indices, ou None. *)
let cherche_exception m v =
  try
    for i = 0 to Array.length m - 1 do
      for j = 0 to Array.length m.(i) - 1 do
        if lire m i j = v then raise (Trouve (i, j))
      done
    done;
    None
  with Trouve (i, j) -> Some (i, j)

3. La mesure, sur une matrice $100\times 100$ contenant deux fois la valeur cherchée, en $(3,7)$ et en $(80,2)$ :

complet    -> Some (80, 2),  10 000 cases lues
exception  -> Some ( 3, 7),     308 cases lues

Deux différences, et la seconde est la plus importante.

Le coût. $308$ cases contre $10000$ : la sortie anticipée s'arrête à la case $3\times 100+7+1=308$. Quand la valeur est absente, les deux lisent les $10000$ cases — mesuré également. La sortie anticipée ne change pas la complexité dans le pire cas, elle change tout dans le cas favorable.

Le résultat. Les deux fonctions ne calculent pas la même chose. La version complète écrase sa référence à chaque occurrence : elle rend donc la dernière. La version à exception rend la première. Une seule ligne de spécification sépare deux fonctions dont on aurait juré qu'elles étaient équivalentes, et aucun test sur une matrice à occurrence unique ne les distinguerait.

drapeau complet : Some (3,7), 308 cases lues,   4 tours exterieurs
drapeau partiel : Some (3,7), 308 cases lues, 100 tours exterieurs