     /// Creates a diff between the calee and `other` collection
     ///
     /// - Complexity: O((N+M)*D)
-    /// 
+    ///
     /// - Parameters:
     ///   - other: a collection to compare the calee to
     /// - Returns: a Diff between the calee and `other` collection
     public func diff(
         _ other: Self,
         isEqual: EqualityChecker<Self>
-    ) -> Diff {
+        ) -> Diff {
         let diffPath = outputDiffPathTraces(
             to: other,
             isEqual: isEqual
         )
         return Diff(elements:
             diffPath
-            .flatMap { Diff.Element(trace: $0) }
+                .flatMap { Diff.Element(trace: $0) }
         )
     }
 

        let D = traceStep.D

        if traceType == .insertion {
            let x = traceStep.nextX!
            return Trace(from: Point(x: x, y: x - k - 1), to: Point(x: x, y: x - k), D: D)
        } else {
            let x = traceStep.previousX! + 1
            return Trace(from: Point(x: x - 1, y: x - k), to: Point(x: x, y: x - k), D: D)
        }
    }

    fileprivate func myersDiffTraces(
        to: Self,
        isEqual: (Iterator.Element, Iterator.Element) -> Bool
        ) -> [Trace] {

        // fromCount is N, N is the number of from array
        let fromCount = Int(count)
        // toCount is M, M is the number of to array
        let toCount = Int(to.count)
        var traces = Array<Trace>()

        let max = fromCount + toCount // this is arbitrary, maximum difference between from and to. N+M assures that this algorithm always finds from diff

        var vertices = Array(repeating: -1, count: max + 1) // from [0...N+M], it is -M...N in the whitepaper
        vertices[toCount + 1] = 0

        // D-patch: numberOfDifferences is D
        for numberOfDifferences in 0 ... max {
            for k in stride(from: (-numberOfDifferences), through: numberOfDifferences, by: 2) {

                guard k >= -toCount && k <= fromCount else {
                    continue
                }

                let index = k + toCount
                let traceStep = TraceStep(D: numberOfDifferences, k: k, previousX: vertices.value(at: index - 1), nextX: vertices.value(at: index + 1))
                if let trace = bound(trace: nextTrace(traceStep), maxX: fromCount, maxY: toCount) {
                    var x = trace.to.x
