active.clojure.monad — active-clojure 0.25.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.

exception-value-exception clj/s

(exception-value-exception ExceptionValue)

Access exception field from a [[ExceptionValue]] record. See active.clojure.monad/make-exception-value.

exception-value? clj/s

(exception-value? thing)

Is object a ExceptionValue record? See active.clojure.monad/make-exception-value.

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)

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

free-bind-monad clj/s

(free-bind-monad Bind)

Access 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.

free-return clj/s

(free-return val)

Construct a Return record.

val: access via active.clojure.monad/free-return-val

free-return-val clj/s

(free-return-val Return)

Access val field from a [[Return]] record. See active.clojure.monad/free-return.

free-return? clj/s

(free-return? thing)

Is object a Return record? See active.clojure.monad/free-return.

free-throw clj/s

(free-throw exception)

Construct a Throw record.

exception: access via active.clojure.monad/free-throw-exception

free-throw-exception clj/s

(free-throw-exception Throw)

Access exception field from a [[Throw]] record. See active.clojure.monad/free-throw.

free-throw? clj/s

(free-throw? thing)

Is object a Throw record? See active.clojure.monad/free-throw.

get-env clj/s

(get-env)

Construct a GetEnv record.

get-env-component clj/s

(get-env-component name)

Retrieve a named component of a map-valued environment.

get-env? clj/s

(get-env? thing)

Is object a GetEnv record? See active.clojure.monad/get-env.

get-state clj/s

(get-state)

Construct a GetState record.

get-state-component clj/s

(get-state-component name)

Retrieve a named component of a map-valued state.

get-state? clj/s

(get-state? thing)

Is object a GetState record? See active.clojure.monad/get-state.

make-exception-value clj/s

(make-exception-value exception)

Construct a ExceptionValue record.

exception: access via active.clojure.monad/exception-value-exception

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 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

make-unknown-command clj/s

(make-unknown-command)

Construct a UnknownCommand record.

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

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))

monadic-1 clj/s macro

(monadic-1 ?meta & ?stmts)

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! clj/s

(put-state! state)

Construct a PutState record.

state: access via active.clojure.monad/put-state-state

put-state!? clj/s

(put-state!? thing)

Is object a PutState record? See active.clojure.monad/put-state!.

put-state-component! clj/s

(put-state-component! name value)

Set a named component of a map-valued state.

put-state-state clj/s

(put-state-state PutState)

Access state field from a [[PutState]] record. See active.clojure.monad/put-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.

unknown-command? clj/s

(unknown-command? thing)

Is object a UnknownCommand record? See active.clojure.monad/make-unknown-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 clj/s

(with-env trans body)

Construct a WithEnv record.

trans: access via active.clojure.monad/with-env-trans body: access via active.clojure.monad/with-env-body

with-env-body clj/s

(with-env-body WithEnv)

Access body field from a [[WithEnv]] record. See active.clojure.monad/with-env.

with-env-component clj/s

(with-env-component key f m)

Transform a keyed component of a map-valued environment.

with-env-trans clj/s

(with-env-trans WithEnv)

Access trans field from a [[WithEnv]] record. See active.clojure.monad/with-env.

with-env? clj/s

(with-env? thing)

Is object a WithEnv record? See active.clojure.monad/with-env.

with-handler clj/s

(with-handler handler body)

Construct a WithHandler record.

handler: access via active.clojure.monad/with-handler-handler body: access via active.clojure.monad/with-handler-body

with-handler-body clj/s

(with-handler-body WithHandler)

Access body field from a [[WithHandler]] record. See active.clojure.monad/with-handler.

with-handler-handler clj/s

(with-handler-handler WithHandler)

Access handler field from a [[WithHandler]] record. See active.clojure.monad/with-handler.

with-handler? clj/s

(with-handler? thing)

Is object a WithHandler record? See active.clojure.monad/with-handler.