Middleware.swift

struct Request {}
struct Response {}

enum MiddlewareBeforeResult {
    case Next(Request)
    case Respond(Response)
}

typealias MiddlewareBefore = Request -> MiddlewareBeforeResult
typealias MiddlewareAfter = (Request, Response) -> Response
typealias Responder = Request -> Response

infix operator >>> {
    associativity left
}

func >>>(middlewareA: MiddlewareBefore, middlewareB: MiddlewareBefore) -> MiddlewareBefore {
    return { req in
        switch middlewareA(req) {
        case .Next(let req):
            return middlewareB(req)
        case .Respond(let res):
            return .Respond(res)
        }
    }
}

func >>>(middleware: MiddlewareBefore, responder: Responder) -> Responder {
    return { req in
        switch middleware(req) {
        case .Next(let req):
            return responder(req)
        case .Respond(let res):
            return res
        }
    }
}

func >>>(responder: Responder, middleware: MiddlewareAfter) -> Responder {
    return { req in
        let res = responder(req)
        return middleware(req, res)
    }
}

let before1: MiddlewareBefore = { req in
    print("before1")
    return .Next(req)
}
let before2: MiddlewareBefore = { req in
    print("before2")
    return .Next(req)
}
let respond: Responder = { req in
    print("responder")
    return Response()
}
let after1: MiddlewareAfter = { req, res in
    print("after1")
    return res
}

let after2: MiddlewareAfter = { req, res in
    print("after2")
    return res
}


let route = before1 >>> before2 >>> respond >>> after1 >>> after2

route(Request())

// prints:
//before1
//before2
//responder
//after1
//after2