fmnoise.flow — fmnoise/flow 4.2.2

call clj/s

(call f & args)

Calls given function with supplied args in try/catch block, then calls Catch.caught on caught exception. If no exception has caught during function call returns its result

call-with clj/s

(call-with catch-handler f & args)

Calls given function with supplied args in try/catch block, then calls catch-handler on caught exception. If no exception has caught during function call returns its result

Catch clj/s protocol

caught clj/s

(caught t)

defines how to process caught exception

chain clj/s

(chain v f & fs)

Passes given value through chain of functions. If value is an error or any function in chain returns error, it's returned and rest of chain is skipped

else clj/s

(else f)

(else f value)

If value is an error, applies f to it, otherwise returns value

else-call clj/s

(else-call f)

(else-call f value)

If value is an error, applies f to it wrapped to call, otherwise returns value

else-if clj

(else-if err-class f)

(else-if err-class f value)

If value is an error of err-class (or any of its parents), applies f to it, otherwise returns value

ex-info! clj/s

(ex-info! & args)

Functional wrapper for creating and throwing ex-info

fail-with clj/s≠

clj

(fail-with {:keys [msg data cause suppress? trace?]
            :or {data {} suppress? false trace? false}
            :as options})

Constructs Fail with given options. Stacktrace is disabled by default

cljs

(fail-with {:keys [msg data cause] :or {data {}} :as options})

Constructs ex-info with given options

fail-with! clj/s≠

clj

(fail-with!
  {:keys [msg data cause suppress? trace?] :or {trace? true} :as options})

Constructs Fail with given options and throws it. Stacktrace is enabled by default. See fail-with for more details

cljs

(fail-with! {:keys [msg data cause] :as options})

Constructs ex-info with given options and throws it. See fail-with for more details

fail? clj/s

(fail? t)

Checks if given value is considered as failure

flet clj macro

(flet bindings & body)

Flow adaptation of Clojure let. Wraps evaluation of each binding to try/catch and handles all thrown exceptions with Catch.caught. If value returned from binding evaluation is failure, it's returned immediately and all other bindings and body are skipped.

Flow clj/s protocol

?err clj/s

(?err this f)

if value is an error, apply f to it, otherwise return value

?ok clj/s

(?ok this f)

if value is not an error, apply f to it, otherwise return value

?throw clj/s

(?throw this)

if value is an error, throw it, otherwise return value

handle clj/s deprecated

switch clj/s

(switch opts)

(switch {:keys [ok err] :or {ok identity err identity}} value)

Accepts map with :ok, :err keys and a value. If value is an error, runs :err on it, else runs :ok. Both keys default to identity

then clj/s

(then f)

(then f value)

If value is not an error, applies f to it, otherwise returns value

then-call clj/s

(then-call f)

(then-call f value)

If value is not an error, applies f to it wrapped to call, otherwise returns value

thru clj/s

(thru f)

(thru f value)

Applies f to value (for side effects). Returns value. Works similar to doto, but accepts function as first arg

thru-call clj/s

(thru-call f)

(thru-call f value)

Applies f to value wrapped to call (for side effects). Returns value. Works similar to doto, but accepts function as first arg. Please not that exception thrown inside of function will be silently ignored by default