[Basic] Remove OrderedSet MutableCollection conformance

The semantics for MutableCollection and RandomAccessCollection are
proving to be undefined in edge cases and right now we don't really need
them as cycle detection could be implemented without it. This basically
reverts: 04781a2 and
79cc5ed

Author: aciidgh

Sources/Basic/OrderedSet.swift

@@ -10,7 +10,7 @@
 
 /// An ordered set is an ordered collection of instances of `Element` in which
 /// uniqueness of the objects is guaranteed.
-public struct OrderedSet<E: Hashable>: Equatable, MutableCollection, RandomAccessCollection {
+public struct OrderedSet<E: Hashable>: Equatable, Collection {
     public typealias Element = E
     public typealias Index = Int
     public typealias Indices = CountableRange<Int>
@@ -77,45 +77,6 @@ public struct OrderedSet<E: Hashable>: Equatable, MutableCollection, RandomAcces
         array.removeAll(keepingCapacity: keepCapacity)
         set.removeAll(keepingCapacity: keepCapacity)
     }
-
-    // MARK:- MutableCollection, RandomAccessCollection conformance
-
-    public var startIndex: Int { return contents.startIndex }
-    public var endIndex: Int { return contents.endIndex }
-
-    public subscript(position: Int) -> Element {
-        get {
-            return array[position]
-        }
-        set(newValue) {
-            let oldValue = array[position]
-            // Remove the old value from set.
-            set.remove(oldValue)
-            // Add the new value.
-            array[position] = newValue
-            set.insert(newValue)
-        }
-    }
-
-    public subscript(bounds: Range<Int>) -> ArraySlice<Element> {
-        get {
-            return array[bounds]
-        }
-        set(newValues) {
-            let oldValues = array[bounds]
-            // Remove the old values from set.
-            oldValues.forEach{ set.remove($0) }
-            // Add the new values.
-            array[bounds] = newValues
-            newValues.forEach{ set.insert($0) }
-        }
-    }
-}
-
-extension OrderedSet: RangeReplaceableCollection {
-    mutating public func replaceSubrange<C>(_ subrange: Range<Int>, with newElements: C) where C : Collection, C.Iterator.Element == Element {
-        self[subrange] = ArraySlice(newElements)
-    }
 }
 
 extension OrderedSet: ExpressibleByArrayLiteral {
@@ -128,6 +89,14 @@ extension OrderedSet: ExpressibleByArrayLiteral {
     }
 }
 
+extension OrderedSet: RandomAccessCollection {
+    public var startIndex: Int { return contents.startIndex }
+    public var endIndex: Int { return contents.endIndex }
+    public subscript(i: Int) -> Element {
+      return contents[i]
+    }
+}
+
 public func ==<T>(lhs: OrderedSet<T>, rhs: OrderedSet<T>) -> Bool {
     return lhs.contents == rhs.contents
 }

Tests/BasicTests/OrderedSetTests.swift

@@ -51,41 +51,7 @@ class OrderedSetTests: XCTestCase {
         XCTAssertEqual(set.contents, [])
     }
 
-    func testMutation() {
-        var set = OrderedSet<Int>()
-        set.append(1)
-        set.append(2)
-        set.append(3)
-        XCTAssertEqual(set.contents, [1, 2, 3])
-
-        set[0] = 4
-        XCTAssertEqual(set.contents, [4, 2, 3])
-        XCTAssertFalse(set.contains(1))
-        XCTAssert(set.contains(4))
-
-        set[2] = 9
-        XCTAssertEqual(set.contents, [4, 2, 9])
-        XCTAssertFalse(set.contains(3))
-        XCTAssert(set.contains(9))
-
-        XCTAssertEqual(set[0..<2], [4, 2])
-        set[0..<2] = [6, 7]
-        XCTAssertEqual(set, [6, 7, 9])
-        XCTAssertFalse(set.contains(4))
-        XCTAssert(set.contains(6))
-        XCTAssertFalse(set.contains(2))
-        XCTAssert(set.contains(7))
-
-        set.replaceSubrange(0..<2, with: [1, 2])
-        XCTAssertEqual(set.contents, [1, 2, 9])
-        XCTAssertFalse(set.contains(6))
-        XCTAssert(set.contains(1))
-        XCTAssertFalse(set.contains(7))
-        XCTAssert(set.contains(2))
-    }
-
     static var allTests = [
         ("testBasics", testBasics),
-        ("testMutation", testMutation),
     ]
 }