las3r/keyword?
([x])

Return true if x is a Keyword

las3r/val
([e])

Returns the value in the map entry.

las3r/max-key
([k x] [k x y] [k x y & more])

Returns the x for which (k x), a number, is greatest.

las3r/list*
([item & more])

Creates a new list containing the item prepended to more.

las3r/ns-aliases
([ns])

Returns a map of the aliases for the namespace.

las3r/==
([x] [x y] [x y & more])

Returns non-nil if nums all have the same value, otherwise false

las3r/print-textile-doc
([v])

nil

las3r/bit-shl
([x n])

Bitwise shift left

las3r/instance?
([c x])

Evaluates x and tests if it is an instance of the class c. Returns true or false

las3r/compile-file-and-save
([module-id])

1. Browse to a source file. 2. Compile all forms in the source file. 3. Browse a location to save the compiled swf module.

las3r/dorun
([coll] [n coll])

When lazy sequences are produced via functions that have side effects, any effects other than those needed to produce the first element in the seq do not occur until the seq is consumed. dorun can be used to force any effects. Walks through the successive rests of the seq, does not retain the head and returns nil.

las3r/time
([expr])
Macro

Evaluates expr and prints the time it took. Returns the value of expr.

las3r/gensym
([] [prefix-string])

Returns a new symbol with a unique name. If a prefix string is supplied, the name is prefix# where # is some unique number. If prefix is not supplied, the prefix is 'G'.

las3r/not=
([x] [x y] [x y & more])

Same as (not (= obj1 obj2))

las3r/browse-save-file
([data name] [data name callback])

Browse to a file. Apply callback to the loaded FileReference.

las3r/get-property-values
([obj])

Return a list of all the values of an object's dynamic properties, wrapper for actionscript's for each(...) construct.

las3r/doseq
([item list & body])
Macro

Repeatedly executes body (presumably for side-effects) with binding-form bound to successive items from coll. Does not retain the head of the sequence. Returns nil.

las3r/bit-or
([x] [x y] [x y & more])

Bitwise or

las3r/hash-set
([& vals])

Returns a new hash set with supplied values.

las3r/some
([pred coll])

Returns the first logical true value of (pred x) for any x in coll, else nil.

las3r/nil?
([x])

Returns true if x is nil, false otherwise.

las3r/string?
([x])

Return true if x is a String

las3r/second
([x])

Same as (first (rest x))

las3r/keys
([map])

Returns a sequence of the map's keys.

las3r/for
([seq-exprs expr])
Macro

List comprehension. Takes a vector of one or more binding-form/collection-expr pairs, each followed by an optional filtering :when/:while expression (:when test or :while test), 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. (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))

las3r/cond
([& clauses])
Macro

Takes a set of test/expr pairs. It evaluates each test one at a time. If a test returns logical true, cond evaluates and returns the value of the corresponding expr and doesn't evaluate any of the other tests or exprs. (cond) returns nil.

las3r/fn
([& sigs])
Macro

(fn name? [params* ] exprs*) (fn name? ([params* ] exprs*)+) params => positional-params* , or positional-params* & rest-param positional-param => binding-form rest-param => binding-form name => symbol Defines a function

las3r/ns-unalias
([ns sym])

Removes the alias for the symbol from the namespace.

las3r/ns-publics
([ns])

Returns a map of the public intern mappings for the namespace.

las3r/all-ns
([])

Returns a sequence of all namespaces.

las3r/runtime***
nil

nil

las3r/textile-doc-all-publics
([ns])

Prints documentation for all public vars in the given namespace.

las3r/false?
([x])

Returns true if x is the value false, false otherwise.

las3r/apply*
nil

nil

las3r/true?
([x])

Returns true if x is the value true, false otherwise.

las3r/ns-unmap
([ns sym])

Removes the mappings for the symbol from the namespace.

las3r/repeat
([x])

Returns a lazy (infinite!) seq of xs.

las3r/zipmap
([keys vals])

Returns a map with the keys mapped to the corresponding vals.

las3r/distinct
([coll])

Returns a lazy sequence of the elements of coll with duplicates removed

las3r/bit-xor
([x] [x y] [x y & more])

