sci.core — org.replikativ/sci 0.15.59-replikativ.1

The main SCI API namespace.

*1 clj/s

*2 clj/s

*3 clj/s

*e clj/s

add-class! clj/s

(add-class! ctx class-name class)

Adds class (JVM class or JS object) to ctx as class-name (a symbol). Returns mutated context.

add-import! clj/s

(add-import! ctx ns-name class-name alias)

Adds import of class named by class-name (a symbol) to namespace named by ns-name (a symbol) under alias alias (a symbol). Returns mutated context.

add-js-lib! cljs

(add-js-lib! ctx name-str js-lib)

Add js library to context, so it can be used with require.

add-namespace! clj/s

(add-namespace! ctx ns-name ns-map)

Adds namespace map ns-map named by the symbol ns-name to ctx. Returns mutated context.

all-ns clj/s

(all-ns ctx)

Returns all SCI ns objects in the ctx

alter-var-meta! clj/s

(alter-var-meta! v f & args)

Atomically alter metadata for SCI Var v in its home world, or in the world selected by call-with-context. This is the portable host boundary; ClojureScript's native alter-meta! writes object fields directly.

alter-var-root clj/s

(alter-var-root v f)

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

assert clj/s

SCI var that represents SCI's clojure.core/assert

binding clj/s macro

(binding bindings & body)

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

call-with-context clj/s

(call-with-context ctx f)

Invoke zero-argument host thunk f with ctx selected. Embeddings use this boundary when a stable inherited value must be read or mutated in a particular forked world.

capture-continuation-context clj/s

(capture-continuation-context)

(capture-continuation-context ctx)

Capture the active SCI context and dynamic bindings for later continuation resumption. Must be called from managed SCI evaluation. The returned token is opaque; use continuation-context-fn to resume through it.

The explicit ctx arity is for host embedding boundaries invoked through an interpreted function after the top-level evaluation has returned.

continuation-context-fn clj/s

(continuation-context-fn continuation-context f)

Return a function that invokes f with the SCI world and dynamic bindings represented by continuation-context.

copy-ns clj/s macro

(copy-ns ns-sym sci-ns)

(copy-ns ns-sym sci-ns opts)

Returns map of names to SCI vars as a result of copying public Clojure vars from ns-sym (a symbol). Attaches sci-ns (result of sci/create-ns) to meta. Copies :name, :macro :doc, :no-doc and :argslists metadata.

Options:

• :exclude: a seqable of names to exclude from the namespace. Defaults to none.

• :copy-meta: a seqable of keywords to copy from the original var meta. Use :all instead of a seqable to copy all. Defaults to [:doc :arglists :macro].

• :exclude-when-meta: seqable of keywords; vars with meta matching these keys are excluded. Defaults to [:no-doc :skip-wiki]

The selection of vars is done at compile time which is mostly important for ClojureScript to not pull in vars into the compiled JS. Any additional vars can be added after the fact with sci/copy-var manually.

copy-var clj/s macro

(copy-var sym ns)

(copy-var sym ns opts)

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

On ClojureScript, when sym names a protocol (except cljs.core/IFn), the sci var holds a protocol entry instead of the raw protocol object. Sci code can then implement the protocol on deftype types, extend those with extend-type and use satisfies?. Host code calling protocol methods on such instances dispatches into the sci implementations.

Options (ignored for protocols):

• :name: The name of the copied var. Defaults to the original var name.
• :copy-meta-from: A symbol resolving to a var whose metadata (:doc, :arglists, :file, :line, :column) is used instead of sym's. Useful for wrapper vars that delegate to another var.

copy-var* clj/s

(copy-var* clojure-var sci-ns)

Copies Clojure var to SCI var. Runtime analog of compile time copy-var.

create-ns clj/s

(create-ns sym)

(create-ns sym meta)

Creates namespace object. Can be used in var metadata.

disable-jit cljs

enable-unrestricted-access! clj/s deprecated

(enable-unrestricted-access!)

Removed. Use the :unrestricted option of init or eval-string instead. Throws when called.

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.

• :allow: a seqable of allowed symbols. All symbols, even those brought in via :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}).

• :ns-aliases: a map of aliases to namespaces that are globally valid, e.g. {'clojure.test 'cljs.test}

• :interrupt-fn: a zero-arg fn called on every interpreted fn entry / loop entry

• :unrestricted: when true, evaluated code may mutate built-in vars and CLJS instance interop skips :classes checks. Off by default. Applies only to this context: a context created during an unrestricted evaluation is sandboxed unless it also gets this option.

• :fork-fn: optional one-argument host function used by fork to copy values held in SCI world cells that do not implement sci.fork/Forkable and need application-specific isolation. SCI-owned mutable primitives are already world-relative and retain identity.

• :runtime-mode: :standard (the default) retains SCI's direct hot paths. :forkable enables isolated runtime worlds for Vars, dynamic bindings and SCI-owned mutable primitives.

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

eval-string* clj/s

(eval-string* ctx s)

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

eval-string+ clj/s

(eval-string+ ctx s)

(eval-string+ ctx s opts)

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

Options: *:ns - the namespace to start evaluation in (defaults to the value of sci/ns)

Returns map with:

• :val - the evaluated value
• :ns - the namespace object

file clj/s

SCI var that represents SCI's clojure.core/*file*

find-ns clj/s

(find-ns ctx ns-sym)

Returns SCI ns object as created with sci/create-ns from ctx found by ns-sym.

fork clj/s

(fork ctx)

(fork ctx opts)

Forks a context (as produced with init) into an isolated runtime world.

Existing SCI Vars and SCI-created mutable primitives retain identity, but their values diverge after the fork. Host values may implement sci.fork/Forkable; opts may contain :fork-fn, which overrides the context's fallback function for other application-specific host values.

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.

normalize-meta clj/s

(normalize-meta m)

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-next+string clj/s

(parse-next+string ctx reader)

(parse-next+string 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-dup clj/s

SCI var that represents SCI's clojure.core/*print-dup*

print-err-fn cljs

SCI var that represents SCI's cljs.core/*print-err-fn*

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-namespace-maps clj/s

SCI var that represents SCI's clojure.core/*print-namespace-maps*

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*

read-eval clj/s

SCI var that represents SCI's clojure.core/*read-eval*

reader clj/s

(reader x)

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

reset-var-meta! clj/s

(reset-var-meta! v m)

Reset metadata for SCI Var v in its home or explicitly selected world.

resolve clj/s

(resolve ctx sym)

retarget-continuation-context clj/s

(retarget-continuation-context continuation-context target-ctx)

Copy a captured continuation context for target-ctx, which must belong to the same SCI lineage. The copy has independent dynamic binding boxes.

set! clj/s

(set! dynamic-var v)

Establish thread local binding of dynamic var

source-reader clj/s

(source-reader x)

stacktrace clj/s

(stacktrace ex)

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

var->symbol clj/s

(var->symbol sci-var)

Returns a fully qualified symbol from a sci.lang.Var

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-detached-context clj/s

(with-detached-context f)

Invoke zero-argument f outside the currently executing SCI context.

Embeddings use this host boundary when interpreted code recursively creates an independent SCI interpreter. The caller's active world and dynamic binding frame are restored even when f throws. Ordinary nested evaluation of an existing context does not need this function.

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.