index 8111706..fafde0a 100644 (file)
@@ -5,28 +5,28 @@
Say you've got some moderately-complex function for searching through a list, for example:

let find_nth (test : 'a -> bool) (n : int) (lst : 'a list) : (int * 'a) ->
-               let rec helper (position : int) n lst =
-                       match lst with
-                       | [] -> failwith "not found"
-                       | x :: xs when test x -> (if n = 1
-                               then (position, x)
-                               else helper (position + 1) (n - 1) xs
-                       )
-                       | x :: xs -> helper (position + 1) n xs
-               in helper 0 n lst;;
+           let rec helper (position : int) n lst =
+               match lst with
+               | [] -> failwith "not found"
+               | x :: xs when test x -> (if n = 1
+                   then (position, x)
+                   else helper (position + 1) (n - 1) xs
+               )
+               | x :: xs -> helper (position + 1) n xs
+           in helper 0 n lst;;

This searches for the `n`th element of a list that satisfies the predicate `test`, and returns a pair containing the position of that element, and the element itself. Good. But now what if you wanted to retrieve a different kind of information, such as the `n`th element matching `test`, together with its preceding and succeeding elements? In a real situation, you'd want to develop some good strategy for reporting when the target element doesn't have a predecessor and successor; but we'll just simplify here and report them as having some default value:

let find_nth' (test : 'a -> bool) (n : int) (lst : 'a list) (default : 'a) : ('a * 'a * 'a) ->
-               let rec helper (predecessor : 'a) n lst =
-                       match lst with
-                       | [] -> failwith "not found"
-                       | x :: xs when test x -> (if n = 1
-                               then (predecessor, x, match xs with [] -> default | y::ys -> y)
-                               else helper x (n - 1) xs
-                       )
-                       | x :: xs -> helper x n xs
-               in helper default n lst;;
+           let rec helper (predecessor : 'a) n lst =
+               match lst with
+               | [] -> failwith "not found"
+               | x :: xs when test x -> (if n = 1
+                   then (predecessor, x, match xs with [] -> default | y::ys -> y)
+                   else helper x (n - 1) xs
+               )
+               | x :: xs -> helper x n xs
+           in helper default n lst;;

This duplicates a lot of the structure of `find_nth`; it just has enough different code to retrieve different information when the matching element is found. But now what if you wanted to retrieve yet a different kind of information...?