   nil is converted to false."
   [result]
   (let [ch (chan 1)]
-    (>!! ch (or result false))
+    (put! ch (or result false))
     ch))
 
 (defn ring-handler->async-handler
-  "Wraps a syncronous Ring handler function as an asynchrounous handler. The handler is invoked in another
+  "Wraps a syncronous Ring handler function as an asynchronous handler. The handler is invoked in another
    thread, and a nil response is converted to false."
   [handler]
   (fn [request]
     (safe-thread request (handler request))))
+
+(defn- routing*
+  [request response-ch handlers]
+  (if (empty? handlers)
+    ;; Resolve to false when running out of handlers.
+    (put! response-ch false)
+    ;; Otherwise, see if the first handler will return a truthy value
+    (take! (safety-first request ((first handlers) request))
+           (fn [handler-response]
+             (if handler-response
+               (put! response-ch handler-response)
+               (routing* request response-ch (rest handlers)))))))
 
 (defn routing
   "Routes a request to sequence of async handlers. Each handler should return a channel
   that contains either a Ring response map or false (nil is not an allowed value over a channel). Handlers
   are typically implemented using core.async go or thread blocks."
   [request & handlers]
-  (safe-go request
-    (loop [[handler & more] handlers]
-      (if handler
-        ;; Invoke the handler asynchronously and park until it responds.
-        (let [result-ch (handler request)
-              result (<! result-ch)]
-          ;; Again, a result of false means "continue the search".
-          (if-not (false? result)
-            result
-            (recur more)))
-        ;; And since there was no match yet, we signal to continue the search.
-        false))))
+  (let [response-ch (chan 1)]
+    (routing* request response-ch handlers)
+    response-ch))
 
 (defn routes
   "Creates an async handler that routes to a number of other async handlers."

   (let [options' (session/session-options options)]
     (fn [request]
       (safe-go request
         (let [request' (session/session-request request options')]
           (->
             (handler request')
             <!
             (session/session-response request' options'))))))))
  can be obtained without blocking."
  (:import (javax.servlet.http HttpServletResponse))
  (:require
    [clojure.core.async :refer [chan go >! <! <!! >!! thread put! take!]]
    [clojure.tools.logging :as l]
    [clout.core :as clout]
    [ring.middleware
