 
 // MARK: Methods
 
-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 extension Trie {
-  private mutating func remove
-    <G : GeneratorType where G.Element == Element>
-    (var gen: G) {
-      if let head = gen.next() {
-        children[head]?.remove(gen)
-      } else {
-        endHere = false
-      }
-  }
-  public mutating func remove
-    <S : SequenceType where S.Generator.Element == Element>
-    (seq: S) {
-      remove(seq.generate())
-  }
-}
-
 extension Trie {
   private func completions
     <G : GeneratorType where G.Element == Element>

    >(sequence: S) {
      for toRemove in sequence { remove(toRemove) }
  }
}

extension Trie {
  public func intersect<
    S : SequenceType where
    S.Generator.Element : SequenceType,

    >(sequence: S) -> Bool { return !sequence.contains(self.contains) }
}

// MARK: More effecient implementations

extension Trie {
  public func map<S : SequenceType>(@noescape transform: [Element] -> S) -> Trie<S.Generator.Element> {
    return Trie<S.Generator.Element>(contents.map(transform))
  }
}

extension Trie {
  public func flatMap<S : SequenceType>(@noescape transform: [Element] -> S?) -> Trie<S.Generator.Element> {
    var ret = Trie<S.Generator.Element>()
