io.randomseed.utils — io.randomseed/utils 1.2.33

Random support functions and macros.

add-spc-b clj

(add-spc-b s)

Adds space characters to the beginning and end of the given string s if it is not an empty string. Otherwise it returns a string with a single space.

add-spc-l clj

(add-spc-l s)

Prepends space character to the given string s if it is not an empty string.

add-spc-r clj

(add-spc-r s)

Appends space character to the given string s if it is not an empty string or a single space.

ask clj

(ask &
     {:keys [ask-fn allow-empty? empty-nil? empty-quits? empty-quits-nil? prompt
             confirm-prompt not-match-msg empty-msg retries confirmation?]
      :or {confirm-prompt "Repeat text: "
           not-match-msg "Texts do not match."
           empty-msg "Text is empty."
           empty-nil? false
           confirmation? true
           empty-quits-nil? true
           ask-fn read-line-with-prompt
           prompt "Enter text: "
           allow-empty? false
           empty-quits? false}})

Ask user for a string with optional confirmation using ask-fn to get a string (or nil). Repeats until two entered strings are the same and are not empty. Keyword arguments can be given to configure behavior: prompt (message displayed when asking for first string), confirm-prompt (message displayed when asking for the same string again), not-match-msg (message displayed when strings do not match), empty-msg (message displayed when the entered string is empty), retries (number of retries before quitting the loop; when set to nil or not given, it will continue indefinitely), confirmation? (requires string to be re-entered for confirmation, defaults to true), allow-empty? (allows the entered string to be empty; defaults to false), empty-nil? (returns nil instead of an empty string; defaults to false), empty-quits? (short-circuits on any empty string and returns nil; defaults to false), empty-quits-nil? (returns nil when quitting on empty string; defaults to true). Returns the entered string or nil.

atom? clj

(atom? v)

b64-to-bytes clj

(b64-to-bytes s)

Converts Base64 encoded string to array of bytes.

bytes-concat clj

(bytes-concat)

(bytes-concat bary)

(bytes-concat bary & byte-arys)

Concatenates byte arrays.

bytes-to-string clj

(bytes-to-string b)

Converts bytes into a string

bzero clj

Returns zeroed array of bytes.

char-ranges->set clj

(char-ranges->set & ranges)

Returns a set of characters defined as a collection of collections with start and stop character, e.g.: [\A \Z][\0 \9]

const-form? clj

(const-form? x)

Returns true when x is nil or is of one of the following types: string or keyword or boolean or number or character. Otherwise returns false.

contains-some? clj

(contains-some? s1 s2)

Takes two indexed collections and returns true if at least one element is shared in both. Otherwise it returns false.

count-digits clj

(count-digits n)

Returns a number of digits in a decimal number n.

current-thread clj

(current-thread)

current-thread-id clj

(current-thread-id)

current-thread-name clj

(current-thread-name)

defdoc! clj macro

(defdoc! v docstr)

empty-ident? clj

(empty-ident? v)

Returns true if v is an empty identifier.

empty-string? clj

(empty-string? s)

Returns true if s is an empty string. Will throw an exception when s is not a string.

ensure-ident-keyword clj

(ensure-ident-keyword id)

ensure-keyword clj

(ensure-keyword id)

Takes an identifier id and tries to convert it to a keyword. If it is not an identifier, it calls keyword.

ensure-keyword-having-ns clj

(ensure-keyword-having-ns id ns)

ensure-namespaced-keyword clj

(ensure-namespaced-keyword id ns)

ensure-ns clj

(ensure-ns id ns)

Takes an identifier id and a namespace ns (a string), and tries to set a namespace in the identifier. If a namespace already exists in identifier, it is not changed.

ensure-str clj

(ensure-str v)

(ensure-str v & more)

exception? clj

(exception? v)

find-first clj

(find-first f coll)

(find-first f coll not-found)

Returns the first item from coll for which (f item) returns true or nil if no such item is present. If the given not-found value is supplied, it will return it instead of nil.

fn-name clj

(fn-name f)

Tries to obtain symbolic function name for the given function f. Uses metadata and Java reflection as fallback.

gen-digits clj

(gen-digits num)

(gen-digits num rng)

