 }
 
 func &<T: Hashable>(lhs: Set<T>, rhs: Set<T>) -> Set<T> {
-    var newSet = Set<T>()
-    for entry in lhs {
-        if rhs.contains(entry) {
-            newSet.add(entry)
-        }
-    }
-    return newSet
+    return lhs.intersection(rhs)
 }
 
 func |<T: Hashable>(lhs: Set<T>, rhs: Set<T>) -> Set<T> {

@assignment func -=<T: Hashable>(inout lhs: Set<T>, rhs: T) {
    lhs.remove(rhs)
}

        self._internalDict = Dictionary<T, T>()
    }

    func intersection(other: Set<T>) -> Set<T> {
        var newSet = Set<T>()
        for entry in self {
            if other.contains(entry) {
                newSet.add(entry)
            }
        }
        return newSet
    }

    func isDisjoint(other: Set<T>) -> Bool {
        return self.intersection(other) == Set([])
    }

    func isdisjoint(other: Set<T>) -> Bool {
        return isDisjoint(other)
    }

    // Implement ArrayLiteralConvertible (allows for "var set: Set<Int> = [2, 4, 8]")
    class func convertFromArrayLiteral(elements: T...) -> Set<T> {
        return Set(elements)
    }

    // Implement Collection (allows for "countElements(set)", etc.)
    subscript (i: Int) -> T {
        return Array(self._internalDict.values)[i]
    }

    // Implement Collection (allows for "countElements(set)", etc.)
