active.clojure.monad — de.active-group/active-clojure 0.30.0

Monad related functionality, particularly free monads.

and-finally clj/s

(and-finally m final-m)

Execute m, and always final-m, no matter if an exception occurs or not.

Bind cljs

bind-except clj/s

(bind-except m handler f)

Evaluate m, and if an exception occurs continue with (handler exception), otherwise with (f value-of-m). Note that neither the handler result is to f, nor exceptions are caught in f.

combine-monad-command-configs clj/s

(combine-monad-command-configs & mccs)

Combine a sequence of monad-command configs into one. The earlier entries have precedence.

execute-free-reader-state-exception clj/s

(execute-free-reader-state-exception command-config m & [state])

Run monadic computation in a reader-state-exception monad, turning exceptions into Clojure exceptions.

• command-config is the configuration object for running commands
• m is the computation to run
• state is an optional initial state (from a previous run)

Returns [result state].

free-bind clj/s

(free-bind mv f)

Bind/flatMap for the free monad.

free-bind-cont clj/s

(free-bind-cont Bind)

Lens for the cont field from a Bind record. See active.clojure.monad/make-free-bind.

free-bind-monad clj/s

(free-bind-monad Bind)

Lens for the monad field from a Bind record. See active.clojure.monad/make-free-bind.

free-bind? clj/s

(free-bind? thing)

Is object a Bind record? See active.clojure.monad/make-free-bind.

get-env-component clj/s

(get-env-component name)

Retrieve a named component of a map-valued environment.

get-state-component clj/s

(get-state-component name)

Retrieve a named component of a map-valued state.

make-free-bind clj/s

(make-free-bind monad cont)

Construct a Bind record.

monad: access via active.clojure.monad/free-bind-monad cont: access via active.clojure.monad/free-bind-cont

make-monad-command-config clj/s

(make-monad-command-config run-command env state)

Construct a MonadCommandConfig (Configuration for supporting a set of monad commands.) record.

run-command: access via active.clojure.monad/monad-command-config-run-command env: access via active.clojure.monad/monad-command-config-env state: access via active.clojure.monad/monad-command-config-state

monad-command-config-env clj/s

(monad-command-config-env MonadCommandConfig)

reader-monad initial environment represented as a mergable map

monad-command-config-run-command clj/s

(monad-command-config-run-command MonadCommandConfig)

run-command :: run-any env state comp -> (| [(| exception-value? val) state] unknown-command) Where run-any is a function for running any monad command of the signature `env state comp -> (| [(| exception-value? val) state] unknown-command)

monad-command-config-state clj/s

(monad-command-config-state MonadCommandConfig)

state-monad initial state represented as a mergable map

monad-command-config? clj/s

(monad-command-config? thing)

Is object a MonadCommandConfig record? See active.clojure.monad/make-monad-command-config.

MonadCommandConfig cljs

Configuration for supporting a set of monad commands.

monadic clj/s macro

(monadic & ?stmts)

Construct a monadic computation.

The syntax is (monadic <stmt> ...) where <stmt> is one of the following:

• [<pat> <exp> ...] which creates monadic bindings
• (let <bindings>) which creates regular bindings
• anything else is just a regular expression, expected to yield a monadic value.

Example:

(monadic [first (ask "what's your first name?")
          last (ask "what's your last name?")]
         (let [s (str "Hello, " first " " last)])
         (tell s))

null-monad-command-config clj/s

(null-monad-command-config env state)

Monad command-configuration with no commands except for reader/state/exception.

put-state-component! clj/s

(put-state-component! name value)

Set a named component of a map-valued state.

reified? clj/s

(reified? m)

Checks whether a monadic command is reified.

reify-as clj/s

(reify-as m reification)

Adds reification meta data to m that helps utilities (like the mock runner for tests), to reify a composed command as something comparable (and printable), for cases where the command itself is not; e.g. it includes a bind inside. See [[reify-command]] to extract the meta data again.

reify-command clj/s

(reify-command m)

Return the reification object of m, if one was added with [[reify-as]], or m itself otherwise.

return clj/s

run-free-reader-state-exception clj/s

(run-free-reader-state-exception command-config m & [state])

Run monadic computation in a reader-state-exception monad.

• command-config is the configuration object for running commands
• m is the computation to run
• state an optional initial state (from a previous run) that is merged into the one from command-config

Returns [result state]

run-no-commands clj/s

(run-no-commands run-any env state m)

For use in make-monad-command-config when there are no commands.

sequ clj/s

(sequ ms)

Evaluate each action in the sequence from left to right, and collect the results.

sequ_ clj/s

(sequ_ ms)

Evaluate each action in the sequence from left to right, and ignore the results.

throw-illegal-argument-exception clj/s

(throw-illegal-argument-exception msg)

unknown-command clj/s

Marker that command functions can return to signal they don't recognize a command.

update-state-component! clj/s

(update-state-component! name f & args)

Calls f with the current value of the component and puts back return value as the new component.

with-env-component clj/s

(with-env-component key f m)

Transform a keyed component of a map-valued environment.