convex.clj.eval — world.convex/clojurify.clj 0.0.0-alpha1

Shortcuts for evaluating Convex Lisp code, useful for development and testing.

Takes a form (Clojure data expressing Convex Lisp code) and evaluates to some result returned as Clojure data.

This namespace offers many flavors of how exceptions and results are handled and returned.

Primarily useful for dev and testing.

Given context is always forked, meaning the argument is left intact. See convex.cvm/fork from :project/cvm.

*ctx-default* clj

Holder for a default context which can set whenever suited or dynamically with Clojure's binding.

Nil by default.

See alter-ctx-default.

alter-ctx-default clj

(alter-ctx-default ctx)

Sets the value of ctx-default.

code clj

(code code form)

(code ctx code form)

Like exception but returns an exception only if it matches the given code.

See convex.cell/code-std* from :project/cvm.

code* clj macro

(code* code form)

(code* ctx code form)

Note: if code is a keyword, it is passed to convex.cell/code-std* from :project/cvm.

code? clj

(code? code form)

(code? ctx code form)

Like code but returns a boolean indicating if an exception of the given `code occured.

code?* clj macro

(code?* code form)

(code?* ctx code form)

Note: if code is a keyword, it is passed to convex.cell/code-std* from :project/cvm.

ctx clj

(ctx form)

(ctx ctx form)

Evaluates the given form and returns ctx.

Uses *ctx-default* if ctx is not provided.

ctx* clj macro

(ctx* form)

(ctx* ctx form)

exception clj

(exception form)

(exception ctx form)

Like ctx but returns the current exception or nil if there is none.

exception* clj macro

(exception* form)

(exception* ctx form)

exception? clj

(exception? form)

(exception? ctx form)

Like ctx but returns a boolean indicating if an exception occured.

exception?* clj macro

(exception?* form)

(exception?* ctx form)

like-clojure? clj

(like-clojure? form)

(like-clojure? ctx form)

(like-clojure? form f arg+)

(like-clojure? ctx form f arg+)

Returns true if applying arg+ to form on the CVM produces the exact same result as (apply f arg+)

Alternatively, a unique form can be given for both execution environments. In that case, the form is processed in Clojure via eval.

(like-clojure? '(+ 2 2))

(like-clojure? '+
               +
               [2 2)

like-clojure?* clj macro

(like-clojure?* form)

(like-clojure?* ctx form)

(like-clojure?* form f arg+)

(like-clojure?* ctx form f arg+)

log clj

(log form)

(log ctx form)

Like ctx but returns the context log as Clojure data structure, where the last entry for the executing address is a map containing the given form as well as its return value.

Useful for debugging, akin to using println with Clojure.

log* clj macro

(log* form)

(log* ctx form)

result clj

(result form)

(result ctx form)

Like ctx but returns the result as Clojure data.

result* clj macro

(result* form)

(result* ctx form)

value clj

(value form)

(value ctx form)

Like ctx but returns either an exception or a result.

value* clj macro

(value* form)

(value* ctx form)