From: Jim Pryor <profjim@jimpryor.net>
Date: Wed, 1 Dec 2010 05:24:28 +0000 (-0500)
Subject: zippers: spaces
X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=commitdiff_plain;h=83b68c86811f83d777305ac085c01a19f2cb373c

zippers: spaces

Signed-off-by: Jim Pryor <profjim@jimpryor.net>
---

diff --git a/tree_and_list_zippers.mdwn b/tree_and_list_zippers.mdwn
index 81117060..fafde0a4 100644
--- a/tree_and_list_zippers.mdwn
+++ b/tree_and_list_zippers.mdwn
@@ -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...?