Revert " is now renamed to"

This reverts commit e23c3b7.

Sources/Algorithm.swift

@@ -118,9 +118,9 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
     /// - Complexity: O(n)
     public init(source: Collection, target: Collection) {
         typealias Section = Collection.Element
-        typealias SectionIdentifier = Collection.Element.Model.Identifier
+        typealias SectionIdentifier = Collection.Element.Model.DifferenceIdentifier
         typealias Element = Collection.Element.Collection.Element
-        typealias ElementIdentifier = Collection.Element.Collection.Element.Identifier
+        typealias ElementIdentifier = Collection.Element.Collection.Element.DifferenceIdentifier
 
         let sourceSections = ContiguousArray(source)
         let targetSections = ContiguousArray(target)
@@ -167,7 +167,7 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
             for sourceElementIndex in contiguousSourceSections[sourceSectionIndex].indices {
                 let sourceElementPath = ElementPath(element: sourceElementIndex, section: sourceSectionIndex)
                 let sourceElement = contiguousSourceSections[sourceElementPath]
-                flattenSourceIdentifiers.append(sourceElement.identifier)
+                flattenSourceIdentifiers.append(sourceElement.differenceIdentifier)
                 flattenSourceElementPaths.append(sourceElementPath)
             }
         }
@@ -199,7 +199,7 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
                 let targetElements = contiguousTargetSections[targetSectionIndex]
 
                 for targetElementIndex in targetElements.indices {
-                    var targetIdentifier = targetElements[targetElementIndex].identifier
+                    var targetIdentifier = targetElements[targetElementIndex].differenceIdentifier
                     let key = TableKey(pointer: &targetIdentifier)
 
                     switch sourceOccurrencesTable[key] {
@@ -402,19 +402,19 @@ private func differentiate<E, D: Differentiable, I>(
 
     var sourceTraces = ContiguousArray<Trace<Int>>()
     var targetReferences = ContiguousArray<Int?>(repeating: nil, count: target.count)
-    var sourceIdentifiers = ContiguousArray<D.Identifier>()
+    var sourceIdentifiers = ContiguousArray<D.DifferenceIdentifier>()
 
     sourceIdentifiers.reserveCapacity(source.count)
     sourceTraces.reserveCapacity(source.count)
 
     for sourceElement in source {
         sourceTraces.append(Trace())
-        sourceIdentifiers.append(differentiable(sourceElement).identifier)
+        sourceIdentifiers.append(differentiable(sourceElement).differenceIdentifier)
     }
 
     sourceIdentifiers.withUnsafeBufferPointer { bufferPointer in
         // The pointer and the table key are for optimization.
-        var sourceOccurrencesTable = [TableKey<D.Identifier>: Occurrence](minimumCapacity: source.count * 2)
+        var sourceOccurrencesTable = [TableKey<D.DifferenceIdentifier>: Occurrence](minimumCapacity: source.count * 2)
 
         // Record the index where the element was found in source collection into occurrences table.
         for sourceIndex in sourceIdentifiers.indices {
@@ -436,7 +436,7 @@ private func differentiate<E, D: Differentiable, I>(
 
         // Record the target index and the source index that the element having the same identifier.
         for targetIndex in target.indices {
-            var targetIdentifier = differentiable(target[targetIndex]).identifier
+            var targetIdentifier = differentiable(target[targetIndex]).differenceIdentifier
             let key = TableKey(pointer: &targetIdentifier)
 
             switch sourceOccurrencesTable[key] {

Sources/AnyDifferentiable.swift

@@ -1,7 +1,7 @@
 /// A type-erased differentiable value.
 ///
 /// The `AnyDifferentiable` type hides the specific underlying types.
-/// Associated type `Identifier` is erased by `AnyHashable`.
+/// `DifferenceIdentifier` type is erased by `AnyHashable`.
 /// The comparisons of whether has updated is forwards to an underlying differentiable value.
 ///
 /// You can store mixed-type elements in collection that require `Differentiable` conformance by
@@ -26,7 +26,7 @@ public struct AnyDifferentiable: Differentiable {
     /// The value wrapped by this instance.
     public let base: Any
     /// A type-erased identifier value for difference calculation.
-    public let identifier: AnyHashable
+    public let differenceIdentifier: AnyHashable
 
     private let isContentEqualTo: (AnyDifferentiable) -> Bool
 
@@ -36,7 +36,7 @@ public struct AnyDifferentiable: Differentiable {
     ///   - base: A differentiable value to wrap.
     public init<D: Differentiable>(_ base: D) {
         self.base = base
-        self.identifier = AnyHashable(base.identifier)
+        self.differenceIdentifier = AnyHashable(base.differenceIdentifier)
 
         self.isContentEqualTo = { source in
             guard let sourceBase = source.base as? D else { return false }

Sources/Differentiable.swift

@@ -1,10 +1,10 @@
 /// Represents the value that identified and can be compared to whether has updated.
 public protocol Differentiable {
     /// A type representing the identifier.
-    associatedtype Identifier: Hashable
+    associatedtype DifferenceIdentifier: Hashable
 
     /// An identifier value for difference calculation.
-    var identifier: Identifier { get }
+    var differenceIdentifier: DifferenceIdentifier { get }
 
     /// Indicate whether the content of `self` is equals to the content of
     /// the given source value.
@@ -33,7 +33,7 @@ public extension Differentiable where Self: Equatable {
 
 public extension Differentiable where Self: Hashable {
     /// The `self` value as an identifier for difference calculation.
-    var identifier: Self {
+    var differenceIdentifier: Self {
         return self
     }
 }

Tests/AnyDifferentiableTest.swift

@@ -8,26 +8,26 @@ final class AnyDifferentiableTestCase: XCTestCase {
         let d1 = AnyDifferentiable(base1)
         let d2 = AnyDifferentiable(base1)
 
-        XCTAssertEqual(d1.identifier.hashValue, d2.identifier.hashValue)
-        XCTAssertEqual(d1.identifier, d2.identifier)
+        XCTAssertEqual(d1.differenceIdentifier.hashValue, d2.differenceIdentifier.hashValue)
+        XCTAssertEqual(d1.differenceIdentifier, d2.differenceIdentifier)
         XCTAssertTrue(d1.isContentEqual(to: d2))
 
         let base2 = M(1, false)
 
         let d3 = AnyDifferentiable(base1)
         let d4 = AnyDifferentiable(base2)
 
-        XCTAssertNotEqual(d3.identifier.hashValue, d4.identifier.hashValue)
-        XCTAssertNotEqual(d3.identifier, d4.identifier)
+        XCTAssertNotEqual(d3.differenceIdentifier.hashValue, d4.differenceIdentifier.hashValue)
+        XCTAssertNotEqual(d3.differenceIdentifier, d4.differenceIdentifier)
         XCTAssertFalse(d3.isContentEqual(to: d4))
 
         let base3 = M(1, true)
 
         let d5 = AnyDifferentiable(base2)
         let d6 = AnyDifferentiable(base3)
 
-        XCTAssertEqual(d5.identifier.hashValue, d6.identifier.hashValue)
-        XCTAssertEqual(d5.identifier, d6.identifier)
+        XCTAssertEqual(d5.differenceIdentifier.hashValue, d6.differenceIdentifier.hashValue)
+        XCTAssertEqual(d5.differenceIdentifier, d6.differenceIdentifier)
         XCTAssertFalse(d5.isContentEqual(to: d6))
     }
 }

Tests/SectionTest.swift

@@ -6,8 +6,8 @@ final class SectionTestCase: XCTestCase {
         let s1 = Section(model: D.a, elements: [0])
         let s2 = Section(model: s1.model, elements: s1.elements)
 
-        XCTAssertEqual(s1.model.identifier, s2.model.identifier)
-        XCTAssertEqual(s1.model.identifier.hashValue, s2.model.identifier.hashValue)
+        XCTAssertEqual(s1.model.differenceIdentifier, s2.model.differenceIdentifier)
+        XCTAssertEqual(s1.model.differenceIdentifier.hashValue, s2.model.differenceIdentifier.hashValue)
         XCTAssertEqual(s1.elements, s2.elements)
     }
 }

Tests/TestTools.swift

@@ -21,7 +21,7 @@ struct M: Differentiable, Equatable {
         self.b = b
     }
 
-    var identifier: Int {
+    var differenceIdentifier: Int {
         return i
     }
 }