 
 public struct Map<Key: Comparable, Value>: SortedAssociativeCollectionType {
     // Typealiases
+    internal typealias Tree = BTree<Key, Value>
 
-    internal typealias Summary = EmptySummary<Key>
-    internal typealias TreeKey = StoredKey<Summary>
-    internal typealias Tree = RedBlackTree<TreeKey, Value>
-    internal typealias Handle = Tree.Handle
-
-    public typealias Index = MapIndex<Key, Value>
+    public typealias Index = TreeIndex<Key, Value>
     public typealias Generator = MapGenerator<Key, Value>
     public typealias Element = (Key, Value)
 

    // Methods

    public func generate() -> Generator {
        return Generator(tree: tree)
    }

    public func indexForKey(key: Key) -> Index? {
        guard let handle = tree.find(TreeKey(key)) else { return nil }
        return Index(tree: tree, handle: handle)
    }

    // Mutators

    public mutating func reserveCapacity(minimumCapacity: Int) {
        tree.reserveCapacity(minimumCapacity)
    }

    public mutating func updateValue(value: Value, forKey key: Key) -> Value? {
        return tree.setPayloadOf(TreeKey(key), to: value).1
    }

    public mutating func removeAtIndex(index: Index) -> (Key, Value) {
        let handle = index.handle!
        let key = tree.headAt(handle)
        let value = tree.remove(handle)
        return (key, value)
    }

    public mutating func removeValueForKey(key: Key) -> Value? {
        guard let handle = tree.find(TreeKey(key)) else { return nil }
        return tree.remove(handle)
    }

    public mutating func removeAll() {

    internal private(set) var tree: Tree

    // Initalizer 
    public init() {
        self.tree = Tree()
    }

    // Properties
    public var startIndex: Index {
        return tree.startIndex
    }

    public var endIndex: Index {
        return tree.endIndex
    }

    public var count: Int {
