Set.swift

import Swift

struct SetGenerator<T : Hashable> : Generator {
    var dictGenerator : DictionaryGenerator<T, Void>
    
    init(_ d : Dictionary<T,Void>) {
        dictGenerator = d.generate()
    }
    
    typealias Element = T
    mutating func next() -> Element? {
        if let tuple = dictGenerator.next() {
            let (k, _) = tuple
            return k
        } else {
            return nil
        }
    }
}

struct Set<T : Hashable> : Sequence {
    var dict : Dictionary<T,Void> = [:]
    
    init(_ a : Array<T>) {
        for i in a {
            insert(i)
        }
    }
    
    mutating func insert(i : T) {
        dict[i] = ()
    }
    mutating func remove(i : T) {
        dict.removeValueForKey(i)
    }
    func isMember(i : T) -> Bool {
        return dict[i].getLogicValue()
    }
    
    typealias GeneratorType = SetGenerator<T>
    func generate() -> GeneratorType { return SetGenerator(dict) }
}

var s = Set<Int>([3, 5, 7, 9, 11, 13, 17])

s.insert(3)
s.insert(4)
for i in s {
    println("\(i)")
}
s.isMember(6)
s.isMember(7)

extension Set: ArrayLiteralConvertible {
    static func convertFromArrayLiteral(elements: T...) -> Set<T> {
        return Set(elements)
    }
}

var s: Set<Int> = [3, 5, 7, 9, 11, 13, 17]

An alternative implementation of Sequence conformance:

extension Set : Sequence {
    func generate() -> MapSequenceGenerator<Dictionary<Element, Void>.GeneratorType, Element> {
        return _dictionary.keys.generate()
    }
}