Table of Contents

blank?

Usage: (blank? s)

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

butlast

Usage: (butlast s n)

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

Note the argument order is the opposite of clojure.core/butlast;
this is to keep the string as the first argument for use with ->

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.

contains?

Usage: (contains? s substring)

True if s contains the substring.

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 s n)

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

Note the argument order is the opposite of clojure.core/drop; this
is to keep the string as the first argument for use with ->

escape

Usage: (escape s cmap)

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.

partial

Usage: (partial f & args)

Like clojure.core/partial for functions that take their primary
argument first.

Takes a function f and its arguments, NOT INCLUDING the first
argument.  Returns a new function whose first argument will be the
first argument to f.

Example: (str-utils2/partial str-utils2/take 2)
         ;;=> (fn [s] (str-utils2/take s 2))

partition

Usage: (partition s re)

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 "abc123def" #"[a-z]+")
returns: ("" "abc" "123" "def")

repeat

Usage: (repeat s n)

Returns a new String containing s repeated n times.

replace

Usage: (replace string pattern replacement)

Replaces all instances of pattern in string with replacement.

Allowed argument types for pattern and replacement are:
 1. String and String
 2. Character and Character
 3. regex Pattern and String
    (Uses java.util.regex.Matcher.replaceAll)
 4. regex Pattern and function
    (Calls function with re-groups of each match, uses return
     value as replacement.)

replace-first

Usage: (replace-first s pattern replacement)

Replaces the first instance of pattern in s with replacement.

Allowed argument types for pattern and replacement are:
 1. String and String
 2. regex Pattern and String
    (Uses java.util.regex.Matcher.replaceAll)
 3. regex Pattern and function

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 s re)
       (split s re limit)

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.

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 s n)

Returns the last n characters of s.

take

Usage: (take s n)

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

Note the argument order is the opposite of clojure.core/take; this
is to keep the string as the first argument for use with ->

trim

Usage: (trim s)

Removes whitespace from both ends of string.

upper-case

Usage: (upper-case s)

Converts string to all upper-case.