   public func map<T>(@noescape transform: Element -> T) -> Deque<T> {
     return Deque<T>(
       front: front.map(transform),
-      back: back.map(transform),
-      fCount: fCount, bCount: bCount
+      back: back.map(transform)
     )
   }
 }
 
 extension Deque {
   public func reverse() -> Deque<Element> {
-    return Deque(front: back, back: front, fCount: bCount, bCount: fCount)
+    return Deque(front: back, back: front)
   }
 }
 
 extension Deque {
   public func filter(@noescape includeElement: Element -> Bool) -> Deque<Element> {
-    var (nFCount, nBCount) = (0, 0)
-    let nFront = front.filter { includeElement($0) ? {++nFCount; return true}() : false }
-    let nBack  = back .filter { includeElement($0) ? {++nBCount; return true}() : false }
-    var ret = Deque(front: nFront, back: nBack, fCount: nFCount, bCount: nBCount)
+    var ret = Deque(front: front.filter(includeElement), back: back.filter(includeElement))
     ret.check()
     return ret
   }

    switch front {
    case .Nil: return nil
    case let .Cons(head, tail):
      --fCount
      front = tail
      return head
    }


extension Deque {
  public init(ar: [Element]) {
    let half = ar.endIndex / 2
    front = List(seq: ar[0..<half])
    back  = List(seq: ar[half..<ar.endIndex].reverse())
  }
}

