sci.core — borkdude/sci 0.2.7

*1 clj/s

*2 clj/s

*3 clj/s

*e clj/s

alter-var-root clj/s

(alter-var-root v f & args)

Atomically alters the root binding of sci var v by applying f to its current value plus any args.

binding clj/s macro

(binding bindings & body)

Macro for binding sci vars. Must be called with a vector of sci dynamic vars to values.

copy-var clj/s macro

(copy-var sym ns)

Copies contents from var sym to a new sci var. The value ns is an object created with sci.core/create-ns.

create-ns clj/s

(create-ns sym)

(create-ns sym meta)

Creates namespace object. Can be used in var metadata.

err clj/s

Sci var that represents sci's clojure.core/*err*

eval-form clj/s

(eval-form ctx form)

Evaluates form (as produced by parse-string or parse-next) in the context of ctx (as produced with init). To allow namespace switches, establish root binding of sci/ns with sci/binding or sci/with-bindings.

eval-string clj/s

(eval-string s)

(eval-string s opts)

Evaluates string s as one or multiple Clojure expressions using the Small Clojure Interpreter.

The map opts may contain the following:

• :namespaces: a map of symbols to namespaces, where a namespace is a map with symbols to values, e.g.: {'foo.bar {'x 1}}. These namespaces can be used with require.

• :bindings: :bindings x is the same as :namespaces {'user x}.

• :allow: a seqable of allowed symbols. All symbols, even those brought in via :bindings or :namespaces have to be explicitly enumerated.

• :deny: a seqable of disallowed symbols, e.g.: [loop quote recur].

• :features: when provided a non-empty set of keywords, sci will process reader conditionals using these features (e.g. #{:bb}).

• :env: an atom with a map in which state from the evaluation (defined namespaced and vars) will be persisted for re-use over multiple calls.

• :disable-arity-checks: disables arity checks for single-arity functions.

eval-string* clj/s

(eval-string* ctx s)

Evaluates string s in the context of ctx (as produced with init).

file clj/s

Sci var that represents sci's clojure.core/*file*

fork clj/s

(fork ctx)

Forks a context (as produced with init) into a new context. Any new vars created in the new context won't be visible in the original context.

format-stacktrace clj/s

(format-stacktrace stacktrace)

Returns a list of formatted stack trace elements as strings from stacktrace.

future clj/s macro

(future & body)

Like clojure.core/future but also conveys sci bindings to the thread.

get-column-number clj/s

(get-column-number reader)

get-line-number clj/s

(get-line-number reader)

in clj/s

Sci var that represents sci's clojure.core/*in*

init clj/s

(init opts)

Creates an initial sci context from given options opts. The context can be used with eval-string*. See eval-string for available options. The internal organization of the context is implementation detail and may change in the future.

intern clj/s

(intern ctx sci-ns name)

(intern ctx sci-ns name val)

Finds or creates a sci var named by the symbol name in the namespace ns (which can be a symbol or a sci namespace), setting its root binding to val if supplied. The namespace must exist in the ctx. The sci var will adopt any metadata from the name symbol. Returns the sci var.

merge-opts clj/s

(merge-opts ctx opts)

Updates a context with opts merged in and returns it.

new-dynamic-var clj/s

(new-dynamic-var name)

(new-dynamic-var name init-val)

(new-dynamic-var name init-val meta)

Same as new-var but adds :dynamic true to meta.

new-macro-var clj/s

(new-macro-var name init-val)

(new-macro-var name init-val meta)

Same as new-var but adds :macro true to meta as well as :sci/macro true to meta of the fn itself.

new-var clj/s

(new-var name)

(new-var name init-val)

(new-var name init-val meta)

Returns a new sci var.

ns clj/s

Sci var that represents sci's clojure.core/*ns*

ns-name clj/s

(ns-name sci-ns)

Returns name of SCI ns as symbol.

out clj/s

Sci var that represents sci's clojure.core/*out*

parse-next clj/s

(parse-next ctx reader)

(parse-next ctx reader opts)

Parses next form from reader

parse-string clj/s

(parse-string ctx s)

Parses string s in the context of ctx (as produced with init).

pmap clj

(pmap f coll)

(pmap f coll & colls)

Like clojure.core/pmap but also conveys sci bindings to the threads.

print-fn cljs

Sci var that represents sci's cljs.core/*print-fn*

print-length clj/s

Sci var that represents sci's clojure.core/*print-length*

print-level clj/s

Sci var that represents sci's clojure.core/*print-level*

print-meta clj/s

Sci var that represents sci's clojure.core/*print-meta*

print-newline cljs

Sci var that represents sci's cljs.core/*print-newline*

print-readably clj/s

Sci var that represents sci's clojure.core/*print-readably*

reader clj/s

(reader x)

Coerces x into indexing pushback-reader to be used with parse-next. Accepts: string or java.io.Reader.

set! clj/s

(set! dynamic-var v)

Establish thread local binding of dynamic var

stacktrace clj/s

(stacktrace ex)

Returns list of stacktrace element maps from exception, if available.

with-bindings clj/s macro

(with-bindings bindings-map & body)

Macro for binding sci vars. Must be called with map of sci dynamic vars to values. Used in babashka.

with-in-str clj/s macro

(with-in-str s & body)

Evaluates body in a context in which sci's in is bound to a fresh StringReader initialized with the string s.

with-out-str clj/s macro

(with-out-str & body)

Evaluates exprs in a context in which sci's out is bound to a fresh StringWriter. Returns the string created by any nested printing calls.