         return compareOptimallyUsingLCS(other, in: range, transformer: Int.init(integerLiteral:))
     }
 
+    /// Return updating, deleting, and inserting `U`-type indexes from Longest Common
+    /// Subsequence diffing that can be used to apply on collection interfaces such as 
+    /// `UICollectionView`, `UITableView`, `NSTableView`, `NSCollectionView`.
+    ///
+    /// - Complexity: O(m * n)
+    /// - Parameters:
+    ///     - other: a collection to compare with.
+    ///     - range: a range for both collection to apply the algorithm on.
+    ///       If `range` is `nil`, the operation will perform on the entire collections.
+    ///     - transformer: a block to apply diffing indexes with.
+    /// - Note: the results are guaranteed to have the elements' order reserved that 
+    ///         can apply on `self` and produce `other`.
     func compareThoroughlyUsingLCS<C, T>(_ other: C, in range: Range<Index>? = nil, transformer: IndexTransformer<T>) -> (updates: [T], deletes: [T], inserts: [T]) where
         T: Comparable,
         C: Collection,

        return compareThoroughlyUsingLCS(other, in: range, transformer: transformer)
    }

    func compareThoroughlyUsingLCS<C>(_ other: C, in range: Range<Index>? = nil) -> (updates: [Int], deletes: [Int], inserts: [Int]) where
        C: Collection,
        C.Index == Index,


public extension Collection where Iterator.Element: Comparable {

    /// Return the first element using Binary Search algorithm.
    ///
    /// - Parameter element: a element to search for.
    /// - Warning: this should only be called on sorted collection
    func binarySearch(_ element: Iterator.Element) -> Index? {
        func _binarySearch(in range: Range<Index>) -> Index? {
            guard range.lowerBound < range.upperBound else { return nil }
