 		h += (h << 15)
 		return h
 	}
-}
+
+
+	// MARK: Printable
+
+	public var description: String {
+		if self.count == 0 { return "{}" }
+
+		let joined = join(", ", map(toString))
+		return "{ \(joined) }"
+	}
+
+
+	// MARK: Private
+
+	/// The underlying dictionary.
+	private var values: [Element: Unit]
+}
+
+
+/// Extends a `set` with the elements of a `sequence`.
+public func += <S: SequenceType> (inout set: Set<S.Generator.Element>, sequence: S) {
+	set.extend(sequence)
+}
+
+/// Returns a new set with all elements from `set` which are not contained in `other`.
+public func - <Element> (set: Set<Element>, other: Set<Element>) -> Set<Element> {
+	return set.difference(other)
+}
+
+/// Removes all elements in `other` from `set`.
+public func -= <Element> (inout set: Set<Element>, other: Set<Element>) {
+	for element in other {
+		set.remove(element)
+	}
+}
+
+/// Intersects with `set` with `other`.
+public func &= <Element> (inout set: Set<Element>, other: Set<Element>) {
+	for element in set {
+		if !other.contains(element) {
+			set.remove(element)
+		}
+	}
+}
+
+/// Returns the intersection of `set` and `other`.
+public func & <Element> (set: Set<Element>, other: Set<Element>) -> Set<Element> {
+	return set.intersection(other)
+}
+
+
+/// Defines equality for sets of equatable elements.
+public func == <Element: Hashable> (a: Set<Element>, b: Set<Element>) -> Bool {
+	return a.values == b.values
+}

	}


	// MARK: Printable

	public var description: String {
		if self.count == 0 { return "{}" }

		let joined = join(", ", map(toString))
		return "{ \(joined) }"
	}


	// MARK: Private

	/// The underlying dictionary.
	private var values: [Element: Unit]
}


/// Extends a `set` with the elements of a `sequence`.
public func += <S: SequenceType> (inout set: Set<S.Generator.Element>, sequence: S) {
	set.extend(sequence)
}

/// Returns a new set with all elements from `set` which are not contained in `other`.
public func - <Element> (set: Set<Element>, other: Set<Element>) -> Set<Element> {
	return set.difference(other)
}

/// Removes all elements in `other` from `set`.
public func -= <Element> (inout set: Set<Element>, other: Set<Element>) {
	for element in other {
		set.remove(element)
	}
}

/// Intersects with `set` with `other`.
public func &= <Element> (inout set: Set<Element>, other: Set<Element>) {
	for element in set {
		if !other.contains(element) {
			set.remove(element)
		}
	}
}

/// Returns the intersection of `set` and `other`.
public func & <Element> (set: Set<Element>, other: Set<Element>) -> Set<Element> {
	return set.intersection(other)
}


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


/// Hashable conformance.
///
/// This hash function has not been proven in this usage, but is based on Bob Jenkins’ one-at-a-time hash.
extension Set: Hashable {
	public var hashValue: Int {
		var h = reduce(0) { into, each in
			var h = into + each.hashValue

//  Copyright (c) 2014 Rob Rix. All rights reserved.

/// A set of unique elements.
public struct Set<Element: Hashable>: ArrayLiteralConvertible, CollectionType, ExtensibleCollectionType, Hashable, Printable, SequenceType {
	// MARK: Constructors

	/// Constructs a `Set` with the elements of `sequence`.
