zpst.repl — zpst 0.1.4

*locals* clj

break clj/s macro

(break id)

(break id input-map)

Stop and interact with the console when you hit this macro. Should have all of the local lexical context around. Type () to exit and continue execution.

eval-in-ns clj

(eval-in-ns n outerbody)

Evaluate the outerbody argument in namespace n.

eval-with-locals clj

(eval-with-locals locals form)

Take a map of locals and their values, and eval an expression within that context.

eval-with-locals-return clj

(eval-with-locals-return locals form)

Take a map of locals and their values, and eval an expression within that context. Allow the evaluated expression to affect the return.

local-context clj/s macro

(local-context)

local-names clj

locals clj

(locals)

(locals length)

(locals length depth)

Print the local-context, embodied in locals,, one per line, with an optional depth and length. Don't print a local with the name return-var.

make-last clj

(make-last m key-seq)

Given a map and a set of keys, return a seq of the map with the elements of the map (if any) that match the keys last. The order of the elements that match the keys will be the same as the order of the keys in key-seq.

mpst clj

(mpst e depth)

(mpst e depth lvl)

Prints a stack trace of the exception, to the depth requested. If none supplied, uses the root cause of the most recent repl exception (*e), and a depth of 12.

mpstg clj

(mpstg e depth)

(mpstg e depth lvl)

Prints a stack trace of the exception, to the depth requested. If none supplied, uses the root cause of the most recent repl exception (*e), and a depth of 12.

p clj

(p expr)

(p expr length)

(p expr length depth)

Pretty-print to stdout to a length and depth, end with newline.

p* clj

(p* coll)

(p* coll length)

(p* coll length depth)

Pretty-print to stdout a length and depth. Do not end with newline.

p-str clj

(p-str & rest)

Pretty-print into a string, to a length and depth and finish without a newline.

pred-by-map clj

(pred-by-map key-map x y)

Takes a map and two arguments, and returns true if
the value of x in the map is less than the value of y in the map.

print-stacktrace-array clj

(print-stacktrace-array st)

Given an array of stacktrace elements, print it (eliding some of the hooking stuff).

print-wrap clj

(print-wrap form)

Can't use debugging in here, well, so print stuff out!

readr clj

(readr request-prompt exit-code)

(readr fnmap request-prompt exit-code)

Read and return a value to the repl. fnmap is a map of input symbols to functions to execute.

repl clj/s macro

(repl context-map id input-map)

Interact with the console when you hit this macro. Context for the repl comes from the context map. Type () to exit and continue execution.

return-set clj

(return-set val)

Set the return value of a dbreak at the done call. Actually sets return-var, but you don't see that because of collaboration of locals and eval-with-locals-return.

run clj/s macro

(run)

Take a list of local names and a function name, and do it.

sconcat-alt clj

(sconcat-alt x y)

Concatentate two stacks together (which are actually arrays).

split-seq-with clj

(split-seq-with pred coll)

Take a coll, and return a vector of
[(filter pred coll) (filter #(not (pred %)) coll)].

split-sort clj

(split-sort pair-seq key-seq)

Takes a sequence of key-value vector pairs (e.g., seq of a map) or map itself, and a seq of keys. Produces a vector with two items as output. First, the sequence without any of the pairs that match the keys from the list. Second, a sequence of the key-value pairs where the keys match the list of keys input, and appear in the sequence in the same order as the input sequence of keys.

test-bug clj

(test-bug a b c)

If called with c = 8, it will throw an exception.

test-deep clj

(test-deep [arg0 arg1 arg2])

A function on the way down.

test-fn clj

(test-fn stuff)

A multithreaded function to use for testing zpst.

test-fn-alt clj

(test-fn-alt stuff)

A multithreaded function to use for testing zpst.

test-fn-s clj

(test-fn-s stuff)

A multithreaded function to use for testing zpst.

test-fn-t clj

(test-fn-t stuff)

A multithreaded function to use for testing zpst.

with-ns clj/s macro

(with-ns ns & body)

Evaluates body in another namespace. ns is either a namespace object or a symbol. This makes it possible to define functions in namespaces other than the current one. Modification of old contrib fn by Stuart Sierra which allows body to reference symbols in the calling namespace. Without this modification, the following will define, but not run correctly: (defn printns [n x] (with-ns n (println x)))