Create Bag with initial elements

CHANGELOG.md

@@ -4,6 +4,7 @@
 1. New property operator: `filter` (#586, kudos to @iv-mexx)
 1. New operator `merge(with:)` (#600, kudos to @ra1028)
 1. New operator `map(value:)` (#601, kudos to @ra1028)
+1. Bag can be created with the initial elements now (#609, kudos to @ra1028)
 
 # 3.1.0
 1. Fixed `schedule(after:interval:leeway:)` being cancelled when the returned `Disposable` is not retained. (#584, kudos to @jjoelson)

Sources/Bag.swift

@@ -14,12 +14,22 @@ public struct Bag<Element> {
 		fileprivate let value: UInt64
 	}
 
-	fileprivate var elements: ContiguousArray<Element> = []
-	fileprivate var tokens: ContiguousArray<UInt64> = []
+	fileprivate var elements: ContiguousArray<Element>
+	fileprivate var tokens: ContiguousArray<UInt64>
 
-	private var nextToken = Token(value: 0)
+	private var nextToken: Token
 
-	public init() {}
+	public init() {
+		elements = ContiguousArray()
+		tokens = ContiguousArray()
+		nextToken = Token(value: 0)
+	}
+
+	public init<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+		self.elements = ContiguousArray(elements)
+		self.nextToken = Token(value: UInt64(self.elements.count))
+		self.tokens = ContiguousArray(0..<nextToken.value)
+	}
 
 	/// Insert the given value into `self`, and return a token that can
 	/// later be passed to `remove(using:)`.

Sources/Disposable.swift

@@ -140,12 +140,7 @@ public final class CompositeDisposable: Disposable {
 	public init<S: Sequence>(_ disposables: S)
 		where S.Iterator.Element == Disposable
 	{
-		var bag: Bag<Disposable> = Bag()
-
-		for disposable in disposables {
-			bag.insert(disposable)
-		}
-
+		let bag = Bag(disposables)
 		self.disposables = Atomic(bag)
 		self.state = UnsafeAtomicState(DisposableState.active)
 	}

Tests/ReactiveSwiftTests/BagSpec.swift

@@ -50,5 +50,23 @@ class BagSpec: QuickSpec {
 			expect(bag).toNot(contain("bar"))
 			expect(bag).toNot(contain("buzz"))
 		}
+
+		it("should create bag with initial values") {
+			let values = ["foo", "bar", "buzz"]
+			var bag = Bag(values)
+
+			let a = bag.insert("fuzz")
+
+			expect(bag).to(contain("foo"))
+			expect(bag).to(contain("bar"))
+			expect(bag).to(contain("buzz"))
+			expect(bag).to(contain("fuzz"))
+
+			bag.remove(using: a)
+			expect(bag).to(contain("foo"))
+			expect(bag).to(contain("bar"))
+			expect(bag).to(contain("buzz"))
+			expect(bag).toNot(contain("fuzz"))
+		}
 	}
 }

Tests/ReactiveSwiftTests/DisposableSpec.swift

@@ -81,6 +81,24 @@ class DisposableSpec: QuickSpec {
 				disposable.dispose()
 				expect(simpleDisposable.isDisposed) == false
 			}
+
+			it("should create with initial disposables") {
+				let disposable1 = AnyDisposable()
+				let disposable2 = AnyDisposable()
+				let disposable3 = AnyDisposable()
+
+				let compositeDisposable = CompositeDisposable([disposable1, disposable2, disposable3])
+
+				expect(disposable1.isDisposed) == false
+				expect(disposable2.isDisposed) == false
+				expect(disposable3.isDisposed) == false
+
+				compositeDisposable.dispose()
+
+				expect(disposable1.isDisposed) == true
+				expect(disposable2.isDisposed) == true
+				expect(disposable3.isDisposed) == true
+			}
 		}
 
 		describe("ScopedDisposable") {