     public typealias Parameters = [String: String]
     public typealias Completed = () -> Void
     
-    private enum RouteType {
-        case Proxy((String) -> (ProxyHandler?, Parameters))
-        case Route((String) -> (RouteHandler?, Parameters))
-    }
-    
     private var accessQueue: dispatch_queue_t!
     private var routingQueue: dispatch_queue_t!
     private var callbackQueue: dispatch_queue_t!
-    private var routes: [RouteType] = [RouteType]()
+    private typealias Proxy = (String) -> (ProxyHandler?, Parameters)
+    private var proxies: [Proxy] = [Proxy]()
+    private typealias Route = (String) -> (RouteHandler?, Parameters)
+    private var routes: [Route] = [Route]()
     
     public init(accessQueue: dispatch_queue_t = dispatch_queue_create("Routing Access Queue", DISPATCH_QUEUE_CONCURRENT),
         routingQueue: dispatch_queue_t = dispatch_queue_create("Routing Queue", DISPATCH_QUEUE_SERIAL),

        return false
    }
    
    private func process(var path: String, var parameters: [String: String], var route: (RouteHandler, Parameters), routes: [RouteType]) {
        dispatch_async(routingQueue) {
            let semaphore = dispatch_semaphore_create(0)
            // TODO: allow proxy to abort
            routes  /* Proxies */
                .map { closure -> (ProxyHandler?, Parameters) in
                    if case let .Proxy(f) = closure { return f(path) }
                    else { return (nil, [String : String]())}
                }
                .filter { $0.0 != nil }
                .map { ($0!, $1) }
                .forEach { (h, var p) in

            }

            let proxiedRoute = routes
                .map { $0(path) }
                .filter { $0.0 != nil }
                .first
                .map { ($0!, $1) }
