Table of Contents

as-str

Usage: (as-str)
       (as-str x)
       (as-str x & ys)

Like clojure.core/str, but if an argument is a keyword or symbol,
its name will be used instead of its literal representation.

Example:
   (str :foo :bar)     ;;=> ":foo:bar"
   (as-str :foo :bar)  ;;=> "foobar" 

Note that this does not apply to keywords or symbols nested within
data structures; they will be rendered as with str.

Example:
   (str {:foo :bar})     ;;=> "{:foo :bar}"
   (as-str {:foo :bar})  ;;=> "{:foo :bar}" 

blank?

Usage: (blank? s)

True if s is nil, empty, or contains only whitespace.

butlast

Usage: (butlast n s)

Returns s without the last n characters.  Returns an empty string
if n is greater than the length of s.

capitalize

Usage: (capitalize s)

Converts first character of the string to upper-case, all other
characters to lower-case.

chomp

Usage: (chomp s)

Removes all trailing newline \n or return \r characters from
string.  Note: String.trim() is similar and faster.

chop

Usage: (chop s)

Removes the last character of string, does nothing on a zero-length
string.

codepoints

Usage: (codepoints s)

Returns a sequence of integer Unicode code points in s.  Handles
Unicode supplementary characters (above U+FFFF) correctly.

dochars

Usage: (dochars bindings & body)

bindings => [name string]

Repeatedly executes body, with name bound to each character in
string.  Does NOT handle Unicode supplementary characters (above
U+FFFF).

docodepoints

Usage: (docodepoints bindings & body)

bindings => [name string]

Repeatedly executes body, with name bound to the integer code point
of each Unicode character in the string.  Handles Unicode
supplementary characters (above U+FFFF) correctly.

drop

Usage: (drop n s)

Drops first n characters from s.  Returns an empty string if n is
greater than the length of s.

escape

Usage: (escape cmap s)

Returns a new String by applying cmap (a function or a map) to each
character in s.  If cmap returns nil, the original character is
added to the output unchanged.

get

Usage: (get s i)

Gets the i'th character in string.

grep

Usage: (grep re coll)

Filters elements of coll by a regular expression.  The String
representation (with str) of each element is tested with re-find.

join

Usage: (join separator coll)

Returns a string of all elements in coll, separated by
separator.  Like Perl's join.

lower-case

Usage: (lower-case s)

Converts string to all lower-case.

ltrim

Usage: (ltrim s)

Removes whitespace from the left side of string.

map-str

Usage: (map-str f coll)

Apply f to each element of coll, concatenate all results into a
String.

partition

Usage: (partition re s)

Splits the string into a lazy sequence of substrings, alternating
between substrings that match the patthern and the substrings
between the matches.  The sequence always starts with the substring
before the first match, or an empty string if the beginning of the
string matches.

For example: (partition #"[a-z]+" "abc123def")
returns: ("" "abc" "123" "def")

repeat

Usage: (repeat n s)

Returns a new String containing s repeated n times.

replace-by

Usage: (replace-by re f s)

Replaces all matches of re in s with the result of 
(f (re-groups the-match)).

replace-char

Usage: (replace-char a b s)

Replaces all instances of character a with character b in s.

replace-first-by

Usage: (replace-first-by re f s)

Replace first match of re in s with the result of
(f (re-groups the-match)).

replace-first-re

Usage: (replace-first-re re replacement s)

Replace first match of re in s.

replace-first-str

Usage: (replace-first-str a b s)

Replace first occurance of substring a with b in s.

replace-re

Usage: (replace-re re replacement s)

Replaces all matches of re with replacement in s.

replace-str

Usage: (replace-str a b s)

Replaces all instances of substring a with b in s.

reverse

Usage: (reverse s)

Returns s with its characters reversed.

rtrim

Usage: (rtrim s)

Removes whitespace from the right side of string.

split

Usage: (split re s)
       (split re limit s)

Splits string on a regular expression.  Optional argument limit is
the maximum number of splits.

split-lines

Usage: (split-lines s)

Splits s on \n or \r\n.

substring?

Usage: (substring? substring s)

True if s contains the substring.

swap-case

Usage: (swap-case s)

Changes upper case characters to lower case and vice-versa.
Handles Unicode supplementary characters correctly.  Uses the
locale-sensitive String.toUpperCase() and String.toLowerCase()
methods.

tail

Usage: (tail n s)

Returns the last n characters of s.

take

Usage: (take n s)

Take first n characters from s, up to the length of s.

trim

Usage: (trim s)

Removes whitespace from both ends of string.

upper-case

Usage: (upper-case s)

Converts string to all upper-case.