arrudeia.core — pfeodrippe/arrudeia 0.10.0

*bypass* clj

*proc-name* clj

*result-modifiers* clj

->* clj macro

(->* & forms)

->*-reader clj

(->*-reader form)

ArrudeiaProcess clj

build-thread-first-macro-body clj

(build-thread-first-macro-body ->-macro & forms)

cancel-remaining-steps clj

(cancel-remaining-steps procs)

debug! clj

(debug! v)

disable-macros? clj

done-step clj

(done-step args [proc-name keyword idx])

exceptions clj

find-cancelled-indexes clj

(find-cancelled-indexes steps)

Find indexes which should have the execution cancelled (last step of a proc).

label clj macro deprecated

(label {:keys [:identifier :idx]} & body)

Use with-label instead.

parse-process-names clj

(parse-process-names process-name->process process-with-steps)

register clj macro

(register proc-name pipe & [{:keys [:result-modifiers]}])

run-processes! clj

(run-processes! steps)

(run-processes! steps {:keys [:step-handler]})

Returns a map of steps with their returned values. :step-handler is a function which receives a map with :idx, :proc, :step and :response, which is just the step response.

run-step clj

(run-step proc-with-step)

(run-step [{:keys [:proc-name :proc]} step]
          {:keys [:run-intermediate-steps? :step-opts]
           :or {run-intermediate-steps? true}})

semaphore clj

thread-first-macro-builder clj macro

(thread-first-macro-builder name ->-macro)

Yes, a macro that creates another macro. It should be useful when you have some thread first macro from some of your dependencies (e.g. cats.core/->=) and you would like to use arrudeia.

It also creates a new data reader so you could use it with a tagged literal.

valid-interleavings clj

(valid-interleavings & processes-with-steps)

It returns all valid interleavings for processes with their steps.

For the example below, see that, for any interleaving, :step2 never comes before of :step1 and :step3 never appears before :step2. The order passed at input is respected at interleavings so you always have valid steps (we trust you to pass it correctly).

Usage example: (valid-interleavings [[:t1 :step1] [:t1 :step2] [:t1 :step3]] [[:t2 :other-step-1] [:t2 :other-step-2]]) => [... ;; other interleavings [[:t1 :step1] [:t2 :other-step-1] [:t1 :step2] [:t1 :step3] [:t2 :other-step-2]] ...] ;; other interleavings

var->keyword clj

(var->keyword v)

waiting-step clj

(waiting-step [proc-name keyword idx])

(waiting-step args [proc-name keyword idx])

with-bypass clj macro

(with-bypass & body)

with-label clj macro

(with-label opts & body)

opts can be a map (with :identifier and/or :idx) or a keyword as the identifier.

The return is unmodified and will not modify the execution in any way if you don't ask (see arrudeia.core/register).

Disable it in production so it does not create unnecessary code with the environment variable ARRUDEIA_DISABLE_MACROS=1.

E.g. (ar/with-label ::check-funds (when (< money (@balances sender)) args))

without-bypass clj macro

(without-bypass & body)