 	public init() {}
 	
 	
-	public var count: Int { return _dictionary.count }
+	public var count: Int { return values.count }
 	
 	public func contains(element: Element) -> Bool {
-		return _dictionary[element] != nil
+		return values[element] != nil
 	}
 	
 	public mutating func insert(element: Element) {
-		_dictionary[element] = Unit()
+		values[element] = Unit()
 	}
 	
 	public mutating func remove(element: Element) {
-		_dictionary.removeValueForKey(element)
+		values.removeValueForKey(element)
 	}
+
+	private var values: Dictionary<Element, Unit> = [:]
 }
 
 
 /// Sequence conformance.
 extension Set : SequenceType {
 	public func generate() -> GeneratorOf<Element> {
-		var generator = _dictionary.keys.generate()
+		var generator = values.keys.generate()
 		return GeneratorOf {
 			return generator.next()
 		}


/// A set of unique elements.
public struct Set<Element : Hashable> {
	var _dictionary: Dictionary<Element, Unit> = [:]
	
	public init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) {
		extend(sequence)
	}


/// Defines equality for sets of equatable elements.
public func == <Element : Hashable> (a: Set<Element>, b: Set<Element>) -> Bool {
	return a.values == b.values
}


