Mini-rework: cleanup.

Author: oscbyspro

Sources/DiffableTextKit/Helpers/Field.swift

@@ -54,7 +54,7 @@ extension Field {
     //=------------------------------------------------------------------------=
 
     @inlinable mutating func update(snapshot: Snapshot) {
-        let selection = Range.from(selection, // proposed selection calculated first
+        let selection = Range.map(selection, // proposed selection is calculated first
         lower: { Mismatches .forwards(from: self.snapshot[..<$0], to: snapshot).next },
         upper: { Mismatches.backwards(from: self.snapshot[$0...], to: snapshot).next })
         self.snapshot = snapshot; self.update(selection: selection)
@@ -71,8 +71,8 @@ extension Field {
     }
 
     @inlinable mutating func update(selection: Range<Index>, momentum: Directions = .none) {
-        if selection == snapshot.range { return self.selection = selection } // accept max
-        self.selection = Range.from(selection, // set preferred carets based on attributes
+        if selection == snapshot.range { return self.selection = selection } // accept max value
+        self.selection = Range.map(selection, // set preferred carets based on snapshot attributes
         lower: { snapshot.caret(from: $0, towards: momentum.lowerBound, preferring:  .forwards) },
         upper: { snapshot.caret(from: $0, towards: momentum.upperBound, preferring: .backwards) })
     }

Sources/DiffableTextKit/Helpers/Range.swift

@@ -14,30 +14,34 @@
 extension Range {
 
     //=------------------------------------------------------------------------=
-    // MARK: Convenient
+    // MARK: Convenience
     //=------------------------------------------------------------------------=
 
+    /// Creates an empty instance with its lower and upper bound set at the location.
     @inlinable static func empty(_ location: Bound) -> Self {
         Self(uncheckedBounds: (location, location))
     }
 
+    /// Creates an instance with the given bounds.
     @inlinable static func unchecked(_ bounds: (lower: Bound, upper: Bound)) -> Self {
         Self(uncheckedBounds: bounds)
     }
 
     //=------------------------------------------------------------------------=
-    // MARK: Transformative
+    // MARK: Map
     //=------------------------------------------------------------------------=
 
-    @inlinable static func from<T>(_ source: Range<T>,
-    map bound: (T) -> Bound) -> Range<Bound> {
+    /// Maps the bounds of another instance.
+    @inlinable static func map<T>(_ source: Range<T>,
+    bound: (T) -> Bound) -> Range<Bound> {
         //=--------------------------------------=
         // MARK: Return
         //=--------------------------------------=
-        Self.from(source, lower: bound, upper: bound)
+        Self.map(source, lower: bound, upper: bound)
     }
 
-    @inlinable static func from<T>(_ source: Range<T>,
+    /// Maps the bounds of another instance. It maps the upper bound when it is empty.
+    @inlinable static func map<T>(_ source: Range<T>,
     lower: (T) -> Bound, upper: (T) -> Bound) -> Range<Bound> {
         //=--------------------------------------=
         // MARK: Single

Sources/DiffableTextKit/Models/Snapshot.swift

@@ -19,9 +19,9 @@
 /// ```
 ///
 /// Set the anchor to force selection of the caret represented by its index. This is required
-/// when the snapshot contains only formatting characters, and you want the user's caret to appear
-/// at a specific location. As an example, a pattern text style with an empty value may anchor at the
-/// index of the first placeholder character.
+/// when a snapshot contains only formatting characters, and you want the caret to appear
+/// at a location. As an example, a pattern style bound to an enmpty value may want to set
+/// the anchor at the index of the first placeholder character.
 ///
 public struct Snapshot: BidirectionalCollection, RangeReplaceableCollection {
     @usableFromInline typealias Target = (Index) -> Bool
@@ -158,7 +158,7 @@ public extension Snapshot {
     }
 
     //=------------------------------------------------------------------------=
-    // MARK: Attributes
+    // MARK: Update
     //=------------------------------------------------------------------------=
 
     @inlinable mutating func update(attributes index: Index,
@@ -181,7 +181,7 @@ public extension Snapshot {
     }
 
     //=------------------------------------------------------------------------=
-    // MARK: Replacements
+    // MARK: Replace
     //=------------------------------------------------------------------------=
 
     @inlinable mutating func replaceSubrange<C: Collection>(
@@ -239,10 +239,41 @@ extension Snapshot: CustomStringConvertible {
     }
 }
 
+//=----------------------------------------------------------------------------=
+// All extensions below this line are internal implementation details.
 //=----------------------------------------------------------------------------=
 // MARK: + Accessors
 //=----------------------------------------------------------------------------=
-// All extensions below this line are internal implementation details.
+
+extension Snapshot {
+    
+    //=------------------------------------------------------------------------=
+    // MARK: Attributes
+    //=------------------------------------------------------------------------=
+    
+    @inlinable func nonpassthrough(at index: Index) -> Bool {
+        !attributes[index.attribute].contains(.passthrough)
+    }
+    
+    //=------------------------------------------------------------------------=
+    // MARK: Peek
+    //=------------------------------------------------------------------------=
+
+    @inlinable func peek(from index: Index, towards direction: Direction) -> Index? {
+        direction == .forwards ? peek(ahead: index) : peek(behind: index)
+    }
+    
+    @inlinable func peek(ahead index: Index) -> Index? {
+        index != endIndex ? index : nil
+    }
+
+    @inlinable func peek(behind index: Index) -> Index? {
+        index != startIndex ? self.index(before: index) : nil
+    }
+}
+
+//=----------------------------------------------------------------------------=
+// MARK: + Positions
 //=----------------------------------------------------------------------------=
 
 extension Snapshot {
@@ -256,27 +287,27 @@ extension Snapshot {
     }
 
     //=------------------------------------------------------------------------=
-    // MARK: Index
+    // MARK: Single
     //=------------------------------------------------------------------------=
 
     @inlinable func index<T>(at position: T.Position) -> Index where T: Offset {
         T.index(at: position, in: characters)
     }
 
-    @inlinable func indices<T>(at positions: Range<T.Position>) -> Range<Index> where T: Offset {
-        Range.from(positions, map: index(at:))
+    @inlinable func position<T>(at index: Index) -> T.Position where T: Offset {
+        T.position(at: index, in: characters)
     }
 
     //=------------------------------------------------------------------------=
-    // MARK: Position
+    // MARK: Double
     //=------------------------------------------------------------------------=
-    
-    @inlinable func position<T>(at index: Index) -> T.Position where T: Offset {
-        T.position(at: index, in: characters)
+
+    @inlinable func indices<T>(at positions: Range<T.Position>) -> Range<Index> where T: Offset {
+        Range.map(positions, bound: index(at:))
     }
 
     @inlinable func positions<T>(at indices: Range<Index>) -> Range<T.Position> where T: Offset {
-        Range.from(indices, map: position(at:))
+        Range.map(indices, bound: position(at:))
     }
 }
 
@@ -307,29 +338,28 @@ extension Snapshot {
         //=--------------------------------------=
         let direction = direction ?? preference
         //=--------------------------------------=
-        // MARK: Search In The Direction
+        // MARK: Search In Direction
         //=--------------------------------------=
         if let caret = caret(from: index,
         towards: direction,
         jumping: direction == preference ? .to : .through,
         targeting: nonpassthrough(at:)) { return caret }
         //=--------------------------------------=
-        // MARK: Search In The Other Direction
+        // MARK: Search In Other Direction
         //=--------------------------------------=
         if let caret = caret(from: index,
         towards: direction.reversed(),
         jumping: Jump.to, // use Jump.to on each direction
         targeting: nonpassthrough(at:)) { return caret }
         //=--------------------------------------=
-        // MARK: Default To Instance End Index
+        // MARK: Default To Instance's End Index
         //=--------------------------------------=
         return self.endIndex
     }
 
     //=--------------------------------------------------------------------=
     // MARK: Forwards / Backwards / To / Through
     //=--------------------------------------------------------------------=
-
 
     @inlinable func caret(from index: Index, towards direction: Direction,
     jumping distance: Jump, targeting target: Target) -> Index? {
@@ -356,28 +386,4 @@ extension Snapshot {
     @inlinable func caret(from index: Index, backwardsThrough target: Target) -> Index? {
         indices[..<index].last(where: target)
     }
-    
-    //=------------------------------------------------------------------------=
-    // MARK: Peek
-    //=------------------------------------------------------------------------=
-
-    @inlinable func peek(from index: Index, towards direction: Direction) -> Index? {
-        direction == .forwards ? peek(ahead: index) : peek(behind: index)
-    }
-    
-    @inlinable func peek(ahead index: Index) -> Index? {
-        index != endIndex ? index : nil
-    }
-
-    @inlinable func peek(behind index: Index) -> Index? {
-        index != startIndex ? self.index(before: index) : nil
-    }
-    
-    //=------------------------------------------------------------------------=
-    // MARK: Passthrough
-    //=------------------------------------------------------------------------=
-    
-    @inlinable func nonpassthrough(at index: Index) -> Bool {
-        !attributes[index.attribute].contains(.passthrough)
-    }
 }