memory-whole.core — net.clojars.escherize/memory-whole 0.1.5

balanced-to-idx clj

(balanced-to-idx s)

deftrace clj macro

(deftrace name & definition)

Use in place of defn; traces each call/return of this fn, including arguments. Nested calls to deftrace'd functions will print a tree-like structure. The first argument of the form definition can be a doc string

dotrace clj macro

(dotrace fnames & exprs)

Given a sequence of function identifiers, evaluate the body expressions in an environment in which the identifiers are bound to the traced functions. Does not work on inlined functions, such as clojure.core/+

end-trace! clj

(end-trace! id output)

find-source clj

(find-source fn-symbol)

fmt clj

ignored-form? clj

many clj

one clj

read-source-by-hand clj

(read-source-by-hand text line column)

select clj

start-trace! clj

(start-trace! name _f args)

Returns id

throw-trace! clj

(throw-trace! id exception)

ThrowableRecompose clj protocol

Protocol to isolate trace-form from convoluted throwables that do not have a constructor with a single string argument. clone-throwable attempts to clone a throwable with a human readable stack trace and message :) It must return a throwable of the same class. If not clonable, the original throwable should be returned. At least this will preserve the original throwable information. Cloning should be non-obtrusive hence internal exceptions should be silently swallowed and return the original throwable.

clone-throwable clj

(clone-throwable this stack-trace args)

trace-compose-throwable clj

(trace-compose-throwable throwable message)

Re-create a new throwable with a composed message from the given throwable and the message to be added. The exception stack trace is kept at a minimum.

trace-fn-call clj

(trace-fn-call name f args)

Traces a single call to a function f with args. 'name' is the symbol name of the function.

trace-form clj

(trace-form form)

Trace the given form avoiding try catch when recur is present in the form.

trace-forms clj macro

(trace-forms & body)

Trace all the forms in the given body. Returns any underlying uncaught exceptions that may make the forms fail.

trace-ns clj macro

(trace-ns n)

Trace all fns in the given name space. The given name space can be quoted, unquoted or stored in a var. We must try to resolve the expression passed to us partially to find out if it needs to be quoted or not when passed to trace-ns*

trace-ns* clj

(trace-ns* ns)

Replaces each function from the given namespace with a version wrapped in a tracing call. Can be undone with untrace-ns. ns should be a namespace object or a symbol. No-op for clojure.core and clojure.tools.trace.

trace-special-form clj multimethod

trace-var* clj

(trace-var* v)

(trace-var* ns s)

If the specified Var holds an IFn and is not marked as a macro, its contents is replaced with a version wrapped in a tracing call; otherwise nothing happens. Can be undone with untrace-var. In the unary case, v should be a Var object or a symbol to be resolved in the current namespace. In the binary case, ns should be a namespace object or a symbol naming a namespace and s a symbol to be resolved in that namespace.

trace-vars clj macro

(trace-vars & vs)

Trace each of the specified Vars. The arguments may be Var objects or symbols to be resolved in the current namespace.

traceable? clj

(traceable? v)

Returns true if the given var can be traced, false otherwise

traced? clj

(traced? v)

Returns true if the given var is currently traced, false otherwise

trim-source clj

(trim-source s)

untrace-ns clj macro

(untrace-ns n)

Untrace all fns in the given name space. The given name space can be quoted, unquoted or stored in a var. We must try to resolve the expression passed to us partially to find out if it needs to be quoted or not when passed to untrace-ns*

untrace-ns* clj

(untrace-ns* ns)

Reverses the effect of trace-var / trace-vars / trace-ns for the Vars in the given namespace, replacing each traced function from the given namespace with the original, untraced version.

untrace-var* clj

(untrace-var* v)

(untrace-var* ns s)

Reverses the effect of trace-var / trace-vars / trace-ns for the given Var, replacing the traced function with the original, untraced version. No-op for non-traced Vars. Argument types are the same as those for trace-var.

untrace-vars clj macro

(untrace-vars & vs)

Untrace each of the specified Vars. Reverses the effect of trace-var / trace-vars / trace-ns for each of the arguments, replacing the traced functions with the original, untraced versions.

var->ns-symbol clj

(var->ns-symbol v)