fmnoise.flow — fmnoise/flow 4.2.0-pre4

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≠

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

clj

Constructs Fail with given options and throws it. Stacktrace is enabled by default.

cljs

Constructs ex-info with given options and throws it. Stacktrace is enabled by default.

fail? clj/s

(fail? t)

Checks if given value is considered as failure

flet clj/s macro

(flet bindings & body)

Flow adaptation of Clojure let. Wraps evaluation of each binding to call-with with default handler (defined 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

(handle opts)

(handle {: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

select clj/s

(select f coll)

(select f fallback-f coll)

Processes given collection with given function and returns first non-failure result. If all results are failures, returns nil. Accepts optional 2nd argument with function which will be called on processed collection when no non-failure result was returned. Always returns nil when collection is empty.

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