diff --git a/lib/cocoa/src/TSet.swift b/lib/cocoa/src/TSet.swift
new file mode 100644
index 0000000..85833e5
--- /dev/null
+++ b/lib/cocoa/src/TSet.swift
@@ -0,0 +1,161 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import Foundation
+
+
+public struct TSet<Element : TSerializable> : CollectionType, ArrayLiteralConvertible, TSerializable {
+  
+  public static var thriftType : TType { return .SET }
+  
+  public typealias Index = Storage.Index
+  
+  typealias Storage = Set<Element>
+  
+  private var storage : Storage
+  
+  public init() {
+    storage = Storage()
+  }
+  
+  public init(arrayLiteral elements: Element...) {
+    storage = Storage(elements)
+  }
+  
+  public init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) {
+    storage = Storage(sequence)    
+  }
+  
+  public var startIndex : Index { return storage.startIndex }
+  
+  public var endIndex : Index { return storage.endIndex }
+  
+  public mutating func insert(member: Element) {
+    return storage.insert(member)
+  }
+  
+  public mutating func remove(element: Element) -> Element? {
+    return storage.remove(element)
+  }
+  
+  public mutating func removeAll(keepCapacity keepCapacity: Bool = false) {
+    return storage.removeAll(keepCapacity: keepCapacity)
+  }
+  
+  public mutating func removeAtIndex(index: SetIndex<Element>) -> Element {
+    return storage.removeAtIndex(index)
+  }
+  
+  public subscript (position: SetIndex<Element>) -> Element {
+    return storage[position]
+  }
+  
+  public func union(other: TSet) -> TSet {
+    return TSet(storage.union(other))
+  }
+  
+  public func intersect(other: TSet) -> TSet {
+    return TSet(storage.intersect(other))
+  }
+  
+  public func exclusiveOr(other: TSet) -> TSet {
+    return TSet(storage.exclusiveOr(other))
+  }
+  
+  public func subtract(other: TSet) -> TSet {
+    return TSet(storage.subtract(other))
+  }
+  
+  public mutating func intersectInPlace(other: TSet) {
+    storage.intersectInPlace(other)
+  }
+
+  public mutating func exclusiveOrInPlace(other: TSet) {
+    storage.exclusiveOrInPlace(other)
+  }
+
+  public mutating func subtractInPlace(other: TSet) {
+    storage.subtractInPlace(other)
+  }  
+
+  public func isSubsetOf(other: TSet) -> Bool {
+    return storage.isSubsetOf(other)
+  }
+
+  public func isDisjointWith(other: TSet) -> Bool {
+    return storage.isDisjointWith(other)
+  }
+  
+  public func isSupersetOf(other: TSet) -> Bool {
+    return storage.isSupersetOf(other)
+  }
+
+  public var isEmpty: Bool { return storage.isEmpty }
+
+  public var hashValue : Int {
+    let prime = 31
+    var result = 1
+    for element in storage {
+      result = prime * result + element.hashValue
+    }
+    return result
+  }
+  
+  public static func readValueFromProtocol(proto: TProtocol) throws -> TSet {
+    let (elementType, size) = try proto.readSetBegin()
+    if elementType != Element.thriftType {
+      throw NSError(
+        domain: TProtocolErrorDomain,
+        code: Int(TProtocolError.InvalidData.rawValue),
+        userInfo: [TProtocolErrorExtendedErrorKey: NSNumber(int: elementType.rawValue)])
+    }
+    var set = TSet()
+    for _ in 0..<size {
+      let element = try Element.readValueFromProtocol(proto)
+      set.storage.insert(element)
+    }
+    try proto.readSetEnd()
+    return set
+  }
+  
+  public static func writeValue(value: TSet, toProtocol proto: TProtocol) throws {
+    try proto.writeSetBeginWithElementType(Element.thriftType, size: value.count)
+    for element in value.storage {
+      try Element.writeValue(element, toProtocol: proto)
+    }
+    try proto.writeSetEnd()
+  }
+  
+}
+
+extension TSet : CustomStringConvertible, CustomDebugStringConvertible {
+  
+  public var description : String {
+    return storage.description
+  }
+  
+  public var debugDescription : String {
+    return storage.debugDescription
+  }
+  
+}
+
+public func ==<Element>(lhs: TSet<Element>, rhs: TSet<Element>) -> Bool {
+  return lhs.storage == rhs.storage
+}