Created
September 21, 2015 07:11
-
-
Save cmoore/268e36fa4dffd236b5e1 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| (---> | |
| op "clone" | |
| id "19" | |
| ) | |
| (<- | |
| id "19" | |
| new-session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| session "03205e3c-324f-423a-ab8c-3bc3ab23f2dc" | |
| status ("done") | |
| ) | |
| (---> | |
| op "clone" | |
| id "20" | |
| ) | |
| (<- | |
| id "20" | |
| new-session "f7a577d6-42cd-4ccd-be23-e403b45c8ba8" | |
| session "3891a013-125d-4040-a7bd-5ab11261cd92" | |
| status ("done") | |
| ) | |
| (---> | |
| op "describe" | |
| id "21" | |
| ) | |
| (<- | |
| aux (dict | |
| current-ns "promotable.core") | |
| id "21" | |
| ops (dict | |
| apropos (dict) | |
| classpath (dict) | |
| clone (dict) | |
| close (dict) | |
| complete (dict) | |
| complete-doc (dict) | |
| debug-input (dict) | |
| debug-instrumented-defs (dict) | |
| debug-middleware (dict) | |
| describe (dict) | |
| eldoc (dict) | |
| eval (dict) | |
| format-code (dict) | |
| format-edn (dict) | |
| info (dict) | |
| init-debugger (dict) | |
| inspect-next-page (dict) | |
| inspect-pop (dict) | |
| inspect-prev-page (dict) | |
| inspect-push (dict) | |
| inspect-refresh (dict) | |
| inspect-set-page-size (dict) | |
| interrupt (dict) | |
| load-file (dict) | |
| ls-sessions (dict) | |
| macroexpand (dict) | |
| ns-list (dict) | |
| ns-list-vars-by-name (dict) | |
| ns-path (dict) | |
| ns-vars (dict) | |
| pprint-middleware (dict) | |
| refresh (dict) | |
| refresh-all (dict) | |
| refresh-clear (dict) | |
| resource (dict) | |
| resources-list (dict) | |
| retest (dict) | |
| stacktrace (dict) | |
| stdin (dict) | |
| test (dict) | |
| test-stacktrace (dict) | |
| toggle-trace-ns (dict) | |
| toggle-trace-var (dict) | |
| track-state-middleware (dict) | |
| undef (dict)) | |
| session "9719ce42-a63d-4140-8937-2b25ec746905" | |
| status ("done") | |
| versions (dict | |
| clojure (dict | |
| incremental 0 | |
| major 1 | |
| minor 7 | |
| version-string "1.7.0") | |
| java (dict | |
| incremental "0" | |
| major "1" | |
| minor "8" | |
| update "60" | |
| version-string "1.8.0_60") | |
| nrepl (dict | |
| incremental "10" | |
| major "0" | |
| minor "2" | |
| qualifier "" | |
| version-string "0.2.10")) | |
| ) | |
| (---> | |
| op "eval" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| code "(str *ns*)" | |
| id "22" | |
| ) | |
| (<- | |
| id "22" | |
| ns "promotable.core" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| value "\"promotable.core\"" | |
| ) | |
| (<- | |
| id "22" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("done") | |
| ) | |
| (---> | |
| op "eval" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| code "(when (clojure.core/resolve 'clojure.main/repl-requires)\n (clojure.core/map clojure.core/require clojure.main/repl-requires))" | |
| id "23" | |
| ) | |
| (---> | |
| op "eval" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| code "(try\n (require 'cider.nrepl.version)\n (:version-string @(resolve 'cider.nrepl.version/version))\n (catch Throwable _ \"not installed\"))" | |
| id "24" | |
| ) | |
| (---> | |
| op "init-debugger" | |
| print-level 10 | |
| print-length 10 | |
| id "25" | |
| ) | |
| (<- | |
| id "23" | |
| ns "promotable.core" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| value "(nil nil nil)" | |
| ) | |
| (<- | |
| id "23" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("done") | |
| ) | |
| (<- | |
| changed-namespaces (dict | |
| clojure.core (dict | |
| aliases (dict) | |
| interns (dict | |
| * (dict | |
| arglists "([] [x] [x y] [x y & more])") | |
| *' (dict | |
| arglists "([] [x] [x y] [x y & more])") | |
| *1 (dict) | |
| *2 (dict) | |
| *3 (dict) | |
| *agent* (dict) | |
| *allow-unresolved-vars* (dict) | |
| *assert* (dict) | |
| *clojure-version* (dict) | |
| *command-line-args* (dict) | |
| *compile-files* (dict) | |
| *compile-path* (dict) | |
| *compiler-options* (dict) | |
| *data-readers* (dict) | |
| *default-data-reader-fn* (dict) | |
| *e (dict) | |
| *err* (dict) | |
| *file* (dict) | |
| *flush-on-newline* (dict) | |
| *fn-loader* (dict) | |
| *in* (dict) | |
| *loaded-libs* (dict) | |
| *loading-verbosely* (dict) | |
| *math-context* (dict) | |
| *ns* (dict) | |
| *out* (dict) | |
| *pending-paths* (dict) | |
| *print-dup* (dict) | |
| *print-length* (dict) | |
| *print-level* (dict) | |
| *print-meta* (dict) | |
| *print-readably* (dict) | |
| *read-eval* (dict) | |
| *source-path* (dict) | |
| *suppress-read* (dict) | |
| *unchecked-math* (dict) | |
| *use-context-classloader* (dict) | |
| *verbose-defrecords* (dict) | |
| *warn-on-reflection* (dict) | |
| + (dict | |
| arglists "([] [x] [x y] [x y & more])") | |
| +' (dict | |
| arglists "([] [x] [x y] [x y & more])") | |
| - (dict | |
| arglists "([x] [x y] [x y & more])") | |
| -' (dict | |
| arglists "([x] [x y] [x y & more])") | |
| -> (dict | |
| arglists "([x & forms])" | |
| macro "true") | |
| ->> (dict | |
| arglists "([x & forms])" | |
| macro "true") | |
| ->ArrayChunk (dict | |
| arglists "([am arr off end])") | |
| ->Eduction (dict | |
| arglists "([xform coll])") | |
| ->Vec (dict | |
| arglists "([am cnt shift root tail _meta])") | |
| ->VecNode (dict | |
| arglists "([edit arr])") | |
| ->VecSeq (dict | |
| arglists "([am vec anode i offset])") | |
| -cache-protocol-fn (dict | |
| arglists "([pf x c interf])") | |
| -reset-methods (dict | |
| arglists "([protocol])") | |
| .. (dict | |
| arglists "([x form] [x form & more])" | |
| macro "true") | |
| / (dict | |
| arglists "([x] [x y] [x y & more])") | |
| < (dict | |
| arglists "([x] [x y] [x y & more])") | |
| <= (dict | |
| arglists "([x] [x y] [x y & more])") | |
| = (dict | |
| arglists "([x] [x y] [x y & more])") | |
| == (dict | |
| arglists "([x] [x y] [x y & more])") | |
| > (dict | |
| arglists "([x] [x y] [x y & more])") | |
| >0? (dict | |
| arglists "([n])") | |
| >1? (dict | |
| arglists "([n])") | |
| >= (dict | |
| arglists "([x] [x y] [x y & more])") | |
| EMPTY-NODE (dict) | |
| Throwable->map (dict | |
| arglists "([o])") | |
| accessor (dict | |
| arglists "([s key])") | |
| aclone (dict | |
| arglists "([array])") | |
| add-annotation (dict | |
| arglists "([av name v])") | |
| add-annotations (dict | |
| arglists "([visitor m] [visitor m i])") | |
| add-classpath (dict | |
| arglists "([url])") | |
| add-doc-and-meta (dict | |
| arglists "([name docstring meta])" | |
| macro "true") | |
| add-watch (dict | |
| arglists "([reference key fn])") | |
| agent (dict | |
| arglists "([state & options])") | |
| agent-error (dict | |
| arglists "([a])") | |
| agent-errors (dict | |
| arglists "([a])") | |
| aget (dict | |
| arglists "([array idx] [array idx & idxs])") | |
| alength (dict | |
| arglists "([array])") | |
| alias (dict | |
| arglists "([alias namespace-sym])") | |
| all-ns (dict | |
| arglists "([])") | |
| alter (dict | |
| arglists "([ref fun & args])") | |
| alter-meta! (dict | |
| arglists "([iref f & args])") | |
| alter-var-root (dict | |
| arglists "([v f & args])") | |
| amap (dict | |
| arglists "([a idx ret expr])" | |
| macro "true") | |
| ams (dict) | |
| ancestors (dict | |
| arglists "([tag] [h tag])") | |
| and (dict | |
| arglists "([] [x] [x & next])" | |
| macro "true") | |
| apply (dict | |
| arglists "([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args])") | |
| areduce (dict | |
| arglists "([a idx ret init expr])" | |
| macro "true") | |
| array (dict | |
| arglists "([& items])") | |
| array-map (dict | |
| arglists "([] [& keyvals])") | |
| as-> (dict | |
| arglists "([expr name & forms])" | |
| macro "true") | |
| aset (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-boolean (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-byte (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-char (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-double (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-float (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-int (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-long (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| aset-short (dict | |
| arglists "([array idx val] [array idx idx2 & idxv])") | |
| asm-type (dict | |
| arglists "([c])") | |
| assert (dict | |
| arglists "([x] [x message])" | |
| macro "true") | |
| assert-args (dict | |
| arglists "([& pairs])" | |
| macro "true") | |
| assert-same-protocol (dict | |
| arglists "([protocol-var method-syms])") | |
| assert-valid-fdecl (dict | |
| arglists "([fdecl])") | |
| assoc (dict | |
| arglists "([map key val] [map key val & kvs])") | |
| assoc! (dict | |
| arglists "([coll key val] [coll key val & kvs])") | |
| assoc-in (dict | |
| arglists "([m [k & ks] v])") | |
| associative? (dict | |
| arglists "([coll])") | |
| atom (dict | |
| arglists "([x] [x & options])") | |
| await (dict | |
| arglists "([& agents])") | |
| await-for (dict | |
| arglists "([timeout-ms & agents])") | |
| await1 (dict | |
| arglists "([a])") | |
| bases (dict | |
| arglists "([c])") | |
| bean (dict | |
| arglists "([x])") | |
| bigdec (dict | |
| arglists "([x])") | |
| bigint (dict | |
| arglists "([x])") | |
| biginteger (dict | |
| arglists "([x])") | |
| binding (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| binding-conveyor-fn (dict | |
| arglists "([f])") | |
| bit-and (dict | |
| arglists "([x y] [x y & more])") | |
| bit-and-not (dict | |
| arglists "([x y] [x y & more])") | |
| bit-clear (dict | |
| arglists "([x n])") | |
| bit-flip (dict | |
| arglists "([x n])") | |
| bit-not (dict | |
| arglists "([x])") | |
| bit-or (dict | |
| arglists "([x y] [x y & more])") | |
| bit-set (dict | |
| arglists "([x n])") | |
| bit-shift-left (dict | |
| arglists "([x n])") | |
| bit-shift-right (dict | |
| arglists "([x n])") | |
| bit-test (dict | |
| arglists "([x n])") | |
| bit-xor (dict | |
| arglists "([x y] [x y & more])") | |
| boolean (dict | |
| arglists "([x])") | |
| boolean-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| booleans (dict | |
| arglists "([xs])") | |
| bound-fn (dict | |
| arglists "([& fntail])" | |
| macro "true") | |
| bound-fn* (dict | |
| arglists "([f])") | |
| bound? (dict | |
| arglists "([& vars])") | |
| build-positional-factory (dict | |
| arglists "([nom classname fields])") | |
| butlast (dict | |
| arglists "([coll])") | |
| byte (dict | |
| arglists "([x])") | |
| byte-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| bytes (dict | |
| arglists "([xs])") | |
| case (dict | |
| arglists "([e & clauses])" | |
| macro "true") | |
| case-map (dict | |
| arglists "([case-f test-f tests thens])") | |
| cast (dict | |
| arglists "([c x])") | |
| cat (dict | |
| arglists "([rf])") | |
| char (dict | |
| arglists "([x])") | |
| char-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| char-escape-string (dict) | |
| char-name-string (dict) | |
| char? (dict | |
| arglists "([x])") | |
| chars (dict | |
| arglists "([xs])") | |
| check-cyclic-dependency (dict | |
| arglists "([path])") | |
| check-valid-options (dict | |
| arglists "([options & valid-keys])") | |
| chunk (dict | |
| arglists "([b])") | |
| chunk-append (dict | |
| arglists "([b x])") | |
| chunk-buffer (dict | |
| arglists "([capacity])") | |
| chunk-cons (dict | |
| arglists "([chunk rest])") | |
| chunk-first (dict | |
| arglists "([s])") | |
| chunk-next (dict | |
| arglists "([s])") | |
| chunk-rest (dict | |
| arglists "([s])") | |
| chunked-seq? (dict | |
| arglists "([s])") | |
| class (dict | |
| arglists "([x])") | |
| class? (dict | |
| arglists "([x])") | |
| clear-agent-errors (dict | |
| arglists "([a])") | |
| clojure-version (dict | |
| arglists "([])") | |
| coll? (dict | |
| arglists "([x])") | |
| comment (dict | |
| arglists "([& body])" | |
| macro "true") | |
| commute (dict | |
| arglists "([ref fun & args])") | |
| comp (dict | |
| arglists "([] [f] [f g] [f g & fs])") | |
| comparator (dict | |
| arglists "([pred])") | |
| compare (dict | |
| arglists "([x y])") | |
| compare-and-set! (dict | |
| arglists "([atom oldval newval])") | |
| compile (dict | |
| arglists "([lib])") | |
| complement (dict | |
| arglists "([f])") | |
| completing (dict | |
| arglists "([f] [f cf])") | |
| concat (dict | |
| arglists "([] [x] [x y] [x y & zs])") | |
| cond (dict | |
| arglists "([& clauses])" | |
| macro "true") | |
| cond-> (dict | |
| arglists "([expr & clauses])" | |
| macro "true") | |
| cond->> (dict | |
| arglists "([expr & clauses])" | |
| macro "true") | |
| condp (dict | |
| arglists "([pred expr & clauses])" | |
| macro "true") | |
| conj (dict | |
| arglists "([coll x] [coll x & xs])") | |
| conj! (dict | |
| arglists "([] [coll] [coll x])") | |
| cons (dict | |
| arglists "([x seq])") | |
| constantly (dict | |
| arglists "([x])") | |
| construct-proxy (dict | |
| arglists "([c & ctor-args])") | |
| contains? (dict | |
| arglists "([coll key])") | |
| count (dict | |
| arglists "([coll])") | |
| counted? (dict | |
| arglists "([coll])") | |
| create-ns (dict | |
| arglists "([sym])") | |
| create-struct (dict | |
| arglists "([& keys])") | |
| ctor-sigs (dict | |
| arglists "([super])") | |
| cycle (dict | |
| arglists "([coll])") | |
| data-reader-urls (dict | |
| arglists "([])") | |
| data-reader-var (dict | |
| arglists "([sym])") | |
| dec (dict | |
| arglists "([x])") | |
| dec' (dict | |
| arglists "([x])") | |
| decimal? (dict | |
| arglists "([n])") | |
| declare (dict | |
| arglists "([& names])" | |
| macro "true") | |
| dedupe (dict | |
| arglists "([] [coll])") | |
| def-aset (dict | |
| arglists "([name method coerce])" | |
| macro "true") | |
| default-data-readers (dict) | |
| definline (dict | |
| arglists "([name & decl])" | |
| macro "true") | |
| definterface (dict | |
| arglists "([name & sigs])" | |
| macro "true") | |
| defmacro (dict | |
| arglists "([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])" | |
| macro "true") | |
| defmethod (dict | |
| arglists "([multifn dispatch-val & fn-tail])" | |
| macro "true") | |
| defmulti (dict | |
| arglists "([name docstring? attr-map? dispatch-fn & options])" | |
| macro "true") | |
| defn (dict | |
| arglists "([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?])" | |
| macro "true") | |
| defn- (dict | |
| arglists "([name & decls])" | |
| macro "true") | |
| defonce (dict | |
| arglists "([name expr])" | |
| macro "true") | |
| defprotocol (dict | |
| arglists "([name & opts+sigs])" | |
| macro "true") | |
| defrecord (dict | |
| arglists "([name [& fields] & opts+specs])" | |
| macro "true") | |
| defstruct (dict | |
| arglists "([name & keys])" | |
| macro "true") | |
| deftype (dict | |
| arglists "([name [& fields] & opts+specs])" | |
| macro "true") | |
| delay (dict | |
| arglists "([& body])" | |
| macro "true") | |
| delay? (dict | |
| arglists "([x])") | |
| deliver (dict | |
| arglists "([promise val])") | |
| denominator (dict | |
| arglists "([r])") | |
| deref (dict | |
| arglists "([ref] [ref timeout-ms timeout-val])") | |
| deref-as-map (dict | |
| arglists "([o])") | |
| deref-future (dict | |
| arglists "([fut] [fut timeout-ms timeout-val])") | |
| derive (dict | |
| arglists "([tag parent] [h tag parent])") | |
| descendants (dict | |
| arglists "([tag] [h tag])") | |
| descriptor (dict | |
| arglists "([c])") | |
| destructure (dict | |
| arglists "([bindings])") | |
| disj (dict | |
| arglists "([set] [set key] [set key & ks])") | |
| disj! (dict | |
| arglists "([set] [set key] [set key & ks])") | |
| dissoc (dict | |
| arglists "([map] [map key] [map key & ks])") | |
| dissoc! (dict | |
| arglists "([map key] [map key & ks])") | |
| distinct (dict | |
| arglists "([] [coll])") | |
| distinct? (dict | |
| arglists "([x] [x y] [x y & more])") | |
| doall (dict | |
| arglists "([coll] [n coll])") | |
| dorun (dict | |
| arglists "([coll] [n coll])") | |
| doseq (dict | |
| arglists "([seq-exprs & body])" | |
| macro "true") | |
| dosync (dict | |
| arglists "([& exprs])" | |
| macro "true") | |
| dotimes (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| doto (dict | |
| arglists "([x & forms])" | |
| macro "true") | |
| double (dict | |
| arglists "([x])") | |
| double-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| doubles (dict | |
| arglists "([xs])") | |
| drop (dict | |
| arglists "([n] [n coll])") | |
| drop-last (dict | |
| arglists "([s] [n s])") | |
| drop-while (dict | |
| arglists "([pred] [pred coll])") | |
| eduction (dict | |
| arglists "([xform* coll])") | |
| emit-defrecord (dict | |
| arglists "([tagname name fields interfaces methods])") | |
| emit-deftype* (dict | |
| arglists "([tagname name fields interfaces methods])") | |
| emit-extend-protocol (dict | |
| arglists "([p specs])") | |
| emit-extend-type (dict | |
| arglists "([c specs])") | |
| emit-hinted-impl (dict | |
| arglists "([c [p fs]])") | |
| emit-impl (dict | |
| arglists "([[p fs]])") | |
| emit-method-builder (dict | |
| arglists "([on-interface method on-method arglists])") | |
| emit-protocol (dict | |
| arglists "([name opts+sigs])") | |
| empty (dict | |
| arglists "([coll])") | |
| empty? (dict | |
| arglists "([coll])") | |
| ensure (dict | |
| arglists "([ref])") | |
| ensure-reduced (dict | |
| arglists "([x])") | |
| enumeration-seq (dict | |
| arglists "([e])") | |
| error-handler (dict | |
| arglists "([a])") | |
| error-mode (dict | |
| arglists "([a])") | |
| escape-class-name (dict | |
| arglists "([c])") | |
| eval (dict | |
| arglists "([form])") | |
| even? (dict | |
| arglists "([n])") | |
| every-pred (dict | |
| arglists "([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])") | |
| every? (dict | |
| arglists "([pred coll])") | |
| ex-data (dict | |
| arglists "([ex])") | |
| ex-info (dict | |
| arglists "([msg map] [msg map cause])") | |
| expand-method-impl-cache (dict | |
| arglists "([cache c f])") | |
| extend (dict | |
| arglists "([atype & proto+mmaps])") | |
| extend-protocol (dict | |
| arglists "([p & specs])" | |
| macro "true") | |
| extend-type (dict | |
| arglists "([t & specs])" | |
| macro "true") | |
| extenders (dict | |
| arglists "([protocol])") | |
| extends? (dict | |
| arglists "([protocol atype])") | |
| false? (dict | |
| arglists "([x])") | |
| ffirst (dict | |
| arglists "([x])") | |
| file-seq (dict | |
| arglists "([dir])") | |
| filter (dict | |
| arglists "([pred] [pred coll])") | |
| filter-key (dict | |
| arglists "([keyfn pred amap])") | |
| filter-methods (dict | |
| arglists "([c invalid-method?])") | |
| filterv (dict | |
| arglists "([pred coll])") | |
| find (dict | |
| arglists "([map key])") | |
| find-field (dict | |
| arglists "([c f])") | |
| find-keyword (dict | |
| arglists "([name] [ns name])") | |
| find-ns (dict | |
| arglists "([sym])") | |
| find-protocol-impl (dict | |
| arglists "([protocol x])") | |
| find-protocol-method (dict | |
| arglists "([protocol methodk x])") | |
| find-var (dict | |
| arglists "([sym])") | |
| first (dict | |
| arglists "([coll])") | |
| fits-table? (dict | |
| arglists "([ints])") | |
| flatten (dict | |
| arglists "([x])") | |
| float (dict | |
| arglists "([x])") | |
| float-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| float? (dict | |
| arglists "([n])") | |
| floats (dict | |
| arglists "([xs])") | |
| flush (dict | |
| arglists "([])") | |
| fn (dict | |
| arglists "([& sigs])" | |
| macro "true") | |
| fn? (dict | |
| arglists "([x])") | |
| fnext (dict | |
| arglists "([x])") | |
| fnil (dict | |
| arglists "([f x] [f x y] [f x y z])") | |
| for (dict | |
| arglists "([seq-exprs body-expr])" | |
| macro "true") | |
| force (dict | |
| arglists "([x])") | |
| format (dict | |
| arglists "([fmt & args])") | |
| frequencies (dict | |
| arglists "([coll])") | |
| future (dict | |
| arglists "([& body])" | |
| macro "true") | |
| future-call (dict | |
| arglists "([f])") | |
| future-cancel (dict | |
| arglists "([f])") | |
| future-cancelled? (dict | |
| arglists "([f])") | |
| future-done? (dict | |
| arglists "([f])") | |
| future? (dict | |
| arglists "([x])") | |
| gen-class (dict | |
| arglists "([& options])" | |
| macro "true") | |
| gen-interface (dict | |
| arglists "([& options])" | |
| macro "true") | |
| generate-class (dict | |
| arglists "([options-map])") | |
| generate-interface (dict | |
| arglists "([{:keys [name extends methods]}])") | |
| generate-proxy (dict | |
| arglists "([super interfaces])") | |
| gensym (dict | |
| arglists "([] [prefix-string])") | |
| get (dict | |
| arglists "([map key] [map key not-found])") | |
| get-in (dict | |
| arglists "([m ks] [m ks not-found])") | |
| get-method (dict | |
| arglists "([multifn dispatch-val])") | |
| get-proxy-class (dict | |
| arglists "([& bases])") | |
| get-super-and-interfaces (dict | |
| arglists "([bases])") | |
| get-thread-bindings (dict | |
| arglists "([])") | |
| get-validator (dict | |
| arglists "([iref])") | |
| global-hierarchy (dict) | |
| group-by (dict | |
| arglists "([f coll])") | |
| group-by-sig (dict | |
| arglists "([coll])") | |
| hash (dict | |
| arglists "([x])") | |
| hash-combine (dict | |
| arglists "([x y])") | |
| hash-map (dict | |
| arglists "([] [& keyvals])") | |
| hash-ordered-coll (dict | |
| arglists "([coll])") | |
| hash-set (dict | |
| arglists "([] [& keys])") | |
| hash-unordered-coll (dict | |
| arglists "([coll])") | |
| identical? (dict | |
| arglists "([x y])") | |
| identity (dict | |
| arglists "([x])") | |
| if-let (dict | |
| arglists "([bindings then] [bindings then else & oldform])" | |
| macro "true") | |
| if-not (dict | |
| arglists "([test then] [test then else])" | |
| macro "true") | |
| if-some (dict | |
| arglists "([bindings then] [bindings then else & oldform])" | |
| macro "true") | |
| ifn? (dict | |
| arglists "([x])") | |
| imap-cons (dict | |
| arglists "([this o])") | |
| implements? (dict | |
| arglists "([protocol atype])") | |
| import (dict | |
| arglists "([& import-symbols-or-lists])" | |
| macro "true") | |
| in-ns (dict | |
| arglists "([name])") | |
| inc (dict | |
| arglists "([x])") | |
| inc' (dict | |
| arglists "([x])") | |
| init-proxy (dict | |
| arglists "([proxy mappings])") | |
| instance? (dict | |
| arglists "([c x])") | |
| int (dict | |
| arglists "([x])") | |
| int-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| integer? (dict | |
| arglists "([n])") | |
| interleave (dict | |
| arglists "([] [c1] [c1 c2] [c1 c2 & colls])") | |
| intern (dict | |
| arglists "([ns name] [ns name val])") | |
| interpose (dict | |
| arglists "([sep] [sep coll])") | |
| into (dict | |
| arglists "([to from] [to xform from])") | |
| into-array (dict | |
| arglists "([aseq] [type aseq])") | |
| into1 (dict | |
| arglists "([to from])") | |
| ints (dict | |
| arglists "([xs])") | |
| io! (dict | |
| arglists "([& body])" | |
| macro "true") | |
| is-annotation? (dict | |
| arglists "([c])") | |
| is-runtime-annotation? (dict | |
| arglists "([c])") | |
| isa? (dict | |
| arglists "([child parent] [h child parent])") | |
| iterate (dict | |
| arglists "([f x])") | |
| iterator-seq (dict | |
| arglists "([iter])") | |
| juxt (dict | |
| arglists "([f] [f g] [f g h] [f g h & fs])") | |
| keep (dict | |
| arglists "([f] [f coll])") | |
| keep-indexed (dict | |
| arglists "([f] [f coll])") | |
| key (dict | |
| arglists "([e])") | |
| keys (dict | |
| arglists "([map])") | |
| keyword (dict | |
| arglists "([name] [ns name])") | |
| keyword? (dict | |
| arglists "([x])") | |
| last (dict | |
| arglists "([coll])") | |
| lazy-cat (dict | |
| arglists "([& colls])" | |
| macro "true") | |
| lazy-seq (dict | |
| arglists "([& body])" | |
| macro "true") | |
| let (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| letfn (dict | |
| arglists "([fnspecs & body])" | |
| macro "true") | |
| libspec? (dict | |
| arglists "([x])") | |
| line-seq (dict | |
| arglists "([rdr])") | |
| list (dict | |
| arglists "([& items])") | |
| list* (dict | |
| arglists "([args] [a args] [a b args] [a b c args] [a b c d & more])") | |
| list? (dict | |
| arglists "([x])") | |
| load (dict | |
| arglists "([& paths])") | |
| load-all (dict | |
| arglists "([lib need-ns require])") | |
| load-data-reader-file (dict | |
| arglists "([mappings url])") | |
| load-data-readers (dict | |
| arglists "([])") | |
| load-file (dict | |
| arglists "([name])") | |
| load-lib (dict | |
| arglists "([prefix lib & options])") | |
| load-libs (dict | |
| arglists "([& args])") | |
| load-one (dict | |
| arglists "([lib need-ns require])") | |
| load-reader (dict | |
| arglists "([rdr])") | |
| load-string (dict | |
| arglists "([s])") | |
| loaded-libs (dict | |
| arglists "([])") | |
| locking (dict | |
| arglists "([x & body])" | |
| macro "true") | |
| long (dict | |
| arglists "([x])") | |
| long-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| longs (dict | |
| arglists "([xs])") | |
| loop (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| macroexpand (dict | |
| arglists "([form])") | |
| macroexpand-1 (dict | |
| arglists "([form])") | |
| make-array (dict | |
| arglists "([type len] [type dim & more-dims])") | |
| make-hierarchy (dict | |
| arglists "([])") | |
| map (dict | |
| arglists "([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])") | |
| map-indexed (dict | |
| arglists "([f] [f coll])") | |
| map? (dict | |
| arglists "([x])") | |
| mapcat (dict | |
| arglists "([f] [f & colls])") | |
| mapv (dict | |
| arglists "([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])") | |
| max (dict | |
| arglists "([x] [x y] [x y & more])") | |
| max-key (dict | |
| arglists "([k x] [k x y] [k x y & more])") | |
| max-mask-bits (dict) | |
| max-switch-table-size (dict) | |
| maybe-destructured (dict | |
| arglists "([params body])") | |
| maybe-min-hash (dict | |
| arglists "([hashes])") | |
| memfn (dict | |
| arglists "([name & args])" | |
| macro "true") | |
| memoize (dict | |
| arglists "([f])") | |
| merge (dict | |
| arglists "([& maps])") | |
| merge-hash-collisions (dict | |
| arglists "([expr-sym default tests thens])") | |
| merge-with (dict | |
| arglists "([f & maps])") | |
| meta (dict | |
| arglists "([obj])") | |
| method-sig (dict | |
| arglists "([meth])") | |
| methods (dict | |
| arglists "([multifn])") | |
| min (dict | |
| arglists "([x] [x y] [x y & more])") | |
| min-key (dict | |
| arglists "([k x] [k x y] [k x y & more])") | |
| mix-collection-hash (dict | |
| arglists "([hash-basis count])") | |
| mk-am (dict | |
| arglists "([t])" | |
| macro "true") | |
| mk-bound-fn (dict | |
| arglists "([sc test key])") | |
| mod (dict | |
| arglists "([num div])") | |
| most-specific (dict | |
| arglists "([rtypes])") | |
| munge (dict | |
| arglists "([s])") | |
| name (dict | |
| arglists "([x])") | |
| namespace (dict | |
| arglists "([x])") | |
| namespace-munge (dict | |
| arglists "([ns])") | |
| nary-inline (dict | |
| arglists "([op] [op unchecked-op])") | |
| neg? (dict | |
| arglists "([x])") | |
| newline (dict | |
| arglists "([])") | |
| next (dict | |
| arglists "([coll])") | |
| nfirst (dict | |
| arglists "([x])") | |
| nil? (dict | |
| arglists "([x])") | |
| nnext (dict | |
| arglists "([x])") | |
| non-private-methods (dict | |
| arglists "([c])") | |
| normalize-slurp-opts (dict | |
| arglists "([opts])") | |
| not (dict | |
| arglists "([x])") | |
| not-any? (dict | |
| arglists "([pred coll])") | |
| not-empty (dict | |
| arglists "([coll])") | |
| not-every? (dict | |
| arglists "([pred coll])") | |
| not= (dict | |
| arglists "([x] [x y] [x y & more])") | |
| ns (dict | |
| arglists "([name docstring? attr-map? references*])" | |
| macro "true") | |
| ns-aliases (dict | |
| arglists "([ns])") | |
| ns-imports (dict | |
| arglists "([ns])") | |
| ns-interns (dict | |
| arglists "([ns])") | |
| ns-map (dict | |
| arglists "([ns])") | |
| ns-name (dict | |
| arglists "([ns])") | |
| ns-publics (dict | |
| arglists "([ns])") | |
| ns-refers (dict | |
| arglists "([ns])") | |
| ns-resolve (dict | |
| arglists "([ns sym] [ns env sym])") | |
| ns-unalias (dict | |
| arglists "([ns sym])") | |
| ns-unmap (dict | |
| arglists "([ns sym])") | |
| nth (dict | |
| arglists "([coll index] [coll index not-found])") | |
| nthnext (dict | |
| arglists "([coll n])") | |
| nthrest (dict | |
| arglists "([coll n])") | |
| num (dict | |
| arglists "([x])") | |
| number? (dict | |
| arglists "([x])") | |
| numerator (dict | |
| arglists "([r])") | |
| object-array (dict | |
| arglists "([size-or-seq])") | |
| odd? (dict | |
| arglists "([n])") | |
| or (dict | |
| arglists "([] [x] [x & next])" | |
| macro "true") | |
| overload-name (dict | |
| arglists "([mname pclasses])") | |
| parents (dict | |
| arglists "([tag] [h tag])") | |
| parse-impls (dict | |
| arglists "([specs])") | |
| parse-opts (dict | |
| arglists "([s])") | |
| parse-opts+specs (dict | |
| arglists "([opts+specs])") | |
| partial (dict | |
| arglists "([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more])") | |
| partition (dict | |
| arglists "([n coll] [n step coll] [n step pad coll])") | |
| partition-all (dict | |
| arglists "([n] [n coll] [n step coll])") | |
| partition-by (dict | |
| arglists "([f] [f coll])") | |
| pcalls (dict | |
| arglists "([& fns])") | |
| peek (dict | |
| arglists "([coll])") | |
| persistent! (dict | |
| arglists "([coll])") | |
| pmap (dict | |
| arglists "([f coll] [f coll & colls])") | |
| pop (dict | |
| arglists "([coll])") | |
| pop! (dict | |
| arglists "([coll])") | |
| pop-thread-bindings (dict | |
| arglists "([])") | |
| pos? (dict | |
| arglists "([x])") | |
| pr (dict | |
| arglists "([] [x] [x & more])") | |
| pr-on (dict | |
| arglists "([x w])") | |
| pr-str (dict | |
| arglists "([& xs])") | |
| pref (dict | |
| arglists "([] [a] [a b])") | |
| prefer-method (dict | |
| arglists "([multifn dispatch-val-x dispatch-val-y])") | |
| prefers (dict | |
| arglists "([multifn])") | |
| prep-hashes (dict | |
| arglists "([expr-sym default tests thens])") | |
| prep-ints (dict | |
| arglists "([tests thens])") | |
| prependss (dict | |
| arglists "([x coll])") | |
| preserving-reduced (dict | |
| arglists "([rf])") | |
| prim->class (dict) | |
| primitives-classnames (dict) | |
| print (dict | |
| arglists "([& more])") | |
| print-ctor (dict | |
| arglists "([o print-args w])") | |
| print-dup (dict) | |
| print-initialized (dict) | |
| print-map (dict | |
| arglists "([m print-one w])") | |
| print-meta (dict | |
| arglists "([o w])") | |
| print-method (dict) | |
| print-object (dict | |
| arglists "([o w])") | |
| print-sequential (dict | |
| arglists "([begin print-one sep end sequence w])") | |
| print-simple (dict | |
| arglists "([o w])") | |
| print-str (dict | |
| arglists "([& xs])") | |
| print-tagged-object (dict | |
| arglists "([o rep w])") | |
| print-throwable (dict | |
| arglists "([o w])") | |
| printf (dict | |
| arglists "([fmt & args])") | |
| println (dict | |
| arglists "([& more])") | |
| println-str (dict | |
| arglists "([& xs])") | |
| prn (dict | |
| arglists "([& more])") | |
| prn-str (dict | |
| arglists "([& xs])") | |
| process-annotation (dict | |
| arglists "([av v])") | |
| promise (dict | |
| arglists "([])") | |
| protected-final-methods (dict | |
| arglists "([c])") | |
| protocol? (dict | |
| arglists "([maybe-p])") | |
| proxy (dict | |
| arglists "([class-and-interfaces args & fs])" | |
| macro "true") | |
| proxy-call-with-super (dict | |
| arglists "([call this meth])") | |
| proxy-mappings (dict | |
| arglists "([proxy])") | |
| proxy-name (dict | |
| arglists "([super interfaces])") | |
| proxy-super (dict | |
| arglists "([meth & args])" | |
| macro "true") | |
| push-thread-bindings (dict | |
| arglists "([bindings])") | |
| pvalues (dict | |
| arglists "([& exprs])" | |
| macro "true") | |
| quot (dict | |
| arglists "([num div])") | |
| rand (dict | |
| arglists "([] [n])") | |
| rand-int (dict | |
| arglists "([n])") | |
| rand-nth (dict | |
| arglists "([coll])") | |
| random-sample (dict | |
| arglists "([prob] [prob coll])") | |
| range (dict | |
| arglists "([] [end] [start end] [start end step])") | |
| ratio? (dict | |
| arglists "([n])") | |
| rational? (dict | |
| arglists "([n])") | |
| rationalize (dict | |
| arglists "([num])") | |
| re-find (dict | |
| arglists "([m] [re s])") | |
| re-groups (dict | |
| arglists "([m])") | |
| re-matcher (dict | |
| arglists "([re s])") | |
| re-matches (dict | |
| arglists "([re s])") | |
| re-pattern (dict | |
| arglists "([s])") | |
| re-seq (dict | |
| arglists "([re s])") | |
| read (dict | |
| arglists "([] [stream] [stream eof-error? eof-value] [stream eof-error? eof-value recursive?] [opts stream])") | |
| read-line (dict | |
| arglists "([])") | |
| read-string (dict | |
| arglists "([s] [opts s])") | |
| reader-conditional (dict | |
| arglists "([form splicing?])") | |
| reader-conditional? (dict | |
| arglists "([value])") | |
| realized? (dict | |
| arglists "([x])") | |
| record? (dict | |
| arglists "([x])") | |
| reduce (dict | |
| arglists "([f coll] [f val coll])") | |
| reduce-kv (dict | |
| arglists "([f init coll])") | |
| reduce1 (dict | |
| arglists "([f coll] [f val coll])") | |
| reduced (dict | |
| arglists "([x])") | |
| reduced? (dict | |
| arglists "([x])") | |
| reductions (dict | |
| arglists "([f coll] [f init coll])") | |
| ref (dict | |
| arglists "([x] [x & options])") | |
| ref-history-count (dict | |
| arglists "([ref])") | |
| ref-max-history (dict | |
| arglists "([ref] [ref n])") | |
| ref-min-history (dict | |
| arglists "([ref] [ref n])") | |
| ref-set (dict | |
| arglists "([ref val])") | |
| refer (dict | |
| arglists "([ns-sym & filters])") | |
| refer-clojure (dict | |
| arglists "([& filters])" | |
| macro "true") | |
| reify (dict | |
| arglists "([& opts+specs])" | |
| macro "true") | |
| release-pending-sends (dict | |
| arglists "([])") | |
| rem (dict | |
| arglists "([num div])") | |
| remove (dict | |
| arglists "([pred] [pred coll])") | |
| remove-all-methods (dict | |
| arglists "([multifn])") | |
| remove-method (dict | |
| arglists "([multifn dispatch-val])") | |
| remove-ns (dict | |
| arglists "([sym])") | |
| remove-watch (dict | |
| arglists "([reference key])") | |
| repeat (dict | |
| arglists "([x] [n x])") | |
| repeatedly (dict | |
| arglists "([f] [n f])") | |
| replace (dict | |
| arglists "([smap] [smap coll])") | |
| replicate (dict | |
| arglists "([n x])") | |
| require (dict | |
| arglists "([& args])") | |
| reset! (dict | |
| arglists "([atom newval])") | |
| reset-meta! (dict | |
| arglists "([iref metadata-map])") | |
| resolve (dict | |
| arglists "([sym] [env sym])") | |
| rest (dict | |
| arglists "([coll])") | |
| restart-agent (dict | |
| arglists "([a new-state & options])") | |
| resultset-seq (dict | |
| arglists "([rs])") | |
| reverse (dict | |
| arglists "([coll])") | |
| reversible? (dict | |
| arglists "([coll])") | |
| root-directory (dict | |
| arglists "([lib])") | |
| root-resource (dict | |
| arglists "([lib])") | |
| rseq (dict | |
| arglists "([rev])") | |
| rsubseq (dict | |
| arglists "([sc test key] [sc start-test start-key end-test end-key])") | |
| run! (dict | |
| arglists "([proc coll])") | |
| satisfies? (dict | |
| arglists "([protocol x])") | |
| second (dict | |
| arglists "([x])") | |
| select-keys (dict | |
| arglists "([map keyseq])") | |
| send (dict | |
| arglists "([a f & args])") | |
| send-off (dict | |
| arglists "([a f & args])") | |
| send-via (dict | |
| arglists "([executor a f & args])") | |
| seq (dict | |
| arglists "([coll])") | |
| seq? (dict | |
| arglists "([x])") | |
| seque (dict | |
| arglists "([s] [n-or-q s])") | |
| sequence (dict | |
| arglists "([coll] [xform coll] [xform coll & colls])") | |
| sequential? (dict | |
| arglists "([coll])") | |
| set (dict | |
| arglists "([coll])") | |
| set-agent-send-executor! (dict | |
| arglists "([executor])") | |
| set-agent-send-off-executor! (dict | |
| arglists "([executor])") | |
| set-error-handler! (dict | |
| arglists "([a handler-fn])") | |
| set-error-mode! (dict | |
| arglists "([a mode-keyword])") | |
| set-validator! (dict | |
| arglists "([iref validator-fn])") | |
| set? (dict | |
| arglists "([x])") | |
| setup-reference (dict | |
| arglists "([r options])") | |
| shift-mask (dict | |
| arglists "([shift mask x])") | |
| short (dict | |
| arglists "([x])") | |
| short-array (dict | |
| arglists "([size-or-seq] [size init-val-or-seq])") | |
| shorts (dict | |
| arglists "([xs])") | |
| shuffle (dict | |
| arglists "([coll])") | |
| shutdown-agents (dict | |
| arglists "([])") | |
| sigs (dict) | |
| slurp (dict | |
| arglists "([f & opts])") | |
| some (dict | |
| arglists "([pred coll])") | |
| some-> (dict | |
| arglists "([expr & forms])" | |
| macro "true") | |
| some->> (dict | |
| arglists "([expr & forms])" | |
| macro "true") | |
| some-fn (dict | |
| arglists "([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])") | |
| some? (dict | |
| arglists "([x])") | |
| sort (dict | |
| arglists "([coll] [comp coll])") | |
| sort-by (dict | |
| arglists "([keyfn coll] [keyfn comp coll])") | |
| sorted-map (dict | |
| arglists "([& keyvals])") | |
| sorted-map-by (dict | |
| arglists "([comparator & keyvals])") | |
| sorted-set (dict | |
| arglists "([& keys])") | |
| sorted-set-by (dict | |
| arglists "([comparator & keys])") | |
| sorted? (dict | |
| arglists "([coll])") | |
| special-symbol? (dict | |
| arglists "([s])") | |
| spit (dict | |
| arglists "([f content & options])") | |
| split-at (dict | |
| arglists "([n coll])") | |
| split-with (dict | |
| arglists "([pred coll])") | |
| spread (dict | |
| arglists "([arglist])") | |
| str (dict | |
| arglists "([] [x] [x & ys])") | |
| string? (dict | |
| arglists "([x])") | |
| struct (dict | |
| arglists "([s & vals])") | |
| struct-map (dict | |
| arglists "([s & inits])") | |
| subs (dict | |
| arglists "([s start] [s start end])") | |
| subseq (dict | |
| arglists "([sc test key] [sc start-test start-key end-test end-key])") | |
| subvec (dict | |
| arglists "([v start] [v start end])") | |
| super-chain (dict | |
| arglists "([c])") | |
| supers (dict | |
| arglists "([class])") | |
| swap! (dict | |
| arglists "([atom f] [atom f x] [atom f x y] [atom f x y & args])") | |
| symbol (dict | |
| arglists "([name] [ns name])") | |
| symbol? (dict | |
| arglists "([x])") | |
| sync (dict | |
| arglists "([flags-ignored-for-now & body])" | |
| macro "true") | |
| system-newline (dict) | |
| tagged-literal (dict | |
| arglists "([tag form])") | |
| tagged-literal? (dict | |
| arglists "([value])") | |
| take (dict | |
| arglists "([n] [n coll])") | |
| take-last (dict | |
| arglists "([n coll])") | |
| take-nth (dict | |
| arglists "([n] [n coll])") | |
| take-while (dict | |
| arglists "([pred] [pred coll])") | |
| test (dict | |
| arglists "([v])") | |
| the-class (dict | |
| arglists "([x])") | |
| the-ns (dict | |
| arglists "([x])") | |
| thread-bound? (dict | |
| arglists "([& vars])") | |
| throw-if (dict | |
| arglists "([pred fmt & args])") | |
| time (dict | |
| arglists "([expr])" | |
| macro "true") | |
| to-array (dict | |
| arglists "([coll])") | |
| to-array-2d (dict | |
| arglists "([coll])") | |
| trampoline (dict | |
| arglists "([f] [f & args])") | |
| transduce (dict | |
| arglists "([xform f coll] [xform f init coll])") | |
| transient (dict | |
| arglists "([coll])") | |
| tree-seq (dict | |
| arglists "([branch? children root])") | |
| true? (dict | |
| arglists "([x])") | |
| type (dict | |
| arglists "([x])") | |
| unchecked-add (dict | |
| arglists "([x y])") | |
| unchecked-add-int (dict | |
| arglists "([x y])") | |
| unchecked-byte (dict | |
| arglists "([x])") | |
| unchecked-char (dict | |
| arglists "([x])") | |
| unchecked-dec (dict | |
| arglists "([x])") | |
| unchecked-dec-int (dict | |
| arglists "([x])") | |
| unchecked-divide-int (dict | |
| arglists "([x y])") | |
| unchecked-double (dict | |
| arglists "([x])") | |
| unchecked-float (dict | |
| arglists "([x])") | |
| unchecked-inc (dict | |
| arglists "([x])") | |
| unchecked-inc-int (dict | |
| arglists "([x])") | |
| unchecked-int (dict | |
| arglists "([x])") | |
| unchecked-long (dict | |
| arglists "([x])") | |
| unchecked-multiply (dict | |
| arglists "([x y])") | |
| unchecked-multiply-int (dict | |
| arglists "([x y])") | |
| unchecked-negate (dict | |
| arglists "([x])") | |
| unchecked-negate-int (dict | |
| arglists "([x])") | |
| unchecked-remainder-int (dict | |
| arglists "([x y])") | |
| unchecked-short (dict | |
| arglists "([x])") | |
| unchecked-subtract (dict | |
| arglists "([x y])") | |
| unchecked-subtract-int (dict | |
| arglists "([x y])") | |
| underive (dict | |
| arglists "([tag parent] [h tag parent])") | |
| unquote (dict) | |
| unquote-splicing (dict) | |
| unreduced (dict | |
| arglists "([x])") | |
| unsigned-bit-shift-right (dict | |
| arglists "([x n])") | |
| update (dict | |
| arglists "([m k f] [m k f x] [m k f x y] [m k f x y z] [m k f x y z & more])") | |
| update-in (dict | |
| arglists "([m [k & ks] f & args])") | |
| update-proxy (dict | |
| arglists "([proxy mappings])") | |
| use (dict | |
| arglists "([& args])") | |
| val (dict | |
| arglists "([e])") | |
| valid-java-method-name (dict | |
| arglists "([s])") | |
| validate-fields (dict | |
| arglists "([fields name])") | |
| validate-generate-class-options (dict | |
| arglists "([{:keys [methods]}])") | |
| vals (dict | |
| arglists "([map])") | |
| var-get (dict | |
| arglists "([x])") | |
| var-set (dict | |
| arglists "([x val])") | |
| var? (dict | |
| arglists "([v])") | |
| vary-meta (dict | |
| arglists "([obj f & args])") | |
| vec (dict | |
| arglists "([coll])") | |
| vector (dict | |
| arglists "([] [a] [a b] [a b c] [a b c d] [a b c d & args])") | |
| vector-of (dict | |
| arglists "([t] [t & elements])") | |
| vector? (dict | |
| arglists "([x])") | |
| volatile! (dict | |
| arglists "([val])") | |
| volatile? (dict | |
| arglists "([x])") | |
| vreset! (dict | |
| arglists "([vol newval])") | |
| vswap! (dict | |
| arglists "([vol f & args])" | |
| macro "true") | |
| when (dict | |
| arglists "([test & body])" | |
| macro "true") | |
| when-first (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| when-let (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| when-not (dict | |
| arglists "([test & body])" | |
| macro "true") | |
| when-some (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| while (dict | |
| arglists "([test & body])" | |
| macro "true") | |
| with-bindings (dict | |
| arglists "([binding-map & body])" | |
| macro "true") | |
| with-bindings* (dict | |
| arglists "([binding-map f & args])") | |
| with-in-str (dict | |
| arglists "([s & body])" | |
| macro "true") | |
| with-loading-context (dict | |
| arglists "([& body])" | |
| macro "true") | |
| with-local-vars (dict | |
| arglists "([name-vals-vec & body])" | |
| macro "true") | |
| with-meta (dict | |
| arglists "([obj m])") | |
| with-open (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| with-out-str (dict | |
| arglists "([& body])" | |
| macro "true") | |
| with-precision (dict | |
| arglists "([precision & exprs])" | |
| macro "true") | |
| with-redefs (dict | |
| arglists "([bindings & body])" | |
| macro "true") | |
| with-redefs-fn (dict | |
| arglists "([binding-map func])") | |
| xml-seq (dict | |
| arglists "([root])") | |
| zero? (dict | |
| arglists "([x])") | |
| zipmap (dict | |
| arglists "([keys vals])"))) | |
| promotable.core (dict | |
| aliases (dict) | |
| interns (dict | |
| ->InputChoice (dict | |
| arglists "([value to-string])") | |
| ->SelectWith (dict | |
| arglists "([widget])") | |
| -main (dict | |
| arglists "([& args])") | |
| ConfigAction (dict) | |
| ConfigIcon (dict) | |
| ConfigModel (dict) | |
| ConfigText (dict) | |
| LayoutOrientationConfig (dict) | |
| SelectionModeConfig (dict) | |
| Showable (dict) | |
| abstract-panel (dict | |
| arglists "([panel layout opts] [layout opts])") | |
| action (dict) | |
| action-option (dict) | |
| add! (dict | |
| arglists "([container subject & more])") | |
| alert (dict | |
| arglists "([& args])") | |
| all-frames (dict | |
| arglists "([])") | |
| apropos (dict | |
| arglists "([str-or-pattern])") | |
| assert-ui-thread (dict | |
| arglists "([message])") | |
| base-resource-options (dict) | |
| border-panel (dict | |
| arglists "([& opts])") | |
| border-panel-options (dict) | |
| box-panel (dict | |
| arglists "([dir & opts])") | |
| box-panel-options (dict) | |
| button (dict | |
| arglists "([& args])") | |
| button-group (dict | |
| arglists "([& opts])") | |
| button-group-options (dict) | |
| button-options (dict) | |
| canvas (dict | |
| arglists "([& opts])") | |
| canvas-options (dict) | |
| card-panel (dict | |
| arglists "([& opts])") | |
| card-panel-options (dict) | |
| checkbox (dict | |
| arglists "([& args])") | |
| checkbox-menu-item (dict | |
| arglists "([& args])") | |
| checkbox-menu-item-options (dict) | |
| checkbox-options (dict) | |
| combobox (dict | |
| arglists "([& args])") | |
| combobox-options (dict) | |
| config (dict) | |
| config! (dict) | |
| confirm (dict | |
| arglists "([& args])") | |
| construct (dict | |
| arglists "([factory-class & opts])" | |
| macro "true") | |
| custom-dialog (dict | |
| arglists "([& {:keys [width height visible? modal? on-close size], :or {width 100, height 100, visible? false}, :as opts}])") | |
| custom-dialog-options (dict) | |
| default-options (dict) | |
| dialog (dict | |
| arglists "([& {:as opts}])") | |
| dir (dict | |
| arglists "([nsname])" | |
| macro "true") | |
| dispose! (dict | |
| arglists "([targets])") | |
| doc (dict | |
| arglists "([name])" | |
| macro "true") | |
| editor-pane (dict | |
| arglists "([& opts])") | |
| editor-pane-options (dict) | |
| find-doc (dict | |
| arglists "([re-string-or-pattern])") | |
| flow-panel (dict | |
| arglists "([& opts])") | |
| flow-panel-options (dict) | |
| form-panel (dict | |
| arglists "([& opts])") | |
| form-panel-options (dict) | |
| frame (dict | |
| arglists "([& {:keys [width height visible? size], :as opts}])") | |
| frame-options (dict) | |
| full-screen! (dict | |
| arglists "([device window] [window])") | |
| full-screen-window (dict | |
| arglists "([device] [])") | |
| full-screen? (dict | |
| arglists "([device window] [window])") | |
| get-action* (dict | |
| arglists "([this])") | |
| get-drag-enabled (dict | |
| arglists "([this])") | |
| get-icon* (dict | |
| arglists "([this])") | |
| get-layout-orientation* (dict | |
| arglists "([this])") | |
| get-model* (dict | |
| arglists "([this])") | |
| get-selection-mode* (dict | |
| arglists "([this])") | |
| get-text* (dict | |
| arglists "([this])") | |
| grid-bag-panel (dict) | |
| grid-panel (dict | |
| arglists "([& {:keys [rows columns], :as opts}])") | |
| grid-panel-options (dict) | |
| group-by-id (dict | |
| arglists "([root])") | |
| height (dict | |
| arglists "([w])") | |
| hide! (dict | |
| arglists "([targets])") | |
| horizontal-panel (dict | |
| arglists "([& opts])") | |
| horizontal-panel-options (dict) | |
| icon (dict) | |
| id-for (dict) | |
| id-of (dict | |
| arglists "([w])") | |
| input (dict | |
| arglists "([& args])") | |
| invoke-later (dict | |
| arglists "([& args])" | |
| macro "true") | |
| invoke-now (dict | |
| arglists "([& args])" | |
| macro "true") | |
| invoke-soon (dict | |
| arglists "([& args])" | |
| macro "true") | |
| javadoc (dict | |
| arglists "([class-or-object])") | |
| label (dict | |
| arglists "([& args])") | |
| label-options (dict) | |
| left-right-split (dict | |
| arglists "([left right & args])") | |
| left-right-split-options (dict) | |
| listbox (dict | |
| arglists "([& args])") | |
| listbox-options (dict) | |
| listen (dict) | |
| make-widget (dict | |
| arglists "([v])") | |
| map->InputChoice (dict | |
| arglists "([m__6289__auto__])") | |
| map->SelectWith (dict | |
| arglists "([m__6289__auto__])") | |
| menu (dict | |
| arglists "([& opts])") | |
| menu-item (dict | |
| arglists "([& args])") | |
| menu-item-options (dict) | |
| menu-options (dict) | |
| menubar (dict | |
| arglists "([& opts])") | |
| menubar-options (dict) | |
| model-option (dict) | |
| move! (dict | |
| arglists "([target how & [loc]])") | |
| move-by! (dict | |
| arglists "([this dx dy])") | |
| move-to! (dict | |
| arglists "([this x y])") | |
| move-to-back! (dict | |
| arglists "([this])") | |
| move-to-front! (dict | |
| arglists "([this])") | |
| native! (dict | |
| arglists "([])") | |
| pack! (dict | |
| arglists "([targets])") | |
| paintable (dict | |
| arglists "([cls & opts])" | |
| macro "true") | |
| password (dict | |
| arglists "([& opts])") | |
| password-options (dict) | |
| popup (dict | |
| arglists "([& opts])") | |
| popup-options (dict) | |
| pp (dict | |
| arglists "([])" | |
| macro "true") | |
| pprint (dict | |
| arglists "([object] [object writer])") | |
| progress-bar (dict | |
| arglists "([& {:keys [orientation value min max], :as opts}])") | |
| progress-bar-options (dict) | |
| promotable.core.proxy$java.lang.Object$SignalHandler$d8c00ec7 (dict) | |
| pst (dict | |
| arglists "([] [e-or-depth] [e depth])") | |
| radio (dict | |
| arglists "([& args])") | |
| radio-menu-item (dict | |
| arglists "([& args])") | |
| radio-menu-item-options (dict) | |
| radio-options (dict) | |
| remove! (dict | |
| arglists "([container subject & more])") | |
| repaint! (dict | |
| arglists "([targets])") | |
| replace! (dict | |
| arglists "([container old-widget new-widget])") | |
| request-focus! (dict | |
| arglists "([target])") | |
| return-from-dialog (dict | |
| arglists "([dlg result])") | |
| scroll! (dict | |
| arglists "([target modifier arg])") | |
| scrollable (dict | |
| arglists "([target & opts])") | |
| scrollable-options (dict) | |
| seesaw.core.proxy$java.awt.event.ComponentAdapter$ff19274a (dict) | |
| seesaw.core.proxy$javax.swing.JButton$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JCheckBox$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JComboBox$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JDialog$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JEditorPane$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JFrame$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JLabel$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JList$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JMenu$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JMenuBar$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JPanel$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JPasswordField$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JPopupMenu$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JProgressBar$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JRadioButton$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JScrollPane$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JSeparator$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JSlider$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JSpinner$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JSplitPane$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JTabbedPane$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JTable$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JTextArea$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JTextField$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JTextPane$ff19274a (dict) | |
| seesaw.core.proxy$javax.swing.JToggleButton$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JToolBar$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JTree$Tag$fd407141 (dict) | |
| seesaw.core.proxy$javax.swing.JWindow$Tag$fd407141 (dict) | |
| select (dict | |
| arglists "([root selector])") | |
| select-with (dict | |
| arglists "([target])") | |
| selection (dict | |
| arglists "([target] [target options])") | |
| selection! (dict | |
| arglists "([target new-selection] [target opts new-selection])") | |
| separator (dict | |
| arglists "([& opts])") | |
| separator-options (dict) | |
| set-action* (dict | |
| arglists "([this v])") | |
| set-drag-enabled (dict | |
| arglists "([this v])") | |
| set-icon* (dict | |
| arglists "([this v])") | |
| set-layout-orientation* (dict | |
| arglists "([this v])") | |
| set-model* (dict | |
| arglists "([this m])") | |
| set-selection-mode* (dict | |
| arglists "([this v])") | |
| set-text* (dict | |
| arglists "([this v])") | |
| show! (dict | |
| arglists "([targets])") | |
| show-card! (dict | |
| arglists "([panel id])") | |
| slider (dict | |
| arglists "([& {:keys [orientation value min max minor-tick-spacing major-tick-spacing snap-to-ticks? paint-ticks? paint-labels? paint-track? inverted?], :as kw}])") | |
| slider-options (dict) | |
| source (dict | |
| arglists "([n])" | |
| macro "true") | |
| spinner (dict | |
| arglists "([& args])") | |
| spinner-model (dict | |
| arglists "([v & {:keys [from to by]}])") | |
| spinner-options (dict) | |
| splitter (dict | |
| arglists "([dir left right & opts])") | |
| splitter-options (dict) | |
| style-text! (dict | |
| arglists "([target id start length])") | |
| styled-text (dict | |
| arglists "([& args])") | |
| styled-text-options (dict) | |
| tabbed-panel (dict | |
| arglists "([& opts])") | |
| tabbed-panel-options (dict) | |
| table (dict | |
| arglists "([& args])") | |
| table-options (dict) | |
| text (dict | |
| arglists "([& args])") | |
| text! (dict | |
| arglists "([targets value])") | |
| text-area-options (dict) | |
| text-field-options (dict) | |
| text-options (dict) | |
| timer (dict) | |
| to-document (dict | |
| arglists "([v])") | |
| to-frame (dict) | |
| to-root (dict | |
| arglists "([w])") | |
| to-widget (dict | |
| arglists "([v])") | |
| toggle (dict | |
| arglists "([& args])") | |
| toggle-full-screen! (dict | |
| arglists "([device window] [window])") | |
| toggle-options (dict) | |
| toolbar (dict | |
| arglists "([& opts])") | |
| toolbar-options (dict) | |
| top-bottom-split (dict | |
| arglists "([top bottom & args])") | |
| top-bottom-split-options (dict) | |
| tree (dict | |
| arglists "([& args])") | |
| tree-options (dict) | |
| user-data (dict | |
| arglists "([w])") | |
| value (dict | |
| arglists "([target])") | |
| value! (dict | |
| arglists "([target v])") | |
| vertical-panel (dict | |
| arglists "([& opts])") | |
| vertical-panel-options (dict) | |
| visible! (dict | |
| arglists "([this v])") | |
| visible? (dict | |
| arglists "([this])") | |
| width (dict | |
| arglists "([w])") | |
| window (dict | |
| arglists "([& {:keys [width height visible? size], :as opts}])") | |
| window-options (dict) | |
| with-password* (dict | |
| arglists "([field handler])") | |
| with-widgets (dict | |
| arglists "([widgets & body])" | |
| macro "true") | |
| xyz-panel (dict | |
| arglists "([& opts])"))) | |
| reply.exports (dict | |
| aliases (dict) | |
| interns (dict | |
| apropos-better (dict | |
| arglists "([str-or-pattern])") | |
| call-with-ns-and-name (dict | |
| arglists "([f v])") | |
| clojuredocs-available? (dict) | |
| handle-fns-etc (dict | |
| arglists "([name fn])" | |
| macro "true") | |
| help (dict | |
| arglists "([])") | |
| intern-with-meta (dict | |
| arglists "([ns sym value-var])") | |
| lazy-clojuredocs (dict | |
| arglists "([v] [ns-str var-str])" | |
| macro "true") | |
| original-ns (dict) | |
| resolve-class (dict) | |
| unresolve (dict | |
| arglists "([var])"))) | |
| user (dict | |
| aliases (dict) | |
| interns (dict | |
| apropos-better (dict | |
| arglists "([str-or-pattern])") | |
| cdoc (dict | |
| arglists "([v] [ns-str var-str])" | |
| macro "true") | |
| clojuredocs (dict | |
| arglists "([v] [ns-str var-str])" | |
| macro "true") | |
| find-name (dict | |
| arglists "([str-or-pattern])") | |
| help (dict | |
| arglists "([])")))) | |
| id "22" | |
| repl-type "clj" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("state") | |
| ) | |
| (<- | |
| id "24" | |
| ns "promotable.core" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| value "\"0.10.0-snapshot\"" | |
| ) | |
| (<- | |
| id "24" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("done") | |
| ) | |
| (<- | |
| changed-namespaces (dict) | |
| id "23" | |
| repl-type "clj" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("state") | |
| ) | |
| (<- | |
| changed-namespaces (dict) | |
| id "24" | |
| repl-type "clj" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("state") | |
| ) | |
| (---> | |
| ns "promotable.core" | |
| op "eval" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| code "(-main)\n" | |
| id "26" | |
| ) | |
| (<- | |
| id "26" | |
| ns "promotable.core" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| value "nil" | |
| ) | |
| (<- | |
| id "26" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("done") | |
| ) | |
| (<- | |
| changed-namespaces (dict) | |
| id "26" | |
| repl-type "clj" | |
| session "c82858e6-6033-4cc4-b07d-00abc3f86355" | |
| status ("state") | |
| ) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment