like -> but with % as placeholder

(-> 1 inc (- 10 %)) => 8

like ->> but with % as placeholder

(-> 1 inc (- % 10)) => -8

typesafe aget

(aget (int-array 1 2 3) 2) => 3

Allow macros to be applied to arguments just like functions

(applym const ’((+ 1 2))) => 3

(macroexpand ’(applym const ’((+ 1 2)))) => 3

checks if object is a primitive array

(array? (into-array [])) => true

(array? String (into-array “a” “b” “c”)) => true

Returns true if x is of type clojure.lang.Atom.

(atom? (atom nil)) => true

Returns true if x is of type java.math.BigDecimal.

(bigdec? 1M) => true (bigdec? 1.0) => false

Returns true if x is of type clojure.lang.BigInt.

(bigint? 1N) => true (bigint? 1) => false

Returns true if x is of type java.lang.Byte

(byte? (byte 1)) => true

like invoke but reverses the function and first argument

(call 2) => 2

(call 2 + 1 2 3) => 8

gets the current code column

(code-column) => 3

gets the current code line

(code-line) => number?

returns the current namespace the code is in

(code-ns) => ’std.lib.foundation_test

Returns true if x and y both implements java.lang.Comparable.

(comparable? 1 1) => true

concats two seqs as vector

converts an expression into a constant at compile time

(const (+ 1 2)) => 3

(macroexpand ’(const (+ 1 2))) => 3

creates a counter

(pr-str (counter)) => “#counter{-1}”

creates a new date

(date 1000) => #inst “1970-01-01T00:00:01.000-00:00”

decrements the counter

@(doto (counter 10) (dec! 10)) => 0

defs multiple vars

demunges an input to be nicer looking

(demunge ;;; (munge “+test!”) “PLUS_test_BANG”) => “+test!”

prints then reads back the string

((juxt type (comp type edn)) (symbol “:hello”)) => clojure.lang.Symbol clojure.lang.Keyword

checks if an entry is valid edn

(edn? 1) => true

(edn? {}) => true

(edn? (java.util.Date.)) => false

throws an error with message

(error “Error”) => (throws)

returns false for any combination of input args

(F) => false

returns a unique, time incremental id

(flake) ;; “4Wv-T47LftnVlHhhh00JYuU15NCuNLcr” => string?

returns the hash code of an object

returns the actual memory related id for an object

checks if

(ideref? (volatile! 0)) => true (ideref? (promise)) => true

increments the counter

@(doto (counter) (inc!) (inc! 10)) => 10

returns a java.util.Date object

(instant) => #(instance? java.util.Date %)

(instant 0) => #inst “1970-01-01T00:00:00.000-00:00”

adds a namespace to current

creates base form for intern-in and intern-all

(intern-form ’std.lib ’std.lib.foundation/unfold)

adds a function to current

interns a var in sym

provides a caller for the IFn

(invoke (fn [](+ 1 2 3))) => 6

checks if a component is instance of clojure.lang.IObj

(iobj? 1) => false

(iobj? {}) => true

Returns true if x is of type clojure.lang.IRef.

(iref? (atom 0)) => true

returns the keyword value

(keyword :hello) => :hello

(keyword “hello”) => :hello

Returns true if x is of type java.lang.Long

(long? 1) => true (long? 1N) => false

substring from last

(lsubs “hello-world” 4) => “hello-w”

returns nil for any combination of input args

(NIL) => nil

parses a double from string

(parse-double “100”) => 100.0

(parse-double “100.123”) => 100.123

parses a long from string

(parse-long “100”) => 100

Returns true if x implements clojure.lang.IPersistentMap.

(regexp? #“\d+”) => true

resets a counter to the given value

(reset! (counter 10) 5) => 5

resolves a namespaced symbol

sets a var without changing current meta

(std.lib.foundation/set! -lost- 1)

Returns true if x is of type java.lang.Short

(short? (short 1)) => true

returns a short id string

(sid) ;; “t8a6euzk9usy” => string?

creates a string from a byte array

(string (.getBytes “Hello”)) => “Hello”

returns the strn value

(strn :hello) => “hello”

(strn “hello”) => “hello”

Suppresses any errors thrown in the body.

(suppress (throw (ex-info “Error” {}))) => nil

(suppress (throw (ex-info “Error” {})) :error) => :error

(suppress (throw (ex-info “Error” {})) (fn ^Throwable e (.getMessage e))) => “Error”

returns true for any combination of input args

(T) => true

template-entries but for heavy usage

ensures that the templated entries are the same as the input

uses a template function to produce entries

returns the intern template meta

adds a function to current given var and arguments

helper function to ‘->’ and ‘->>’

(thread-form ’(+ 1) dec (fn form(concat form ’%))) => ’(% (+ 1 %) % (dec %))

Returns true is x is a thread

(thread? (Thread/currentThread)) => true

checks that object is a Throwable

(throwable? (ex-info “hello” {})) => true

prints out the item and a program trace

(trace “Error”) => Throwable

U Combinator

((U factorial) 5) => 120

checks if a variable is unbound

(declare -lost-)

(unbound? -lost-) = true

returns a java.net.UrI object

(uri “http://www.google.com”) => java.net.URI

retruns a java.net.URL object

(url “http://www.google.com”) => java.net.URL

Returns true if x is of type java.net.URL.

(url? (java.net.URL. “file:/Users/chris/Development”)) => true

returns a java.util.UUID object

(uuid) => #(instance? java.util.UUID %)

(uuid “00000000-0000-0000-0000-000000000000”) => #uuid “00000000-0000-0000-0000-000000000000”

constructs a nil uuid

converts a var to a symbol

(var-sym #’var-sym) => ’std.lib.foundation/var-sym

gets the exception data in a form

(with-ex (throw (ex-info “Error” {:hello “1”}))) => {:hello “1”}

with retry macro

with a retry function

gets the exception data in a form

(ex-data (with-thrown (throw (ex-info “Error” {:hello “1”})))) => {:hello “1”}

binds the template meta (for testing purposes)

object to display shell result

checks that an object is wrapped

performs xor comparison

(xor true false) => true

Z combinator

((Z factorial) 5) => 120