 
 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)
 

    // Subscripts

    public subscript(index: Index) -> Element {
        let (key, payload) = tree.elementAt(index.handle!)
        return (key.head, payload)
    }

    public subscript(key: Key) -> Value? {
        get {
            guard let handle = tree.find(TreeKey(key)) else { return nil }
            return tree.payloadAt(handle)
        }
        set(value) {
            if let value = value {
                tree.setPayloadOf(TreeKey(key), to: value)
            }
            else if let handle = tree.find(TreeKey(key)) {
                tree.remove(handle)
            }
        }
    }

    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 {
