         (go-loop []
             (let [value (<! channel)]
                 (when not-nil? value
-                    (go-loop [unflattened (f value)]
-                        (let [inner-value (<! unflattened)]
-                            (when (not-nil? inner-value)
-                                (>! return inner-value)
-                                (recur unflattened))))
+                    (pipe (f value) return)
                     (recur))))
         return))
 
 (def new-provider!
     (let [provider (atom nil)]
-        (fn yosup [ ]
+        (fn [ ]
             (when @provider
                 (doto @provider
                     (.reset)

        return))

(defn keypress-channel! [key-change]
    (let [old-keys (new-keys!)]
        (try
            (let [keys (new-keys! key-change)

            @provider)))

(def new-keys!
    (let [keys (atom DEFAULT_KEYS)]
        (fn ([] @keys)
            ([key-update]
                (swap! keys #(merge % key-update))))))

(defn register-keys [^Provider provider keys]
    (let [return (chan)]
