     (seq: S) {
       remove(seq.generate())
   }
+}
+
+// MARK: Set Methods
+
+/**
+contains(_:)
+exclusiveOr(_:)
+exclusiveOrInPlace(_:)
+intersect(_:)
+intersectInPlace(_:)
+isDisjointWith(_:)
+isStrictSubsetOf(_:)
+isStrictSupersetOf(_:)
+isSubsetOf(_:)
+isSupersetOf(_:)
+remove(_:)
+removeAll(keepCapacity:)
+removeAtIndex(_:)
+removeFirst()
+subtract(_:)
+subtractInPlace(_:)
+union(_:)
+unionInPlace(_:)
+*/
+
+public extension Trie {
+  private func contains
+    <G : GeneratorType where G.Element == Element>
+    (var gen: G) -> Bool {
+      return gen.next().map{self.children[$0]?.contains(gen) ?? false} ?? endHere
+  }
+  public func contains
+    <S : SequenceType where S.Generator.Element == Element>
+    (seq: S) -> Bool {
+      return contains(seq.generate())
+  }
+  
+  public func exclusiveOr<
+    S : SequenceType where
+    S.Generator.Element : SequenceType,
+    S.Generator.Element.Generator.Element == Element
+    > (sequence: S) -> Trie<Element> {
+      var ret = self
+      ret.exclusiveOrInPlace(sequence)
+      return ret
+  }
+  
+  public mutating func exclusiveOrInPlace<
+    S : SequenceType where
+    S.Generator.Element : SequenceType,
+    S.Generator.Element.Generator.Element == Element
+    >(sequence: S) {
+      for toRemove in sequence { remove(toRemove) }
+  }
+  
+  public func intersect<
+    S : SequenceType where
+    S.Generator.Element : SequenceType,
+    S.Generator.Element.Generator.Element == Element
+    >(sequence: S) -> Trie<Element> {
+      return Trie(sequence.filter(contains))
+  }
+  
+  public mutating func intersectInPlace<
+    S : SequenceType where
+    S.Generator.Element : SequenceType,
+    S.Generator.Element.Generator.Element == Element
+    >(sequence: S) {
+      self = intersect(sequence)
+  }
+  
+  public func isDisjointWith<
+    S : SequenceType where
+    S.Generator.Element : SequenceType,
+    S.Generator.Element.Generator.Element == Element
+    >(sequence: S) -> Bool { return !sequence.contains(self.contains) }
 
   public mutating func unionInPlace(with: Trie<Element>) {
     for (head, child) in with.children {
       children[head]?.unionInPlace(child) ?? {children[head] = child}()
     }
   }
-
-  public mutating func exclusiveOrInPlace<
-    S : SequenceType where
-    S.Generator.Element : SequenceType,
-    S.Generator.Element.Generator.Element == Element
-    >(sequence: S) {
-      for toRemove in sequence { remove(toRemove) }
-  }
-
-  public func intersect<
-    S : SequenceType where
-    S.Generator.Element : SequenceType,
-    S.Generator.Element.Generator.Element == Element
-    >(sequence: S) -> Trie<Element> {
-      var ret = Trie()
-      for element in sequence where contains(element) { ret.insert(element) }
-      return ret
-  }
-
-  public func isDisjointWith<
-    S : SequenceType where
-    S.Generator.Element : SequenceType,
-    S.Generator.Element.Generator.Element == Element
-    >(sequence: S) -> Bool { return !sequence.contains(self.contains) }
 }
 
 // MARK: More effecient implementations

    return ", ".join(contents.map {"".join($0.map { String(reflecting: $0) })})
  }
}

// MARK: Init


  }
}

extension Trie {
  private mutating func remove
    <G : GeneratorType where G.Element == Element>
    (var gen: G) {
