failjure.core — failjure 2.0.0

assert-nil? clj/s

assert-not-empty? clj/s

assert-not-nil? clj/s

assert-number? clj/s

assert-some? clj/s

assert-with clj/s

(assert-with pred v msg)

If (pred v) is true, return v otherwise, return (f/fail msg)

attempt-> clj/s macro

(attempt-> start)

(attempt-> start form)

(attempt-> start form & forms)

Deprecated. Use ok-> instead.

attempt->> clj/s macro

(attempt->> start)

(attempt->> start form)

(attempt->> start form & forms)

Deprecated. Use ok->> instead.

attempt-all clj/s macro

(attempt-all bindings return)

(attempt-all bindings return else)

Used like let, but short-circuits in case of a failed binding. Can be used in combination with when-failed to handle the failure.

Unlike let, only accepts a single form to execute after the bindings.

(attempt-all [x "Ok" y (fail "Fail")] x (when-failed [e] (message e))) ; => "Fail"

else* clj/s

(else* else-part result)

fail clj/s

(fail msg)

(fail msg & fmt-parts)

Failure cljs

HasFailed clj/s≠ protocol

failed? clj/s

(failed? self)

message clj/s

(message self)

if-failed clj/s macro deprecated

(if-failed arglist & body)

DEPRECATED: Use when-failed instead

if-let-failed? clj/s macro

(if-let-failed? [v-sym form] failed-branch)

(if-let-failed? [v-sym form] failed-branch ok-branch)

Inverse of if-let-ok?

(if-let-failed? [v (some-fn)] (prn "V Failed!") (prn "V is OK!"))

If called with 1 branch, returns the value in case of non-failure:

(if-let-failed? [v "Hello"] (prn "V Failed!")) ;; => returns "Hello"

if-let-ok? clj/s macro

(if-let-ok? [v-sym form] ok-branch)

(if-let-ok? [v-sym form] ok-branch failed-branch)

Binding convenience.

Acts just like let for non-failing values:

(if-let-ok? [v (something-which-may-fail)] (do-something-else v) (do-something-on-failure v))

Note that the value of v is the result of something-which-may-fail in either case. If no else branch is provided, nil is returned:

(if-let-ok? [v (fail "Goodbye")] "Hello") ;; Returns #failjure.core.Failure{:message "Goodbye"}

Note that the above is identical in function to simply calling (fail "Goodbye")

ok-> clj/s macro

(ok-> start & forms)

Like some->, but with ok? instead of some? (i.e., short-circuits when it encounters a failure)

ok->> clj/s macro

(ok->> start & forms)

Like some->>, but with ok? instead of some? (i.e., short-circuits when it encounters a failure)

ok? clj/s

(ok? v)

try* clj/s macro

(try* & body)

try-all clj/s macro

(try-all bindings return)

(try-all bindings return else)

Similar to attempt-all but catches possible exceptions.

Wraps each arm of the binding in a try* to treat them as Failures and short circuit.

try-fn clj/s

(try-fn body-fn)

when-failed clj/s macro

(when-failed arglist & body)

Use in combination with attempt-all. If any binding in attempt-all failed, run the body given the failure/error as an argument.

Usage:

(attempt-all [_ (fail "Failure")] ; do something (when-failed [e] (print "ERROR:" (message e))))

when-let-failed? clj/s macro

(when-let-failed? [v-sym form] & failed-branches)

Inverse of when-let-ok?

(when-let-faild? [v (some-fn)] (prn "FAILED") (handle-failure v))

Returns the value in case of non-failure

when-let-ok? clj/s macro

(when-let-ok? [v-sym form] & ok-branches)

Analogous to if-let-ok? and when-let.

(when-let-ok? [v (some-fn)] (prn "WAS OK") (do-something v))

Returns the error in case of failure