feat: add extension for addition and subtraction

Sources/OrderedSet/OrderedSet+Cocode.swift

@@ -0,0 +1,38 @@
+extension OrderedSet {
+
+    /// Appends the contents of a sequencet to the ordered set.
+    ///
+    /// If it already contains the element, an element is not inserted.
+    ///
+    /// - returns: True if any item was inserted.
+    @discardableResult
+    public mutating func append<S : Sequence>(_ sequence: S) -> Bool
+      where S.Iterator.Element == Element  {
+        return sequence.map { append($0) }.contains(true)
+    }
+
+    /// Return a new ordered set with the elements of a finite sequence
+    /// appended.
+    public func appending<S : Sequence>(_ sequence: S)
+      -> OrderedSet where S.Iterator.Element == Element {
+        var copy = self
+        copy.append(sequence)
+        return copy
+    }
+
+    /// Remove all members in the ordered set that occur in a finite sequence.
+    public mutating func subtract<S : Sequence>(_ sequence: S)
+      where S.Iterator.Element == Element {
+        set.subtract(sequence)
+        array = array.filter { set.contains($0) }
+    }
+
+    /// Return a new ordered set with elements in this set that do not occur
+    /// in a finite sequence.
+    public func subtracting<S : Sequence>(_ sequence: S)
+      -> OrderedSet where S.Iterator.Element == Element {
+        var copy = self
+        copy.subtract(sequence)
+        return copy
+    }
+}

Tests/OrderedSetTests/OrderedSetTests.swift

@@ -56,4 +56,49 @@ class OrderedSetTests: XCTestCase {
         XCTAssertEqual(set.remove("Hello"), nil)
         XCTAssertEqual(set.remove("cool"), nil)
     }
+
+    func testAppendSequence() {
+        var set = OrderedSet<String>()
+        XCTAssertTrue(set.isEmpty)
+        XCTAssertEqual(set.contents, [])
+
+        XCTAssertTrue(set.append(["one", "two", "three"]))
+
+        XCTAssertFalse(set.isEmpty)
+        XCTAssertEqual(set.count, 3)
+        XCTAssertEqual(set[0], "one")
+        XCTAssertEqual(set[1], "two")
+        XCTAssertEqual(set[2], "three")
+        XCTAssertEqual(set.contents, ["one", "two", "three"])
+
+        XCTAssertFalse(set.append(["one", "two"]))
+        XCTAssertFalse(set.append(["one", "two", "three"]))
+    }
+
+    func testAppendingSequence() {
+        let reference = OrderedSet(["one", "two", "three"])
+        let set = OrderedSet(["one"])
+
+        XCTAssertNotEqual(reference, set)
+        XCTAssertEqual(reference, set.appending(["two", "three"]))
+    }
+
+    func testSubtractSequence() {
+        var set = OrderedSet(["one", "two", "three"])
+
+        set.subtract(["two", "three"])
+
+        XCTAssertFalse(set.isEmpty)
+        XCTAssertEqual(set.count, 1)
+        XCTAssertEqual(set[0], "one")
+        XCTAssertEqual(set.contents, ["one"])
+    }
+
+    func testSubtractingSequence() {
+        let reference = OrderedSet(["one"])
+        let set = OrderedSet(["one", "two", "three"])
+
+        XCTAssertNotEqual(reference, set)
+        XCTAssertEqual(reference, set.subtracting(["two", "three"]))
+    }
 }