 
 /// A uniquely identifying token for removing a value that was inserted into a
 /// Bag.
-public final class RemovalToken {
-	fileprivate var identifier: UInt?
-
-	fileprivate init(identifier: UInt) {
-		self.identifier = identifier
-	}
-}
+public final class RemovalToken {}
 
 /// An unordered, non-unique collection of values of type `Element`.
 public struct Bag<Element> {
 	fileprivate var elements: ContiguousArray<BagElement<Element>> = []
-	private var currentIdentifier: UInt = 0
 
-	public init() {
-	}
+	public init() {}
 
 	/// Insert the given value into `self`, and return a token that can
-	/// later be passed to `removeValueForToken()`.
+	/// later be passed to `remove(using:)`.
 	///
 	/// - parameters:
 	///   - value: A value that will be inserted.
 	@discardableResult
 	public mutating func insert(_ value: Element) -> RemovalToken {
-		let (nextIdentifier, overflow) = UInt.addWithOverflow(currentIdentifier, 1)
-		if overflow {
-			reindex()
-		}
-
-		let token = RemovalToken(identifier: currentIdentifier)
-		let element = BagElement(value: value, identifier: currentIdentifier, token: token)
+		let token = RemovalToken()
+		let element = BagElement(value: value, token: token)
 
 		elements.append(element)
-		currentIdentifier = nextIdentifier
-
 		return token
 	}
 


private struct BagElement<Value> {
	let value: Value
	var identifier: UInt
	let token: RemovalToken
}


	/// - parameters:
	///   - token: A token returned from a call to `insert()`.
	public mutating func remove(using token: RemovalToken) {
		let tokenIdentifier = ObjectIdentifier(token)
		// Removal is more likely for recent objects than old ones.
		for i in elements.indices.reversed() {
			if ObjectIdentifier(elements[i].token) == tokenIdentifier {
				elements.remove(at: i)
				break
			}
		}
	}
}