Generates the given number of random digits and converts all into a single string. When the second argument is present it should be an instance of random number generator used to get the digits.

get-rand-int clj

(get-rand-int n)

(get-rand-int n rng)

Like rand-int but optionally uses random number generator.

inferred-contains? clj

(inferred-contains? coll k)

Just like the contains? but if the keyword is namespace-qualified it also checks if the collection contains the same keyword as its key but without a namespace.

inferred-get clj

(inferred-get coll k)

(inferred-get coll k default)

Just like the get function but if the keyword is namespace-qualified it first attempts to look for the value associated with it. If that fails it uses the variant of the keyword without any namespace.

insert-at clj

(insert-at index coll element)

Takes an index number index, a collection coll and an element element, and inserts element's value under the given index number. Uses sequential operations: split-at, concat and cons.

instant? clj

(instant? v)

is clj macro

(is pred val & body)

Takes a predicate pred, a value val and a body. Evaluates val and passes to pred. If the result is truthy it evaluates all expressions from body in an explicit do. Otherwise it returns the value.

is-not clj macro

(is-not pred val & body)

Takes a predicate pred, a value val and a body. Evaluates val and passes to pred. If the result is truthy it returns the value. Otherwise it evaluates all expressions from body in an explicit do.

juxt-seq clj

(juxt-seq & functions)

Like clojure.core/juxt but produces lazy sequence of results instead of a vector.

lazy-iterator-seq clj

(lazy-iterator-seq coll)

(lazy-iterator-seq coll iter)

Returns a lazy sequence as an interface to the given iterable Java object.

mapply clj

(mapply f & args)

Like apply but works on named arguments. Takes function f and a list of arguments to be passed, were the last argument should be a map that will be decomposed and passed as named arguments.

Returns the result of calling f.

must-have-ns clj

(must-have-ns id ns)

named-to-str clj

(named-to-str v)

Converts a value v to a string. If keyword is given, it will have : character removed.

named-to-str-trim clj

(named-to-str-trim v)

Converts a value v to a string and trims its both sides. If keyword is given, it will have : character removed.

nil-or-empty-str? clj

(nil-or-empty-str? x)

Returns true if the given x is nil or an empty string.

nil-spc-or-empty-str clj

(nil-spc-or-empty-str s)

Takes a string or nil object s and returns an empty string if it is nil, empty string or a string containing a single space only.

nil-spc-or-empty-str? clj

(nil-spc-or-empty-str? s)

Returns true if the given value s is nil, an empty string or a string containing a single space only.

normalize-name clj

(normalize-name some-name)

(normalize-name some-name default-name)

Takes a name expressed as a string or an identifier. If the object is an identifier (a symbol or a keyword) then it converts it to a string using name function. If the second argument is present then it uses it when the given name or a name derived from identifier is empty.

normalize-name-with-ns clj

(normalize-name-with-ns some-name)

(normalize-name-with-ns some-name default-name)

Takes a name expressed as a string or an identifier. If the object is an identifier (a symbol or a keyword) then it converts it to a string using namespace and name functions. If the second argument is present then it uses it when the given name or a name derived from identifier is empty.

normalize-to-bytes clj

(normalize-to-bytes t)

not-empty-ident? clj

(not-empty-ident? v)

Returns true if v is not an empty identifier.

not-empty-string? clj

(not-empty-string? s)

Returns true if s is not an empty string. Will throw an exception when s is not a string.

not-valuable clj macro

(not-valuable & more)

not-valuable? clj

(not-valuable? x)

Returns true if x not valuable: is nil or empty.

ns-infer clj

(ns-infer ns-name k)

(ns-infer ns-name k use-infer)

Takes a string of namespace name and a keyword. If the given keyword is not namespace-qualified it returns a new keyword with the given namespace added. If the given keyword is already equipped with a namespace it returns it.

or-some clj macro

(or-some)

(or-some x)

(or-some x & next)

Same as or but returns first value which is strictly not nil.

parse-long clj

(parse-long s)

(parse-long s default)

parse-num clj

(parse-num n)

(parse-num n default)

parse-percent clj

(parse-percent n)

(parse-percent n default)

parse-re clj

(parse-re v)

parse-url clj

(parse-url u)

Parses URL into a map.

percent clj

