         actions[method] = action
     }
 
-    static var defaultFallback: Action {
-        return Action(
-            responder: Responder { _ in Response(status: .MethodNotAllowed) }
-        )
-    }
-}
+    static let defaultFallback = Action { _ in
+        Response(status: .MethodNotAllowed)
+    }
+}

            }
        }
    }
}

extension RouterBuilder {
    public var fallback: ResponderType {
        get {
            return Responder(respond: fallbackAction.respond)
        }

        set {
            self.fallbackAction = Action(
                responder: Responder { _ in Response(status: .NotFound) }
            )
        }
    }

    public func fallback(middleware middleware: MiddlewareType..., respond: Respond) {
        fallback(middleware, responder: Responder(respond: respond))
    }

    public func fallback(middleware middleware: MiddlewareType..., responder: ResponderType) {
        fallback(middleware, responder: responder)
    }

    private func fallback(middleware: [MiddlewareType], responder: ResponderType) {

}

extension RouterBuilder {
    public func get(path: String, middleware: MiddlewareType..., responder: ResponderType) {
        get(path, middleware: middleware, responder: responder)
    }

    public func get(path: String, _ responder: ResponderType) {
        get(path, responder: responder)
    }

    public func get(path: String, middleware: MiddlewareType..., respond: Respond) {
        get(path, middleware: middleware, responder: Responder(respond))
    }

    public func get(path: String, _ respond: Respond) {
        get(path, respond: respond)
    }

    private func get(path: String, middleware: [MiddlewareType], responder: ResponderType) {
        addRoute(method: .GET, path: path, middleware: middleware, responder: responder)
    }
}

extension RouterBuilder {
    public func post(path: String, middleware: MiddlewareType..., responder: ResponderType) {
        post(path, middleware: middleware, responder: responder)
    }

    public func post(path: String, _ responder: ResponderType) {
        post(path, responder: responder)
    }

    public func post(path: String, middleware: MiddlewareType..., respond: Respond) {
        post(path, middleware: middleware, responder: Responder(respond))
    }

    public func post(path: String, _ respond: Respond) {
        post(path, respond: respond)
    }

    private func post(path: String, middleware: [MiddlewareType], responder: ResponderType) {
        addRoute(method: .POST, path: path, middleware: middleware, responder: responder)
    }
}

extension RouterBuilder {
    public func put(path: String, middleware: MiddlewareType..., responder: ResponderType) {
        put(path, middleware: middleware, responder: responder)
    }

    public func put(path: String, _ responder: ResponderType) {
        put(path, responder: responder)
    }

    public func put(path: String, middleware: MiddlewareType..., respond: Respond) {
        put(path, middleware: middleware, responder: Responder(respond))
    }

    public func put(path: String, _ respond: Respond) {
        put(path, respond: respond)
    }

    private func put(path: String, middleware: [MiddlewareType], responder: ResponderType) {
        addRoute(method: .PUT, path: path, middleware: middleware, responder: responder)
    }
}

extension RouterBuilder {
    public func patch(path: String, middleware: MiddlewareType..., responder: ResponderType) {
        patch(path, middleware: middleware, responder: responder)
    }

    public func patch(path: String, _ responder: ResponderType) {
        patch(path, responder: responder)
    }

    public func patch(path: String, middleware: MiddlewareType..., respond: Respond) {
        patch(path, middleware: middleware, responder: Responder(respond))
    }

    public func patch(path: String, _ respond: Respond) {
        patch(path, respond: respond)
    }

    private func patch(path: String, middleware: [MiddlewareType], responder: ResponderType) {
        addRoute(method: .PATCH, path: path, middleware: middleware, responder: responder)
    }
}

extension RouterBuilder {
    public func delete(path: String, middleware: MiddlewareType..., responder: ResponderType) {
        delete(path, middleware: middleware, responder: responder)
    }

    public func delete(path: String, _ responder: ResponderType) {
        delete(path, responder: responder)
    }

    public func delete(path: String, middleware: MiddlewareType..., respond: Respond) {
        delete(path, middleware: middleware, responder: Responder(respond))
    }

    public func delete(path: String, _ respond: Respond) {
        delete(path, respond: respond)
    }

    private func delete(path: String, middleware: [MiddlewareType], responder: ResponderType) {
        addRoute(method: .DELETE, path: path, middleware: middleware, responder: responder)
    }
}

extension RouterBuilder {
    public func methods(methods: Set<Method>, path: String, middleware: MiddlewareType..., responder: ResponderType) {
        for method in methods {
            addRoute(method: method, path: path, middleware: middleware, responder: responder)
        }
    }

    public func methods(m: Set<Method>, _ path: String, _ responder: ResponderType) {
        methods(m, path: path, responder: responder)
    }

    public func methods(methods: Set<Method>, path: String, middleware: MiddlewareType..., respond: Respond) {
        for method in methods {
            addRoute(method: method, path: path, middleware: middleware, responder: Responder(respond))
        }
    }

    public func methods(m: Set<Method>, _ path: String, _ respond: Respond) {
        methods(m, path: path, respond: respond)
    }
}

extension RouterBuilder {
    public func fallback(path: String, middleware: MiddlewareType..., responder: ResponderType) {
        addRouteFallback(path: path, middleware: middleware, responder: responder)
    }

    public func fallback(path: String, _ responder: ResponderType) {
        fallback(path, responder: responder)
    }

    public func fallback(path: String, middleware: MiddlewareType..., respond: Respond) {
        addRouteFallback(path: path, middleware: middleware, responder: Responder(respond))
    }

    public func fallback(path: String, _ respond: Respond) {
        fallback(path, respond: respond)
    }
}

extension RouterBuilder {
    private func addRouteFallback(path path: String, middleware: [MiddlewareType], responder: ResponderType) {
        let fallback = Action(middleware: middleware, responder: responder)
        let routePath = self.path + path

        if let route = routeFor(routePath) {
            route.fallback = fallback
        } else {
            let route = Route(path: path, fallback: fallback)
            routes.append(route)
        }
    }

    private func addRoute(method method: Method, path: String, middleware: [MiddlewareType], responder: ResponderType) {
        let action = Action(middleware: middleware, responder: responder)
        let routePath = self.path + path

        if let route = routeFor(routePath) {
            route.addAction(method: method, action: action)
        } else {
            let route = Route(path: path, actions: [method: action])
            routes.append(route)
        }
    }

