From 3f5812bef551ca21a84119cd9f02e5f08abb8bf8 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:40:33 -0500
Subject: [PATCH 01/10] Explicitly convert the bounds to Int.

---
 prototype/Doubt/SES.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index 1031798b8..f1b441b02 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -21,7 +21,7 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 
 	// A matrix whose values are streams representing paths through the edit graph, carrying both the diff & the cost of the remainder of the path.
 	var matrix: Matrix<Stream<(Diff, Int)>>!
-	matrix = Matrix(width: a.count + 1, height: b.count + 1) { i, j in
+	matrix = Matrix(width: Int(a.count.toIntMax() + 1), height: Int(b.count.toIntMax() + 1)) { i, j in
 		// Some explanation is warranted:
 		//
 		// 1. `matrix` captures itself during construction, because each vertex in the edit graph depends on other vertices. This is safe, because a) `Matrix` populates its fields lazily, and b) vertices only depend on those vertices downwards and rightwards of them.

From 38686fee20a746eadebcff02fc1adbf8bf5ecafc Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:45:19 -0500
Subject: [PATCH 02/10] `constructRowMajor` operates over a pair of ranges.

---
 prototype/Doubt/Matrix.swift | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/prototype/Doubt/Matrix.swift b/prototype/Doubt/Matrix.swift
index d77db2871..930b57911 100644
--- a/prototype/Doubt/Matrix.swift
+++ b/prototype/Doubt/Matrix.swift
@@ -5,7 +5,7 @@
 /// Values are retrieved by subscripting with row/column indices. Out-of-bound indices produce `nil` values, rather than asserting.
 public struct Matrix<A> {
 	public init(width: Int, height: Int, compute: (Int, Int) -> A) {
-		self.init(width: width, height: height, values: constructRowMajor(width, height: height, forEach: { i, j in Memo { compute(i, j) } }))
+		self.init(width: width, height: height, values: constructRowMajor(0..<width, down: 0..<height, forEach: { i, j in Memo { compute(i, j) } }))
 	}
 
 	public let width: Int
@@ -36,11 +36,11 @@ public struct Matrix<A> {
 }
 
 /// Constructs a row-major ordering of values produced with `forEach`.
-private func constructRowMajor<A>(width: Int, height: Int, @noescape forEach: (Int, Int) -> A) -> [A] {
+private func constructRowMajor<A, I: ForwardIndexType>(across: Range<I>, down: Range<I>, @noescape forEach: (I, I) -> A) -> [A] {
 	var values: [A] = []
-	values.reserveCapacity(width * height)
-	for j in 0..<height {
-		for i in 0..<width {
+	values.reserveCapacity(Int(across.count.toIntMax()) * Int(down.count.toIntMax()))
+	for j in across {
+		for i in down {
 			values.append(forEach(i, j))
 		}
 	}

From fc76ce05eb812f1c60c78ef21ac1b0e524448307 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:45:30 -0500
Subject: [PATCH 03/10] Matrix can be constructed with a pair of ranges.

---
 prototype/Doubt/Matrix.swift | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/prototype/Doubt/Matrix.swift b/prototype/Doubt/Matrix.swift
index 930b57911..be3643436 100644
--- a/prototype/Doubt/Matrix.swift
+++ b/prototype/Doubt/Matrix.swift
@@ -8,6 +8,10 @@ public struct Matrix<A> {
 		self.init(width: width, height: height, values: constructRowMajor(0..<width, down: 0..<height, forEach: { i, j in Memo { compute(i, j) } }))
 	}
 
+	public init<I: ForwardIndexType>(across: Range<I>, down: Range<I>, compute: (I, I) -> A) {
+		self.init(width: Int(across.count.toIntMax()), height: Int(down.count.toIntMax()), values: constructRowMajor(across, down: down, forEach: { i, j in Memo { compute(i, j) } }))
+	}
+
 	public let width: Int
 	public let height: Int
 

From fdfdeb0dbf0a921c3d75cd797a8ff98b90840c40 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:46:36 -0500
Subject: [PATCH 04/10] SES operates over a pair of ranges.

---
 prototype/Doubt/SES.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index f1b441b02..11c679423 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -21,7 +21,7 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 
 	// A matrix whose values are streams representing paths through the edit graph, carrying both the diff & the cost of the remainder of the path.
 	var matrix: Matrix<Stream<(Diff, Int)>>!
-	matrix = Matrix(width: Int(a.count.toIntMax() + 1), height: Int(b.count.toIntMax() + 1)) { i, j in
+	matrix = Matrix(across: a.indices, down: b.indices) { i, j in
 		// Some explanation is warranted:
 		//
 		// 1. `matrix` captures itself during construction, because each vertex in the edit graph depends on other vertices. This is safe, because a) `Matrix` populates its fields lazily, and b) vertices only depend on those vertices downwards and rightwards of them.

From 217a2c5a50ef6171a7412626ebf94e532143cc64 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:51:15 -0500
Subject: [PATCH 05/10] Define Matrix over two ranges.

---
 prototype/Doubt/Matrix.swift | 32 +++++++++++++++-----------------
 prototype/Doubt/SES.swift    |  2 +-
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/prototype/Doubt/Matrix.swift b/prototype/Doubt/Matrix.swift
index be3643436..9789d2bb7 100644
--- a/prototype/Doubt/Matrix.swift
+++ b/prototype/Doubt/Matrix.swift
@@ -3,38 +3,36 @@
 /// These values are populated by a function from the coordinates of a given cell to the matrix’s element type.
 ///
 /// Values are retrieved by subscripting with row/column indices. Out-of-bound indices produce `nil` values, rather than asserting.
-public struct Matrix<A> {
-	public init(width: Int, height: Int, compute: (Int, Int) -> A) {
-		self.init(width: width, height: height, values: constructRowMajor(0..<width, down: 0..<height, forEach: { i, j in Memo { compute(i, j) } }))
+public struct Matrix<A, I: ForwardIndexType> {
+	public init(across: Range<I>, down: Range<I>, compute: (I, I) -> A) {
+		self.init(across: across, down: down, values: constructRowMajor(across, down: down, forEach: { i, j in Memo { compute(i, j) } }))
 	}
 
-	public init<I: ForwardIndexType>(across: Range<I>, down: Range<I>, compute: (I, I) -> A) {
-		self.init(width: Int(across.count.toIntMax()), height: Int(down.count.toIntMax()), values: constructRowMajor(across, down: down, forEach: { i, j in Memo { compute(i, j) } }))
-	}
-
-	public let width: Int
-	public let height: Int
+	public let across: Range<I>
+	public let down: Range<I>
 
 	private let values: [Memo<A>]
 
-	public subscript (i: Int, j: Int) -> Memo<A>? {
-		guard i < width && j < height else { return nil }
-		return values[i + j * width]
+	public subscript (i: I, j: I) -> Memo<A>? {
+		guard across.contains(i) && down.contains(j) else { return nil }
+		let i = across.startIndex.distanceTo(i)
+		let j = down.startIndex.distanceTo(j)
+		return values[Int((i + j * across.count).toIntMax())]
 	}
 
 
 	// MARK: Functor
 
-	public func map<Other>(transform: A -> Other) -> Matrix<Other> {
-		return Matrix<Other>(width: width, height: height, values: values.map { $0.map(transform) })
+	public func map<Other>(transform: A -> Other) -> Matrix<Other, I> {
+		return Matrix<Other, I>(across: across, down: down, values: values.map { $0.map(transform) })
 	}
 
 
 	// MARK: Implementation details
 
-	private init(width: Int, height: Int, values: [Memo<A>]) {
-		self.width = width
-		self.height = height
+	private init(across: Range<I>, down: Range<I>, values: [Memo<A>]) {
+		self.across = across
+		self.down = down
 		self.values = values
 	}
 }
diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index 11c679423..43938fe25 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -20,7 +20,7 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 	}
 
 	// A matrix whose values are streams representing paths through the edit graph, carrying both the diff & the cost of the remainder of the path.
-	var matrix: Matrix<Stream<(Diff, Int)>>!
+	var matrix: Matrix<Stream<(Diff, Int)>, Int>!
 	matrix = Matrix(across: a.indices, down: b.indices) { i, j in
 		// Some explanation is warranted:
 		//

From 6a0068362e46ec9f57acf911f2622fd8ba054919 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:51:50 -0500
Subject: [PATCH 06/10] Subscript with the correct indices.

---
 prototype/Doubt/SES.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index 43938fe25..5dd342ab2 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -62,7 +62,7 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 		return Stream.Nil
 	}
 
-	return Array(matrix[0, 0]!.value.map { diff, _ in diff })
+	return Array(matrix[a.startIndex, b.startIndex]!.value.map { diff, _ in diff })
 }
 
 

From c0002c47e66c7a3dc35cc0c453f2e80312341c3a Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 15:52:38 -0500
Subject: [PATCH 07/10] Use successors rather than integer addition.

---
 prototype/Doubt/SES.swift | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index 5dd342ab2..78a28efb3 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -28,9 +28,9 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 		//
 		// 2. `matrix` is sized bigger than `a.count` x `b.count`. This is safe, because a) we only get a[i]/b[j] when right/down are non-nil (respectively), and b) right/down are found by looking up elements (i + 1, j) & (i, j + 1) in the matrix, which returns `nil` when out of bounds. So we only access a[i] and b[j] when i and j are in bounds.
 
-		let right = matrix[i + 1, j]
-		let down = matrix[i, j + 1]
-		let diagonal = matrix[i + 1, j + 1]
+		let right = matrix[i.successor(), j]
+		let down = matrix[i, j.successor()]
+		let diagonal = matrix[i.successor(), j.successor()]
 
 		if let right = right, down = down, diagonal = diagonal {
 			let here = recur(a[i], b[j])

From f4a8bcdc90b88316f9e92d8768dab4fd65f3adab Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 16:04:39 -0500
Subject: [PATCH 08/10] Correct the Matrix sizing.

---
 prototype/Doubt/SES.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index 78a28efb3..5970bda14 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -21,7 +21,7 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 
 	// A matrix whose values are streams representing paths through the edit graph, carrying both the diff & the cost of the remainder of the path.
 	var matrix: Matrix<Stream<(Diff, Int)>, Int>!
-	matrix = Matrix(across: a.indices, down: b.indices) { i, j in
+	matrix = Matrix(across: a.startIndex..<a.endIndex.successor(), down: b.startIndex..<b.endIndex.successor()) { i, j in
 		// Some explanation is warranted:
 		//
 		// 1. `matrix` captures itself during construction, because each vertex in the edit graph depends on other vertices. This is safe, because a) `Matrix` populates its fields lazily, and b) vertices only depend on those vertices downwards and rightwards of them.

From ee285d79ddab59b9de2f7db76cddf68697df3b0e Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 16:12:53 -0500
Subject: [PATCH 09/10] =?UTF-8?q?Don=E2=80=99t=20transpose=20the=20coordin?=
 =?UTF-8?q?ate=20system.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 prototype/Doubt/Matrix.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prototype/Doubt/Matrix.swift b/prototype/Doubt/Matrix.swift
index 9789d2bb7..5537729bd 100644
--- a/prototype/Doubt/Matrix.swift
+++ b/prototype/Doubt/Matrix.swift
@@ -41,8 +41,8 @@ public struct Matrix<A, I: ForwardIndexType> {
 private func constructRowMajor<A, I: ForwardIndexType>(across: Range<I>, down: Range<I>, @noescape forEach: (I, I) -> A) -> [A] {
 	var values: [A] = []
 	values.reserveCapacity(Int(across.count.toIntMax()) * Int(down.count.toIntMax()))
-	for j in across {
-		for i in down {
+	for j in down {
+		for i in across {
 			values.append(forEach(i, j))
 		}
 	}

From 84ed21b1a2681f6258a61fae5a84d05da4149707 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Thu, 5 Nov 2015 16:14:10 -0500
Subject: [PATCH 10/10] Generalize SES to arbitrary `CollectionType`.

---
 prototype/Doubt/SES.swift | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/prototype/Doubt/SES.swift b/prototype/Doubt/SES.swift
index 5970bda14..d04c06ccd 100644
--- a/prototype/Doubt/SES.swift
+++ b/prototype/Doubt/SES.swift
@@ -1,8 +1,8 @@
 /// Computes the SES (shortest edit script), i.e. the shortest sequence of diffs (`Free<Leaf, Annotation, Patch<Term>>`) for two arrays of `Term`s which would suffice to transform `a` into `b`.
 ///
 /// This is computed w.r.t. an `equals` function, which computes the equality of leaf nodes within terms, and a `recur` function, which produces diffs representing matched-up terms.
-public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf, Annotation, Patch<Term>> -> Int, recur: (Term, Term) -> Free<Leaf, Annotation, Patch<Term>>?) -> [Free<Leaf, Annotation, Patch<Term>>] {
-	typealias Diff = Free<Leaf, Annotation, Patch<Term>>
+public func SES<Leaf, Annotation, C: CollectionType>(a: C, _ b: C, cost: Free<Leaf, Annotation, Patch<C.Generator.Element>> -> Int, recur: (C.Generator.Element, C.Generator.Element) -> Free<Leaf, Annotation, Patch<C.Generator.Element>>?) -> [Free<Leaf, Annotation, Patch<C.Generator.Element>>] {
+	typealias Diff = Free<Leaf, Annotation, Patch<C.Generator.Element>>
 
 	if a.isEmpty { return b.map { .Insert($0) } }
 	if b.isEmpty { return a.map { .Delete($0) } }
@@ -20,7 +20,7 @@ public func SES<Term, Leaf, Annotation>(a: [Term], _ b: [Term], cost: Free<Leaf,
 	}
 
 	// A matrix whose values are streams representing paths through the edit graph, carrying both the diff & the cost of the remainder of the path.
-	var matrix: Matrix<Stream<(Diff, Int)>, Int>!
+	var matrix: Matrix<Stream<(Diff, Int)>, C.Index>!
 	matrix = Matrix(across: a.startIndex..<a.endIndex.successor(), down: b.startIndex..<b.endIndex.successor()) { i, j in
 		// Some explanation is warranted:
 		//