pos-val clj

(pos-val x)

Returns the given value x if it is a positive number. Otherwise it returns nil.

qsome clj macro

(qsome pred coll)

Same as clojure.core/some but when coll is a constant form then a source code with or expression is generated instead of some with recurrent predicate application.

qstrb clj macro

(qstrb)

(qstrb a)

(qstrb a & more)

Calls strb but checks if the first and only argument is a string, and if it so, returns its literal form without calling strb.

random-digits-len clj

(random-digits-len x iteration shrink-now)

(random-digits-len x iteration shrink-now rng)

For 0 or 1 it returns its argument. For other positive numbers it returns a random natural number from 1 to this number (inclusive) in 50% cases. In other 50% cases it returns its argument.

random-uuid clj

(random-uuid)

read-line-with-prompt clj

(read-line-with-prompt)

(read-line-with-prompt prompt)

Reads a line of text from console with optional prompt. Returns a string or nil when the entered string is empty.

replace-first clj

(replace-first s c r)

Replaces the first appearance of a character c in the given string s with a character r.

safe-parse-long clj

(safe-parse-long v)

(safe-parse-long v default)

safe-parse-num clj

(safe-parse-num v)

(safe-parse-num v default)

safe-parse-percent clj

(safe-parse-percent v)

(safe-parse-percent v default)

sanitize-base-url clj

(sanitize-base-url url)

simple-keyword-up clj

(simple-keyword-up v)

simple-quote-form? clj

(simple-quote-form? x)

Returns true when x is a list or is an instance of clojure.lang.Cons, has 2 elements or less and its first element is the quote symbol, plus its second element is a symbol or const-form? returns true for it.

simple-symbol-up clj

(simple-symbol-up v)

some-fn* clj

(some-fn* p)

(some-fn* p1 p2)

(some-fn* p1 p2 p3)

(some-fn* p1 p2 p3 p4)

(some-fn* p1 p2 p3 p4 & preds)

Same as clojure.core/some-fn but multiple arguments are passed to each predicate function and nullary variant is not returning nil but calls each predicate without passing any arguments.

Takes a set of predicates and returns a function that returns the first truthy value (not nil and not false) returned by one of its composing predicates against all of its arguments, else it returns a value returned by the last predicate given (which may be false or nil).

some-keyword clj

(some-keyword v)

some-keyword-simple clj

(some-keyword-simple v)

some-keyword-up clj

(some-keyword-up v)

some-long clj

(some-long s)

(some-long s default)

some-str clj

(some-str v)

Converts the given value v to a string. Keywords are transformed to strings without the : prefix. Empty string or nil will result in nil being returned.

some-str-down clj

(some-str-down v)

Converts the given value v to a lowercase string. Keywords are transformed to strings without the : prefix. Empty string or nil will result in nil being returned.

some-str-simple clj

(some-str-simple v)

Converts the given value v to a string. If v is an identifier only its name part is used and namespace is ignored. Keywords are transformed to strings without the : prefix. Empty string or nil will result in nil being returned.

some-str-simple-down clj

(some-str-simple-down v)

Converts the given value v to a lowercase string. If v is an identifier only its name part is used and namespace is ignored. Keywords are transformed to strings without the : prefix. Empty string or nil will result in nil being returned.

some-str-simple-up clj

(some-str-simple-up v)

Converts the given value v to an uppercase string. If v is an identifier only its name part is used and namespace is ignored. Keywords are transformed to strings without the : prefix. Empty string or nil will result in nil being returned.

some-str-spc clj

(some-str-spc s & more)

Takes one or more strings or other objects convertable to strings and concatenates them with spaces. Keywords are transformed to strings without the : prefix.

some-str-squeeze-spc clj

(some-str-squeeze-spc s & more)

Takes one or more strings or other objects convertable to strings and concatenates them with spaces and squeezes spaces in a resulting string which is returned. Keywords are transformed to strings without the : prefix.

some-str-up clj

(some-str-up v)

Converts the given value v to an uppercase string. Keywords are transformed to strings without the : prefix. Empty string or nil will result in nil being returned.

some-string clj

(some-string s)

Takes a string s and returns it unless its value is nil or it is an empty string. A bit more performant but will throw an exception when s is not a string nor nil.