Bitwise exclusive or

las3r/complement
([f])

Takes a fn f and returns a fn that takes the same arguments as f, has the same effects, if any, and returns the opposite truth value.

las3r/let
([bindings & body])
Macro

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.

las3r/dotimes
([i n & body])
Macro

Repeatedly executes body (presumably for side-effects) with name bound to integers from 0 through n-1.

las3r/ns***
nil

nil

las3r/lazy-cat
([coll] [coll & colls])
Macro

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.

las3r/get-property-names
([obj])

Return a list of all the names of an object's dynamic properties, wrapper for actionscript's for(.. in ..) construct.

las3r/rem
([num div])

rem[ainder] of dividing numerator by denominator.

las3r/connect-to-eval-pipe
([] [port])

Connect to eval_pipe, reading and evaluating strings as they arrive.

las3r/odd?
([n])

Returns true if n is odd, throws an exception if n is not an integer

las3r/bit-shr
([x n])

Bitwise shift right

las3r/symbol?
([x])

Return true if x is a Symbol

las3r/bit-sar
([x n])

Bitwise shift arithmetic right

las3r/ns-interns
([ns])

Returns a map of the intern mappings for the namespace.

las3r/split-with
([pred coll])

Returns a vector of [(take-while pred coll) (drop-while pred coll)]

las3r/loop
([bindings & body])
Macro

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.

las3r/rfirst
([x])

Same as (rest (first x))

las3r/import
([& import-lists])

import-list => (package-symbol class-name-symbols*) For each name in class-name-symbols, adds a mapping from name to the class named by package.name to the current namespace. Use :import in the ns macro in preference to calling this directly.

las3r/symbol
([name] [ns name])

Returns a Symbol with the given namespace and name.

las3r/vals
([map])

Returns a sequence of the map's values.

las3r/print-doc
([v])

nil

las3r/select-keys
([map keyseq])

Returns a map containing only those entries in map whose key is in keys

las3r/rand
([] [n])

Returns a random floating point number between 0 (inclusive) and 1 (exclusive).

las3r/+
([] [x] [x y] [x y & more])

Returns the sum of nums. (+) returns 0.

las3r/set-property!
([instance property value])

Set an instance's property to value using the array access [] operator.

las3r/stage***
nil

nil

las3r/last
([coll])

Return the last item in coll, in linear time

las3r/prn
([& more])

Same as pr followed by (newline).

las3r/with-meta
([obj m])

Returns an object of the same type and value as obj, with map m as its metadata.

