Provides functionality for measuring and displaying time.
details +Implements encoding and decoding of YAML.
+ details +bound in a repl to the most recent value printed
- source + sourcebound in a repl to the second most recent value printed
- source + sourcebound in a repl to the third most recent value printed
- source + sourcebound in a repl to the most recent exception caught by the repl
- source + source(array-map & keyvals)
Constructs an array-map. If any keys are equal, they are handled as
if by repeated uses of assoc.
(as-> expr name & forms)
Binds name to expr, evaluates the first form in the lexical context
of that binding, then binds name to that result, repeating for each
successive form, returning the result of the last form.
(assert x message)Evaluates expr and throws an exception if it does not evaluate to
logical true.
+(assoc-in m [k & ks] v)(assoc-in m ks v)Associates a value in a nested associative structure, where ks is a
- source + source
sequence of keys and v is the new value and returns a new nested structure.
If any levels do not exist, hash-maps will be created.
(associative? coll)
Returns true if coll implements Associative
- source + source(bound? & vars)
Returns true if all of the vars provided as arguments have any bound value.
Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.
(bounded-count n coll)
If coll is counted? returns its count, else will count at most the first n
elements of coll using its seq
(callable? x)
Returns true if x implements Callable. Note that many data structures
(e.g. sets and maps) implement Callable.
(case expr & clauses)
Takes an expression, and a set of clauses.
Each clause can take the form of either:
test-expr result-expr
(test-expr ... test-expr) result-expr
If the expression is equal to a value of
test-expr, the corresponding result-expr is returned. A single
default expression can follow the clauses, and its value will be
returned if no clause matches. If no default expression is provided
and no clause matches, an exception is thrown.
(coll? x)
Returns true if x implements Collection
- source + source(comment & body)
Ignores body, yields nil
- source + source(cond-> expr & clauses)
Takes an expression and a set of test/form pairs. Threads expr (via ->)
through each form for which the corresponding test
expression is true. Note that, unlike cond branching, cond-> threading does
not short circuit after the first true test expression.
(cond->> expr & clauses)
Takes an expression and a set of test/form pairs. Threads expr (via ->>)
through each form for which the corresponding test expression
is true. Note that, unlike cond branching, cond->> threading does not short circuit
after the first true test expression.
(condp pred expr & clauses)
Takes a binary predicate, an expression, and a set of clauses.
Each clause can take the form of either:
test-expr result-expr
test-expr :>> result-fn
Note :>> is an ordinary keyword.
For each clause, (pred test-expr expr) is evaluated. If it returns
logical true, the clause is a match. If a binary clause matches, the
result-expr is returned, if a ternary clause matches, its result-fn,
which must be a unary function, is called with the result of the
predicate as its argument, the result of that call being the return
value of condp. A single default expression can follow the clauses,
and its value will be returned if no clause matches. If no default
expression is provided and no clause matches, an
exception is thrown.
(counted? coll)
Returns true if coll implements count in constant time
- source + source(dedupe coll)
Returns a lazy sequence removing consecutive duplicates in coll.
- source + sourceDefault map of data reader functions provided by Joker. May be
overridden by binding *data-readers*.
(defn- name & decls)
same as defn, yielding non-public def
- source + source(defonce name expr)
defs name to have the value of the expr if the named var is not bound,
else expr is unevaluated
(distinct coll)
Returns a lazy sequence of the elements of coll with duplicates removed.
- source + source(distinct? x y & more)Returns true if no two of the arguments are =
- source + source(empty coll)
Returns an empty collection of the same category as coll, or nil
- source + source(empty? coll)
Returns true if coll has no items - same as (not (seq coll)).
Please use the idiom (seq x) rather than (not (empty? x))
(every-pred p1 p2 p3 & ps)Takes a set of predicates and returns a function f that returns true if all of its
composing predicates return a logical true value against all of its arguments, else it returns
false. Note that f is short-circuiting in that it will stop execution on the first
argument that triggers a logical false result against the original predicates.
(ex-data ex)
Returns exception data (a map) if ex is an ExInfo.
Otherwise returns nil.
(filterv pred coll)
Returns a vector of the items in coll for which
(pred item) returns true. pred must be free of side-effects.
(flatten x)
Takes any nested combination of sequential things (lists, vectors,
etc.) and returns their contents as a single, flat sequence.
(flatten nil) returns an empty sequence.
(fn name? ([params*] exprs*) +)params => positional-params* , or positional-params* & next-param
positional-param => binding-form
next-param => binding-form
name => symbol
Defines a function
(fn? x)
Returns true if x is Fn, i.e. is an object created via fn.
- source + source(fnil f x y z)Takes a function f, and returns a function that calls f, replacing
a nil first argument to f with the supplied value x. Higher arity
versions can replace arguments in the second and third
positions (y, z). Note that the function f can take any number of
arguments, not just the one(s) being nil-patched.
(for seq-exprs body-expr)
List comprehension. Takes a vector of one or more
binding-form/collection-expr pairs, each followed by zero or more
modifiers, and yields a lazy sequence of evaluations of expr.
Collections are iterated in a nested fashion, rightmost fastest,
and nested coll-exprs can refer to bindings created in prior
binding-forms. Supported modifiers are: :let [binding-form expr ...],
:while test, :when test.
(take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))
(format fmt & args)
Formats a string using fmt.Sprintf
- source + source(frequencies coll)
Returns a map from distinct items in coll to the number of times
they appear.
(get-in m ks not-found)Returns the value in a nested associative structure,
where ks is a sequence of keys. Returns nil if the key
is not present, or the not-found value if supplied.
(group-by f coll)
Returns a map of the elements of coll keyed by the result of
f on each element. The value at each key will be a vector of the
corresponding elements, in the order they appeared in coll.
(hash x)
Returns the hash code of its argument.
- source + source(in-ns name)
Sets *ns* to the namespace named by the symbol, creating it if needed.
- source + source(indexed? coll)
Return true if coll implements Indexed, indicating efficient lookup by index
- source + source(interpose sep coll)
Returns a lazy seq of the elements of coll separated by sep.
Returns a stateful transducer when no collection is provided.
(into to from)
Returns a new coll consisting of to-coll with all of the items of
from-coll conjoined.
(joker-version)
Returns joker version as a printable string.
- source + source(keep f coll)
Returns a lazy sequence of the non-nil results of (f item). Note,
this means false return values will be included. f must be free of
side-effects.
(keep-indexed f coll)
Returns a lazy sequence of the non-nil results of (f index item). Note,
this means false return values will be included. f must be free of
side-effects.
(lazy-cat & colls)
Expands to code which yields a lazy sequence of the concatenation
of the supplied colls. Each coll expr is not evaluated until it is
needed.
(lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))
(let [bindings*] exprs*)
binding => binding-form init-expr
Evaluates the exprs in a lexical context in which the symbols in
the binding-forms are bound to their respective init-exprs or parts
therein.
(list? x)
Returns true if x is a List
- source + source(load & libs)
Loads code from libs.
- source + source(load-file f)
Loads code from file f
- source + source(loaded-libs)
Returns a sorted set of symbols naming the currently loaded libs
- source + source(loop [bindings*] exprs*)
Evaluates the exprs in a lexical context in which the symbols in
the binding-forms are bound to their respective init-exprs or parts
therein. Acts as a recur target.
(map-indexed f coll)
Returns a lazy sequence consisting of the result of applying f to 0
and the first item of coll, followed by applying f to 1 and the second
item in coll, etc, until coll is exhausted. Thus function f should
accept 2 arguments, index and item.
(mapv f c1 c2 c3 & colls)Returns a vector consisting of the result of applying f to the
set of first items of each coll, followed by applying f to the set
of second items in each coll, until any one of the colls is
exhausted. Any remaining items in other colls are ignored. Function
f should accept number-of-colls arguments.
(max-key k x y & more)Returns the x for which (k x), a number, is greatest.
- source + source(memoize f)
Returns a memoized version of a referentially transparent function. The
memoized version of the function keeps a cache of the mapping from arguments
to results and, when calls with the same arguments are repeated often, has
higher performance at the expense of higher memory use.
(min-key k x y & more)Returns the x for which (k x), a number, is least.
- source + source(not-empty coll)
If coll is empty, returns nil, else coll
- source + source(ns name docstring? attr-map? references*)
Sets *ns* to the namespace named by name (unevaluated), creating it
if needed. references can be zero or more of:
(:require ...) (:use ...) (:load ...)
with the syntax of require/use/load
respectively, except the arguments are unevaluated and need not be
quoted. Use of ns is preferred to
individual calls to in-ns/require/use:
(ns foo.bar
(:require [my.lib1 :as lib1])
(:use [my.lib2]))
(partition-all n step coll)Returns a lazy sequence of lists like partition, but may include
partitions with fewer than n items at the end.
(partition-by f coll)
Applies f to each value in coll, splitting it each time f returns a
new value. Returns a lazy seq of partitions.
(pr-err & xs)
pr to *err*
- source + source(pr-str & xs)
pr to a string, returning it
- source + source(print-err & xs)
print to *err*
- source + source(print-str & xs)
print to a string, returning it
- source + source(printf fmt & args)
Prints formatted output, as per format
- source + source(println-err & xs)
println to *err*
- source + source(println-str & xs)
println to a string, returning it
- source + source(prn-err & xs)
prn to *err*
- source + source(prn-str & xs)
prn to a string, returning it
- source + source(rand n)Returns a random floating point number between 0 (inclusive) and
n (default 1) (exclusive).
(rand-int n)
Returns a random integer between 0 (inclusive) and n (exclusive).
- source + source(rand-nth coll)
Return a random element of the (sequential) collection. Will have
the same performance characteristics as nth for the given
collection.
(random-sample prob coll)
Returns items from coll with random probability of prob (0.0 -
1.0).
(re-find re s)
Returns the leftmost regex match, if any, of string to pattern.
- source + source(re-matches re s)
Returns the match, if any, of string to pattern.
- source + source(re-pattern s)
Returns an instance of Regex
- source + source(re-seq re s)
Returns a sequence of successive matches of pattern in string
- source + source(realized? x)
Returns true if a value has been produced for a delay or lazy sequence.
- source + source(reductions f init coll)Returns a lazy seq of the intermediate values of the reduction (as
per reduce) of coll by f, starting with init.
(repeatedly n f)Takes a function of no args, presumably with side effects, and
returns an infinite (or length n if supplied) lazy sequence of calls
to it
(replace smap coll)
Given a map of replacement pairs and a vector/collection, returns a
vector/seq with any elements = a key in smap replaced with the
corresponding val in smap.
(require & args)
Loads libs, skipping any that are already loaded. Each argument is
either a libspec that identifies a lib, a prefix list that identifies
multiple libs whose names share a common prefix, or a flag that modifies
how all the identified libs are loaded. Use :require in the ns macro
in preference to calling this directly.
Libs
A 'lib' is a named set of resources in classpath whose contents define a
library of Clojure code. Lib names are symbols and each lib is associated
with a Clojure namespace and a Java package that share its name. A lib's
name also locates its root directory within classpath using Java's
package name to classpath-relative path mapping. All resources in a lib
should be contained in the directory structure under its root directory.
All definitions a lib makes should be in its associated namespace.
'require loads a lib by loading its root resource. The root resource path
is derived from the lib name in the following manner:
Consider a lib named by the symbol 'x.y.z; it has the root directory
resource should contain code to create the lib's namespace (usually by using
the ns macro) and load any additional lib resources.
Libspecs
A libspec is a lib name or a vector containing a lib name followed by
options expressed as sequential keywords and arguments.
Recognized options:
:as takes a symbol as its argument and makes that symbol an alias to the
lib's namespace in the current namespace.
:refer takes a list of symbols to refer from the namespace or the :all
keyword to bring in all public vars.
Prefix Lists
It's common for Clojure code to depend on several libs whose names have
the same prefix. When specifying libs, prefix lists can be used to reduce
repetition. A prefix list contains the shared prefix followed by libspecs
with the shared prefix removed from the lib names. After removing the
prefix, the names that remain must not contain any periods.
Flags
A flag is a keyword.
Recognized flags: :reload, :reload-all, :verbose
:reload forces loading of all the identified libs even if they are
already loaded
:reload-all implies :reload and also forces loading of all libs that the
identified libs directly or indirectly load via require or use
:verbose triggers printing information about each load, alias, and refer
Example:
The following would load the libraries clojure.zip and clojure.set
abbreviated as 's'.
(require '(clojure zip [set :as s]))
(resolve env sym)Same as (ns-resolve *ns* sym) or (ns-resolve *ns* env sym)
- source + source(reversible? coll)
Returns true if coll implements Reversible
- source + source(run! proc coll)
Runs the supplied procedure (via reduce), for purposes of side
effects, on successive items in the collection. Returns nil.
(seqable? x)
Return true if the seq function is supported for x
- source + source(sequential? coll)
Returns true if coll implements Sequential
- source + source(shuffle coll)
Return a random permutation of coll
- source + source(slurp f)
Opens file f and reads all its contents, returning a string.
- source + source(some-> expr & forms)
When expr is not nil, threads it into the first form (via ->),
and when that result is not nil, through the next etc.
(some->> expr & forms)
When expr is not nil, threads it into the first form (via ->>),
and when that result is not nil, through the next etc.
(some-fn p1 p2 p3 & ps)Takes a set of predicates and returns a function f that returns the first logical true value
returned by one of its composing predicates against any of its arguments, else it returns
logical false. Note that f is short-circuiting in that it will stop execution on the first
argument that triggers a logical true result against the original predicates.
(special-symbol? s)
Returns true if s names a special form
- source + source(spit f content)
Opposite of slurp. Opens file f, writes content, then
closes f.
(subs s start end)Returns the substring of s beginning at start inclusive, and ending
at end (defaults to length of string), exclusive.
(test v)
test [v] finds fn at key :test in var metadata and calls it,
presuming failure will throw exception
(trampoline f & args)trampoline can be used to convert algorithms requiring mutual
recursion without stack consumption. Calls f with supplied args, if
any. If f returns a fn, calls that fn with no arguments, and
continues to repeat, until the return value is not a fn, then
returns that non-fn value. Note that if you want to return a fn as a
final value, you must wrap it in some data structure and unpack it
after trampoline returns.
(tree-seq branch? children root)
Returns a lazy sequence of the nodes in a tree, via a depth-first walk.
branch? must be a fn of one arg that returns true if passed a node
that can have children (but may not). children must be a fn of one
arg that returns a sequence of the children. Will only be called on
nodes for which branch? returns true. Root is the root node of the
tree.
(update m k f x y z & more)'Updates' a value in an associative structure, where k is a
key and f is a function that will take the old value
and any supplied args and return the new value, and returns a new
structure. If the key does not exist, nil is passed as the old value.
+(update-in m [k & ks] f & args)(update-in m ks f & args)'Updates' a value in a nested associative structure, where ks is a
- source + source
sequence of keys and f is a function that will take the old value
and any supplied args and return the new value, and returns a new
nested structure. If any levels do not exist, hash-maps will be
created.
(use & args)
Like 'require, but also refers to each lib's namespace using
joker.core/refer. Use :use in the ns macro in preference to calling
this directly.
'use accepts additional options in libspecs: :exclude, :only, :rename.
The arguments and semantics for :exclude, :only, and :rename are the same
as those documented for joker.core/refer.
(var? v)
Returns true if v is of type Var
- source + source(when-first bindings & body)
bindings => x xs
Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once
(while test & body)
Repeatedly executes body while test expression is true. Presumes
some side-effect will cause test to become false/nil. Returns nil
(with-in-str s & body)
Evaluates body in a context in which *in* is bound to a fresh
Buffer initialized with the string s.
(with-out-str & body)
Evaluates exprs in a context in which *out* is bound to a fresh
Buffer. Returns the string created by any nested printing
calls.
(xml-seq root)
A tree seq on the xml elements as per xml/parse
- source + sourceImplements encoding and decoding of YAML.
+++(read-string s)
Parses the YAML-encoded data and return the result as a Joker value.
+ +++(write-string v)
Returns the YAML encoding of v.
+ +