some-symbol clj

(some-symbol v)

some-symbol-simple clj

(some-symbol-simple v)

some-symbol-up clj

(some-symbol-up v)

str-spc clj

(str-spc s & more)

Takes one or more strings or other objects convertable to strings and concatenates them with spaces.

str-squeeze-spc clj

(str-squeeze-spc s & more)

Takes one or more strings or other objects convertable to strings and concatenates them with spaces and squeezes spaces in a resulting string which is returned.

strb clj

(strb a)

(strb a b)

(strb a b c)

(strb a b c d)

(strb a b c d e)

(strb a b c d e & more)

Like clojure.core/str but faster. Be aware that all arguments except first must be of type String or nil.

strs clj macro

(strs)

(strs a)

(strs a & more)

Converts all arguments to strings and concatenates them with keywords being converted to strings without the : prefix. Neighbouring literal strings and known constant forms will be concatenated at compile time.

strs-simple clj macro

(strs-simple)

(strs-simple a)

(strs-simple a & more)

Converts all arguments to strings and concatenates them. Neighbouring literal strings and known constant forms will be concatenated at compile time.

strspc clj macro

(strspc)

(strspc a)

(strspc a & more)

Converts all arguments to strings and concatenates them with keywords being converted to strings without the : prefix. Neighbouring literal strings and known constant forms will be trimmed on both ends and concatenated at compile time with space characters.

For consecutive non-constant forms (like symbols) simple wrappers will be generated to ensure they are properly trimmed and separated with spaces depending on their values (only single space and empty string are detected).

strspc-squeezed clj macro

(strspc-squeezed)

(strspc-squeezed a)

(strspc-squeezed a & more)

Converts all arguments to strings and concatenates them with keywords being converted to strings without the : prefix. Neighbouring literal strings and known constant forms will be trimmed on both ends and concatenated at compile time with space characters.

For consecutive non-constant forms (like symbols) simple wrappers will be generated to ensure they are properly trimmed and separated with spaces depending on their values (only single space and empty string are detected).

Moreover, spaces will be squeezed for detected constant forms at compile time. No squeezing will be performed at run-time.

text-to-bytes clj

(text-to-bytes t)

throwable? clj

(throwable? v)

to-bytes clj

(to-bytes obj)

Converts object to bytes by converting it to a string first with UTF-8 encoding.

to-lisp-simple-str clj

(to-lisp-simple-str v)

abc/ip_address --> ip-address

to-lisp-slashed-str clj

(to-lisp-slashed-str v)

ip_address_is --> ip/address-is

to-lisp-str clj

(to-lisp-str v)

ip_address --> ip-address

to-lisp-str-replace-first clj

(to-lisp-str-replace-first v c r)

ipCaddress_to --> ipRaddress-to

to-long clj

(to-long s default)

to-snake-simple-str clj

(to-snake-simple-str v)

abc/ip-address --> ip_address

to-snake-slashed-str clj

(to-snake-slashed-str v)

ip-address-is --> ip/address_is

to-snake-str clj

(to-snake-str v)

ip-address --> ip_address

to-snake-str-replace-first clj

(to-snake-str-replace-first v c r)

ipCaddress-to --> ipRaddress_to

to-uuid clj

(to-uuid)

(to-uuid s)

Converts the given value to UUID. If it's empty or nil, returns nil.

try-null clj macro

(try-null & body)

Evaluates body and if NullPointerException exception is caught it returns nil. Otherwise it returns the value of last expression in the body.

try-require clj

(try-require n)

Tries to require namespace n and returns the given argument. If the file does not exists, returns nil.

uuid clj

valuable clj macro

(valuable & more)

valuable? clj

(valuable? x)

Returns true if x valuable: is not nil nor empty.

when-not-empty clj macro

(when-not-empty val & body)

Evaluates body when the given value is a non-empty collection.

when-not-valuable clj macro

(when-not-valuable v & more)

Evaluates expressions from more in an implicit do when v is nil or empty.

when-valuable clj macro

(when-valuable v & more)

Evaluates expressions from more in an implicit do when v is not nil nor empty.

with-not-empty clj

(with-not-empty obj)

Returns the collection if it's not empty. Otherwise returns nil.