las3r/*
([] [x] [x y] [x y & more])

Returns the product of nums. (*) returns 1.

las3r/when-not
([test & body])
Macro

Evaluates test. If logical false, evaluates body in an implicit do.

las3r/generate-api-doc
([ns])

Write all api documentation for the given namespace. Save that string to a file.

las3r/butlast
([coll])

Return a sequence of all but the last item in coll, in linear time

las3r/-
([x] [x y] [x y & more])

If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.

las3r/compile-str
([src module-id callback])

Evaluate all forms in src, returns a ByteArray containing compiled swf.

las3r/seq?
([x])

Return true if x implements ISeq

las3r/identical?
nil

nil

las3r/..
([x form] [x form & more])
Macro

form => fieldName-symbol or (instanceMethodName-symbol args*) Expands into a member access (.) of the first member on the first argument, followed by the next member on the result, etc. For instance: (.. System (getProperties) (get "os.name")) expands to: (. (. System (getProperties)) (get "os.name")) but is easier to write, read, and understand.

las3r/print
([& more])

Trace out the object(s). print and println produce output for human consumption.

las3r/zero?
([x])

Returns true if num is zero, else false

las3r/bit-and
([x] [x y] [x y & more])

Bitwise and

las3r/newline
([])

Writes a newline to the output stream that is the current value of *out*

las3r/replicate
([n x])

Returns a lazy seq of n xs.

las3r/remove-ns
([sym])

Removes the namespace named by the symbol. Use with caution. Cannot be used to remove the clojure namespace.

las3r/vec
([coll])

Creates a new vector containing the contents of coll.

las3r/compile-str-and-save
([src module-id])

Evaluate all forms in src, create a ByteArray containing compiled forms, initiate saving of those bytes as a SWF file.

las3r/concat
([] [x] [x y] [x y & zs])

Returns a lazy seq representing the concatenation of the elements in the supplied colls.

las3r/vector
([& args])

Creates a new vector containing the args.

las3r/conj
([coll x] [coll x & xs])

conj[oin]. Returns a new collection with the xs 'added'. (conj nil item) returns (item). The 'addition' may happen at different 'places' depending on the concrete type.

las3r//
([x] [x y] [x y & more])

If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.

las3r/assoc
([map key val] [map key val & kvs])

assoc[iate]. When applied to a map, returns a new map of the same (hashed/sorted) type, that contains the mapping of key(s) to val(s). When applied to a vector, returns a new vector that contains val at index. Note - index must be <= (count vector).

las3r/neg?
([x])

Returns true if num is less than zero, else false

las3r/doto
([x & members])
Macro

Evaluates x then calls all of the methods with the supplied arguments in succession on the resulting object, returning it. (doto (new java.util.HashMap) (put "a" 1) (put "b" 2))

las3r/ctep
nil

nil

las3r/out***
nil

nil

las3r/vector?
([x])

Return true if x implements IVector

las3r/split-at
([n coll])

Returns a vector of [(take n coll) (drop n coll)]

las3r/ns-refers
([ns])

Returns a map of the refer mappings for the namespace.

las3r/assert-false
([form])
Macro

nil

las3r/rrest
([x])

Same as (rest (rest x))

las3r/map
([f coll] [f coll & colls])

Returns a lazy seq 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.

las3r/char-code→str
([code])

Return the string corresponding to the numeric code.

las3r/memfn
([name & args])
Macro

Expands into code that creates a fn that expects to be passed an object and any args and calls the named instance method on the object passing the args. Use when you want to treat a Java method as a first-class fn.

las3r/rand-int
([n])

Returns a random integer between 0 (inclusive) and n (exclusive).

las3r/iterate
([f x])

Returns a lazy seq of x, (f x), (f (f x)) etc. f must be free of side-effects

las3r/when-first
([bindings & body])
Macro

bindings => x xs Same as (when (seq xs) (let [x (first xs)] body))

las3r/mapcat
([f & colls])

Returns the result of applying concat to the result of applying map to f and colls. Thus function f should return a collection.

las3r/special-symbol?
([s])

Returns true if s names a special form

las3r/find-var
([sym])

Returns the global var named by the namespace-qualified symbol, or nil if no var with that name.

las3r/inc
([x])

Returns a number one greater than num.

las3r/ns-name
([ns])

Returns the name of the namespace, a symbol.

las3r/defn-
([name & decls])
Macro

same as defn, yielding non-public def

las3r/aot-swf***
nil

nil

las3r/bit-not
([x])

Bitwise complement

las3r/destructure
([bindings])

nil

las3r/seq
([coll])

Sequence. Returns a new ISeq on the collection. If the collection is empty, returns nil. (seq nil) returns nil. seq also works on Strings and native arrays.

las3r/browse-file
([filters callback])

Browse to a file. Apply callback to the loaded FileReference.

las3r/filter
([pred coll])

Returns a lazy seq of the items in coll for which (pred item) returns true. pred must be free of side-effects.

las3r/comment
([& body])
Macro

Ignores body, yields nil

las3r/key
([e])

Returns the key of the map entry.

las3r/run-tests
([])

nil

las3r/create-ns
([sym])

Create a new namespace named by the symbol if one doesn't already exist, returns it or the already-existing namespace of the same name.

las3r/name
([x])

Returns the name String of a symbol or keyword.

las3r/nthrest
([coll n])

Returns the nth rest of coll, (seq coll) when n is 0.

las3r/doall
([coll] [n coll])

When lazy sequences are produced via functions that have side effects, any effects other than those needed to produce the first element in the seq do not occur until the seq is consumed. doall can be used to force any effects. Walks through the successive rests of the seq, retains the head and returns it, thus causing the entire seq to reside in memory at one time.

las3r/macroexpand-1
([form])

If form represents a macro form, returns its expansion, else returns form.

las3r/not-any?
([pred coll])

Returns false if (pred x) is logical true for any x in coll, else true.

las3r/into
([to from])

Returns a new coll consisting of to-coll with all of the items of from-coll conjoined.

las3r/ffirst
([x])

Same as (first (first x))

las3r/or
([] [x] [x & rest])
Macro

Evaluates exprs one at a time, from left to right. If a form returns a logical true value, or returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last expression. (or) returns nil.

las3r/drop-last
([s] [n s])

Return a lazy seq of all but the last n (default 1) items in coll

las3r/defn
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])
Macro

Same as (def name (fn [params* ] exprs*)) with any doc-string or attrs added to the var metadata

las3r/map?
([x])

Return true if x implements IMap

las3r/with-local-vars
([name-vals-vec & body])
Macro

varbinding=> symbol init-expr Executes the exprs in a context in which the symbols are bound to vars with per-thread bindings to the init-exprs. The symbols refer to the var objects themselves, and must be accessed with var-get and var-set

las3r/reverse
([coll])

Returns a seq of the items in coll in reverse order. Not lazy.

las3r/count
([coll])

Returns the number of items in the collection. (count nil) returns 0. Also works on strings, arrays and maps

las3r/set
([coll])

Returns a set of the distinct elements of coll.

las3r/assert-true
([form])
Macro

nil

las3r/when-let
([binding-form test & body])
Macro

when test is true, evaluates body with binding-form bound to the value of test

las3r/comp
([& fs])

Takes a set of functions and returns a fn that is the composition of those fns. The returned fn takes a variable number of args, applies the rightmost of fns to the args, the next fn (right-to-left) to the result, etc.

las3r/nth
([coll index] [coll index not-found])

Returns the value at the index. get returns nil if index out of bounds, nth throws an exception unless not-found is supplied. nth also works for strings, Java arrays, regex Matchers and Lists, and, in O(n) time, for sequences.

las3r/load-url
([url on-complete on-error])

Load data from a URL using flash.net.URLLoader, setup on-complete and on-error as event listeners.

las3r/err***
nil

nil

las3r/constantly
([x])

Returns a function that takes any number of arguments and returns x.

las3r/namespace
([x])

Returns the namespace String of a symbol or keyword, or nil if not present.

las3r/<
([x] [x y] [x y & more])

Returns non-nil if nums are in monotonically increasing order, otherwise false.

las3r/cycle
([coll])

Returns a lazy (infinite!) seq of repetitions of the items in coll.

las3r/reduce
([f coll] [f val coll])

f should be a function of 2 arguments. If val is not supplied, returns the result of applying f to the first 2 items in coll, then applying f to that result and the 3rd item, etc. If coll contains no items, f must accept no arguments as well, and reduce returns the result of calling f with no arguments. If coll has only 1 item, it is returned and f is not called. If val is supplied, returns the result of applying f to val and the first item in coll, then applying f to that result and the 2nd item, etc. If coll contains no items, returns val and f is not called.

las3r/interleave
([& colls])

Returns a lazy seq of the first item in each coll, then the second etc.

las3r/→
([x form] [x form & more])
Macro

Macro. Threads the expr through the forms. Inserts x as the second item in the first form, making a list of it if it is not a list already. If there are more forms, inserts the first form as the second item in second form, etc.

las3r/cons
([x seq])

Returns a new seq where x is the first element and seq is the rest.

las3r/macroexpand
([form])

Repeatedly calls macroexpand-1 on form until it no longer represents a macro form, then returns it. Note neither macroexpand-1 nor macroexpand expand macros in subforms.

las3r/var-set
([x val])

Sets the value in the var object to val. The var must be thread-locally bound.

las3r/str
([] [x] [x & ys])

With no args, returns the empty string. With one arg x, returns x.toString(). (str nil) returns the empty string. With more than one arg, returns the concatenation of the str values of the args.

las3r/ns-imports
([ns])

Returns a map of the import mappings for the namespace.

las3r/first
([coll])

Returns the first item in the collection. Calls seq on its argument. If coll is nil, returns nil.

las3r/=
([x] [x y] [x y & more])

Equality. Returns true if x equals y, false if not. Same as Java x.equals(y) except it also works for nil, and compares numbers in a type-independent manner. Clojure's immutable data structures define equals() (and thus =) as a value, not an identity, comparison.

las3r/var-get
([x])

Gets the value in the var object

las3r/range
([end] [start end] [start end step])

Returns a lazy seq of nums from start (inclusive) to end (exclusive), by step, where start defaults to 0 and step to 1.

las3r/defmacro
([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])
Macro

Like defn, but the resulting function name is declared as a macro and will be used as a macro by the compiler when it is called.

las3r/eval-url
([url] [url callback] [url callback err-callback])

Evaluate the code in the provided URL and call back with the result or error if callbacks are provided.

las3r/find-ns
([sym])

Returns the namespace named by the symbol or nil if it doesn't exist.

las3r/not-every?
([pred coll])

Returns false if (pred x) is logical true for every x in coll, else true.

las3r/load-module
([module-id])

1. Browse to a swf module on the local file system. 2. Load the compiled lisp forms contained inside.

las3r/>
([x] [x y] [x y & more])

Returns non-nil if nums are in monotonically decreasing order, otherwise false.

las3r/max
([x] [x y] [x y & more])

Returns the greatest of the nums.

las3r/identity
([x])

Returns its argument.

las3r/min-key
([k x] [k x y] [k x y & more])

Returns the x for which (k x), a number, is least.

las3r/subs
([s start] [s start end])

Returns the substring of s beginning at start inclusive, and ending at end (defaults to length of string), exclusive.

las3r/>=
([x] [x y] [x y & more])

Returns non-nil if nums are in monotonically non-increasing order, otherwise false.

las3r/even?
([n])

Returns true if n is even, throws an exception if n is not an integer

las3r/bit-shift-left
nil

nil

las3r/save-bytecodes***
nil

nil

las3r/compare
([x y])

Comparator. Returns 0 if x equals y, -1 if x is logically 'less than' y, else 1. Same as Java x.compareTo(y) except it also works for nil, and compares numbers in a type-independent manner. x must implement Comparable

las3r/cast
([c x])

Throws an Error if x is not a c, else returns x.

las3r/get
([map key] [map key not-found])

Returns the value mapped to key, not-found or nil if key not present.

las3r/<=
([x] [x y] [x y & more])

Returns non-nil if nums are in monotonically non-decreasing order, otherwise false.

las3r/compiler***
nil

nil

las3r/partial
([f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more])

Takes a function f and fewer than the normal arguments to f, and returns a fn that takes a variable number of additional args. When called, the returned function calls f with args + additional args.

las3r/if-let
([binding-form test then] [binding-form test then else])
Macro

if test is true, evaluates then with binding-form bound to the value of test, if not, yields else

las3r/pos?
([x])

Returns true if num is greater than zero, else false

las3r/get-property
([instance property])

Return an instance's property value using the array access [] operator.

las3r/take-while
([pred coll])

Returns a lazy seq of successive items from coll while (pred item) returns true. pred must be free of side-effects.

las3r/and
([] [x] [x & rest])
Macro

Evaluates exprs one at a time, from left to right. If a form returns logical false (nil or false), and returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last expr. (and) returns true.

las3r/lazy-cons
([first-expr & rest-expr])
Macro

Expands to code which produces a seq object whose first is first-expr and whose rest is rest-expr, neither of which is evaluated until first/rest is called. Each expr will be evaluated at most once per step in the sequence, e.g. calling first/rest repeatedly on the same node of the seq evaluates first/rest-expr once - the values they yield are cached.

las3r/refer
([ns-sym & filters])

refers to all public vars of ns, subject to filters. filters can include at most one each of: :exclude list-of-symbols :only list-of-symbols :rename map-of-fromsymbol-tosymbol For each public interned var in the namespace named by the symbol, adds a mapping from the name of the var to the var to the current namespace. Throws an exception if name is already mapped to something else in the current namespace. Filters can be used to select a subset, via inclusion or exclusion, or to provide a mapping to a symbol different from the var's name, in order to prevent clashes. Use :use in the ns macro in preference to calling this directly.

las3r/in-ns
nil

nil

las3r/contains?
([map key])

Returns true if key is present, else false.

las3r/load-file
([])

1. Browse to a lsr source file on the local file system. 2. Load the lisp forms contained inside.

las3r/apply
([f args* argseq])

Applies fn f to the argument list formed by prepending args to argseq.

las3r/rest
([coll])

Returns a seq of the items after the first. Calls seq on its argument. If there are no more items, returns nil.

las3r/keyword
([name] [ns name])

Returns a Keyword with the given namespace and name. Do not use : in the keyword strings, it will be added automatically.

las3r/ns-map
([ns])

Returns a map of all the mappings for the namespace.

las3r/doc-all-publics
([ns])

Prints documentation for all public vars in the given namespace.

las3r/int
([x])

Coerce to int

las3r/array-map
([& keyvals])

keyval => key val Returns a new array map with supplied mappings.

las3r/dec
([x])

Returns a number one less than num.

las3r/println
([& more])

Same as print followed by (newline)

las3r/pr
([] [x] [x & more])

Trace out the object. By default, pr and prn print in a way that objects can be read by the reader

las3r/drop
([n coll])

Returns a lazy seq of all but the first n items in coll.

las3r/eval
([form] [form callback] [form callback err-callback] [form callback err-callback progress])

Evaluates the form data structure (provided as a string!) and calls back with the result if callback is provided.

las3r/loop*
nil
Macro

Loop macro that expands into a let expression with a body that applies a function to the bound locals.

las3r/bit-shift-right
nil

nil

las3r/num
([x])

Coerce to Number

las3r/print-readably***
nil

nil

las3r/merge-with
([f & maps])

Returns a map that consists of the rest of the maps conj-ed onto the first. If a key occurs in more than one map, the mapping(s) from the latter (left-to-right) will be combined with the mapping in the result by calling (f val-in-result val-in-latter).

las3r/take-nth
([n coll])

Returns a lazy seq of every nth item in coll.

las3r/in***
nil

nil

las3r/line-seq
([rdr])

Returns the lines of text from rdr as a lazy sequence of strings. rdr must implement java.io.BufferedReader.

las3r/take
([n coll])

Returns a lazy seq of the first n items in coll, or all items if there are fewer than n.

las3r/when
([test & body])
Macro

Evaluates test. If logical true, evaluates body in an implicit do.

las3r/alias
([alias namespace-sym])

Add an alias in the current namespace to another namespace. Arguments are two symbols: the alias to be used, and the symbolic name of the target namespace. Use :as in the ns macro in preference to calling this directly.

las3r/to-array
([coll])

Returns an array of Objects containing the contents of coll, which can be any Collection.

las3r/hash-map
([& keyvals])

keyval => key val Returns a new hash map with supplied mappings.

las3r/frest
([x])

Same as (first (rest x))

las3r/find
([map key])

Returns the map entry for key, or nil if key not present.

las3r/drop-while
([pred coll])

Returns a lazy seq of the items in coll starting from the first item for which (pred item) returns nil.

las3r/print-special-doc
([name type anchor])

nil

las3r/list
([& items])

Creates a new list containing the items.

las3r/every?
([pred coll])

Returns true if (pred x) is logical true for every x in coll, else false.

las3r/dissoc
([map] [map key] [map key & ks])

dissoc[iate]. Returns a new map of the same (hashed/sorted) type, that does not contain a mapping for key(s).

las3r/not
([x])

Returns true if x is logical false, false otherwise.

las3r/binding
([bindings & body])
Macro

binding => var-symbol init-expr Creates new bindings for the (already-existing) vars, with the supplied initial values, executes the exprs in an implicit do, then re-establishes the bindings that existed before.

las3r/doc
([name])
Macro

Prints documentation for a var or special form given its name

las3r/merge
([& maps])

Returns a map that consists of the rest of the maps conj-ed onto the first. If a key occurs in more than one map, the mapping from the latter (left-to-right) will be the mapping in the result.

las3r/min
([x] [x y] [x y & more])

Returns the least of the nums.

las3r/meta
([obj])

Returns the metadata of obj, returns nil if there is no metadata.