org.tobereplaced.lettercase documentation

Declarative case conversion.

The main functions in this namespace operate on strings and are
named according to:

(case-method)-(optional-separator)-(optional-return-type).

The implemented case-methods include capitalize, sentence, mixed,
upper, and lower.  The implemented separators include space, hyphen,
and underscore, defaulting to nothing.  The implemented return types
include symbol and keyword, defaulting to string.

The functions suffixed by "name" can be used similarly to the core
clojure function with case manipulation.

All of the above functions accept an optional regular expression
pattern to match word-separators.  See "separator-pattern" for
help constructing more complicated patterns.

If you are working with keywords or symbols, see the "alter-name"
and "alter-namespace" functions.

alter-name

(alter-name x f & args)
Returns a new symbol or keyword by applying f to the name of x and
any additional args.

Example: (alter-name :foo/bar upper) => :foo/BAR

alter-namespace

(alter-namespace x f & args)
Returns a new symbol or keyword by applying f to the namespace of x
and any additional args.

Example: (alter-namespace :foo/bar upper) => :FOO/bar

capitalized

(capitalized s)(capitalized s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be capitalized.  The words will not be separated.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized "Foo the Bar") => "FooTheBar"

capitalized-hyphen

(capitalized-hyphen s)(capitalized-hyphen s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by \-.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-hyphen "Foo the Bar") => "Foo-The-Bar"

capitalized-hyphen-keyword

(capitalized-hyphen-keyword s)(capitalized-hyphen-keyword s re)(capitalized-hyphen-keyword ns s)(capitalized-hyphen-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by \-.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-hyphen-keyword "Foo the Bar") => :Foo-The-Bar

capitalized-hyphen-name

(capitalized-hyphen-name x)(capitalized-hyphen-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be capitalized.  Each
word will be separated by \-.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (capitalized-hyphen-name :Foo-the-Bar) => "Foo-The-Bar"

capitalized-hyphen-symbol

(capitalized-hyphen-symbol s)(capitalized-hyphen-symbol s re)(capitalized-hyphen-symbol ns s)(capitalized-hyphen-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by \-.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-hyphen-symbol "Foo the Bar") => Foo-The-Bar

capitalized-keyword

(capitalized-keyword s)(capitalized-keyword s re)(capitalized-keyword ns s)(capitalized-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be capitalized.  The words will not be separated.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-keyword "Foo the Bar") => :FooTheBar

capitalized-name

(capitalized-name x)(capitalized-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be capitalized.  The
words will not be separated.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (capitalized-name :Foo-the-Bar) => "FooTheBar"

capitalized-space

(capitalized-space s)(capitalized-space s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by
\space.  Word boundaries will be determined by re if provided,
otherwise they will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-space "Foo the Bar") => "Foo The Bar"

capitalized-space-keyword

(capitalized-space-keyword s)(capitalized-space-keyword s re)(capitalized-space-keyword ns s)(capitalized-space-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by
\space.  Word boundaries will be determined by re if provided,
otherwise they will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-space-keyword "Foo the Bar") => :Foo The Bar

capitalized-space-name

(capitalized-space-name x)(capitalized-space-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be capitalized.  Each
word will be separated by \space.  Word boundaries will be
determined by re if provided, otherwise they will be determined by
the default pattern returned by separator-pattern.

Example: (capitalized-space-name :Foo-the-Bar) => "Foo The Bar"

capitalized-space-symbol

(capitalized-space-symbol s)(capitalized-space-symbol s re)(capitalized-space-symbol ns s)(capitalized-space-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by
\space.  Word boundaries will be determined by re if provided,
otherwise they will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-space-symbol "Foo the Bar") => Foo The Bar

capitalized-symbol

(capitalized-symbol s)(capitalized-symbol s re)(capitalized-symbol ns s)(capitalized-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be capitalized.  The words will not be separated.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-symbol "Foo the Bar") => FooTheBar

capitalized-underscore

(capitalized-underscore s)(capitalized-underscore s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by \_.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-underscore "Foo the Bar") => "Foo_The_Bar"

capitalized-underscore-keyword

(capitalized-underscore-keyword s)(capitalized-underscore-keyword s re)(capitalized-underscore-keyword ns s)(capitalized-underscore-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by \_.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-underscore-keyword "Foo the Bar") => :Foo_The_Bar

capitalized-underscore-name

(capitalized-underscore-name x)(capitalized-underscore-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be capitalized.  Each
word will be separated by \_.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (capitalized-underscore-name :Foo-the-Bar) => "Foo_The_Bar"

capitalized-underscore-symbol

(capitalized-underscore-symbol s)(capitalized-underscore-symbol s re)(capitalized-underscore-symbol ns s)(capitalized-underscore-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be capitalized.  Each word will be separated by \_.
Word boundaries will be determined by re if provided, otherwise they
will be determined by the default pattern returned by
separator-pattern.

Example: (capitalized-underscore-symbol "Foo the Bar") => Foo_The_Bar

lower

(lower s)(lower s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  The words
will not be separated.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (lower "Foo the Bar") => "foothebar"

lower-hyphen

(lower-hyphen s)(lower-hyphen s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \-.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-hyphen "Foo the Bar") => "foo-the-bar"

lower-hyphen-keyword

(lower-hyphen-keyword s)(lower-hyphen-keyword s re)(lower-hyphen-keyword ns s)(lower-hyphen-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \-.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-hyphen-keyword "Foo the Bar") => :foo-the-bar

lower-hyphen-name

(lower-hyphen-name x)(lower-hyphen-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
lowercase letters.  Each word will be separated by \-.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (lower-hyphen-name :Foo-the-Bar) => "foo-the-bar"

lower-hyphen-symbol

(lower-hyphen-symbol s)(lower-hyphen-symbol s re)(lower-hyphen-symbol ns s)(lower-hyphen-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \-.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-hyphen-symbol "Foo the Bar") => foo-the-bar

lower-keyword

(lower-keyword s)(lower-keyword s re)(lower-keyword ns s)(lower-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  The words
will not be separated.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (lower-keyword "Foo the Bar") => :foothebar

lower-name

(lower-name x)(lower-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
lowercase letters.  The words will not be separated.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (lower-name :Foo-the-Bar) => "foothebar"

lower-space

(lower-space s)(lower-space s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \space.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-space "Foo the Bar") => "foo the bar"

lower-space-keyword

(lower-space-keyword s)(lower-space-keyword s re)(lower-space-keyword ns s)(lower-space-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \space.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-space-keyword "Foo the Bar") => :foo the bar

lower-space-name

(lower-space-name x)(lower-space-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
lowercase letters.  Each word will be separated by \space.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (lower-space-name :Foo-the-Bar) => "foo the bar"

lower-space-symbol

(lower-space-symbol s)(lower-space-symbol s re)(lower-space-symbol ns s)(lower-space-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \space.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-space-symbol "Foo the Bar") => foo the bar

lower-symbol

(lower-symbol s)(lower-symbol s re)(lower-symbol ns s)(lower-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  The words
will not be separated.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (lower-symbol "Foo the Bar") => foothebar

lower-underscore

(lower-underscore s)(lower-underscore s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \_.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-underscore "Foo the Bar") => "foo_the_bar"

lower-underscore-keyword

(lower-underscore-keyword s)(lower-underscore-keyword s re)(lower-underscore-keyword ns s)(lower-underscore-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \_.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-underscore-keyword "Foo the Bar") => :foo_the_bar

lower-underscore-name

(lower-underscore-name x)(lower-underscore-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
lowercase letters.  Each word will be separated by \_.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (lower-underscore-name :Foo-the-Bar) => "foo_the_bar"

lower-underscore-symbol

(lower-underscore-symbol s)(lower-underscore-symbol s re)(lower-underscore-symbol ns s)(lower-underscore-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all lowercase letters.  Each word
will be separated by \_.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (lower-underscore-symbol "Foo the Bar") => foo_the_bar

mixed

(mixed s)(mixed s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  The words will not be separated.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (mixed "Foo the Bar") => "fooTheBar"

mixed-hyphen

(mixed-hyphen s)(mixed-hyphen s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \-.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (mixed-hyphen "Foo the Bar") => "foo-The-Bar"

mixed-hyphen-keyword

(mixed-hyphen-keyword s)(mixed-hyphen-keyword s re)(mixed-hyphen-keyword ns s)(mixed-hyphen-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \-.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (mixed-hyphen-keyword "Foo the Bar") => :foo-The-Bar

mixed-hyphen-name

(mixed-hyphen-name x)(mixed-hyphen-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be converted to
lowercase and the rest will be capitalized.  Each word will be
separated by \-.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (mixed-hyphen-name :Foo-the-Bar) => "foo-The-Bar"

mixed-hyphen-symbol

(mixed-hyphen-symbol s)(mixed-hyphen-symbol s re)(mixed-hyphen-symbol ns s)(mixed-hyphen-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \-.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (mixed-hyphen-symbol "Foo the Bar") => foo-The-Bar

mixed-keyword

(mixed-keyword s)(mixed-keyword s re)(mixed-keyword ns s)(mixed-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  The words will not be separated.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (mixed-keyword "Foo the Bar") => :fooTheBar

mixed-name

(mixed-name x)(mixed-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be converted to
lowercase and the rest will be capitalized.  The words will not be
separated.  Word boundaries will be determined by re if provided,
otherwise they will be determined by the default pattern returned by
separator-pattern.

Example: (mixed-name :Foo-the-Bar) => "fooTheBar"

mixed-space

(mixed-space s)(mixed-space s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \space.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (mixed-space "Foo the Bar") => "foo The Bar"

mixed-space-keyword

(mixed-space-keyword s)(mixed-space-keyword s re)(mixed-space-keyword ns s)(mixed-space-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \space.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (mixed-space-keyword "Foo the Bar") => :foo The Bar

mixed-space-name

(mixed-space-name x)(mixed-space-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be converted to
lowercase and the rest will be capitalized.  Each word will be
separated by \space.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (mixed-space-name :Foo-the-Bar) => "foo The Bar"

mixed-space-symbol

(mixed-space-symbol s)(mixed-space-symbol s re)(mixed-space-symbol ns s)(mixed-space-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \space.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (mixed-space-symbol "Foo the Bar") => foo The Bar

mixed-symbol

(mixed-symbol s)(mixed-symbol s re)(mixed-symbol ns s)(mixed-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  The words will not be separated.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (mixed-symbol "Foo the Bar") => fooTheBar

mixed-underscore

(mixed-underscore s)(mixed-underscore s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \_.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (mixed-underscore "Foo the Bar") => "foo_The_Bar"

mixed-underscore-keyword

(mixed-underscore-keyword s)(mixed-underscore-keyword s re)(mixed-underscore-keyword ns s)(mixed-underscore-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \_.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (mixed-underscore-keyword "Foo the Bar") => :foo_The_Bar

mixed-underscore-name

(mixed-underscore-name x)(mixed-underscore-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be converted to
lowercase and the rest will be capitalized.  Each word will be
separated by \_.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (mixed-underscore-name :Foo-the-Bar) => "foo_The_Bar"

mixed-underscore-symbol

(mixed-underscore-symbol s)(mixed-underscore-symbol s re)(mixed-underscore-symbol ns s)(mixed-underscore-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be converted to lowercase and the rest will be
capitalized.  Each word will be separated by \_.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (mixed-underscore-symbol "Foo the Bar") => foo_The_Bar

sentence

(sentence s)(sentence s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  The words will not be separated.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence "Foo the Bar") => "Foothebar"

sentence-hyphen

(sentence-hyphen s)(sentence-hyphen s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \-.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-hyphen "Foo the Bar") => "Foo-the-bar"

sentence-hyphen-keyword

(sentence-hyphen-keyword s)(sentence-hyphen-keyword s re)(sentence-hyphen-keyword ns s)(sentence-hyphen-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \-.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-hyphen-keyword "Foo the Bar") => :Foo-the-bar

sentence-hyphen-name

(sentence-hyphen-name x)(sentence-hyphen-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be capitalized
and the rest will be converted to lowercase.  Each word will be
separated by \-.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (sentence-hyphen-name :Foo-the-Bar) => "Foo-the-bar"

sentence-hyphen-symbol

(sentence-hyphen-symbol s)(sentence-hyphen-symbol s re)(sentence-hyphen-symbol ns s)(sentence-hyphen-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \-.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-hyphen-symbol "Foo the Bar") => Foo-the-bar

sentence-keyword

(sentence-keyword s)(sentence-keyword s re)(sentence-keyword ns s)(sentence-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  The words will not be separated.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-keyword "Foo the Bar") => :Foothebar

sentence-name

(sentence-name x)(sentence-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be capitalized
and the rest will be converted to lowercase.  The words will not be
separated.  Word boundaries will be determined by re if provided,
otherwise they will be determined by the default pattern returned by
separator-pattern.

Example: (sentence-name :Foo-the-Bar) => "Foothebar"

sentence-space

(sentence-space s)(sentence-space s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \space.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (sentence-space "Foo the Bar") => "Foo the bar"

sentence-space-keyword

(sentence-space-keyword s)(sentence-space-keyword s re)(sentence-space-keyword ns s)(sentence-space-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \space.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (sentence-space-keyword "Foo the Bar") => :Foo the bar

sentence-space-name

(sentence-space-name x)(sentence-space-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be capitalized
and the rest will be converted to lowercase.  Each word will be
separated by \space.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (sentence-space-name :Foo-the-Bar) => "Foo the bar"

sentence-space-symbol

(sentence-space-symbol s)(sentence-space-symbol s re)(sentence-space-symbol ns s)(sentence-space-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \space.  Word boundaries
will be determined by re if provided, otherwise they will be
determined by the default pattern returned by separator-pattern.

Example: (sentence-space-symbol "Foo the Bar") => Foo the bar

sentence-symbol

(sentence-symbol s)(sentence-symbol s re)(sentence-symbol ns s)(sentence-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  The words will not be separated.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-symbol "Foo the Bar") => Foothebar

sentence-underscore

(sentence-underscore s)(sentence-underscore s re)
Returns a new string by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \_.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-underscore "Foo the Bar") => "Foo_the_bar"

sentence-underscore-keyword

(sentence-underscore-keyword s)(sentence-underscore-keyword s re)(sentence-underscore-keyword ns s)(sentence-underscore-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \_.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-underscore-keyword "Foo the Bar") => :Foo_the_bar

sentence-underscore-name

(sentence-underscore-name x)(sentence-underscore-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  The first word will be capitalized
and the rest will be converted to lowercase.  Each word will be
separated by \_.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (sentence-underscore-name :Foo-the-Bar) => "Foo_the_bar"

sentence-underscore-symbol

(sentence-underscore-symbol s)(sentence-underscore-symbol s re)(sentence-underscore-symbol ns s)(sentence-underscore-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
The first word will be capitalized and the rest will be converted to
lowercase.  Each word will be separated by \_.  Word boundaries will
be determined by re if provided, otherwise they will be determined
by the default pattern returned by separator-pattern.

Example: (sentence-underscore-symbol "Foo the Bar") => Foo_the_bar

separator-pattern

(separator-pattern & {:keys [space upper letter number], :or {space #"[\- _,/|]", upper #"\p{Lu}", letter #"\p{L}", number #"\p{N}"}})
Returns a composite pattern that can be used to break a string into
words.  The resulting pattern will match any space character, an
upper letter immediately followed by an upper letter immediately
followed by a lower letter, a lower letter immediately followed by
an upper letter, any letter immediately followed by a number, and
any number immediately followed by a number.

upper

(upper s)(upper s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  The words
will not be separated.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (upper "Foo the Bar") => "FOOTHEBAR"

upper-hyphen

(upper-hyphen s)(upper-hyphen s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \-.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-hyphen "Foo the Bar") => "FOO-THE-BAR"

upper-hyphen-keyword

(upper-hyphen-keyword s)(upper-hyphen-keyword s re)(upper-hyphen-keyword ns s)(upper-hyphen-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \-.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-hyphen-keyword "Foo the Bar") => :FOO-THE-BAR

upper-hyphen-name

(upper-hyphen-name x)(upper-hyphen-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
uppercase letters.  Each word will be separated by \-.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (upper-hyphen-name :Foo-the-Bar) => "FOO-THE-BAR"

upper-hyphen-symbol

(upper-hyphen-symbol s)(upper-hyphen-symbol s re)(upper-hyphen-symbol ns s)(upper-hyphen-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \-.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-hyphen-symbol "Foo the Bar") => FOO-THE-BAR

upper-keyword

(upper-keyword s)(upper-keyword s re)(upper-keyword ns s)(upper-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  The words
will not be separated.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (upper-keyword "Foo the Bar") => :FOOTHEBAR

upper-name

(upper-name x)(upper-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
uppercase letters.  The words will not be separated.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (upper-name :Foo-the-Bar) => "FOOTHEBAR"

upper-space

(upper-space s)(upper-space s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \space.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-space "Foo the Bar") => "FOO THE BAR"

upper-space-keyword

(upper-space-keyword s)(upper-space-keyword s re)(upper-space-keyword ns s)(upper-space-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \space.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-space-keyword "Foo the Bar") => :FOO THE BAR

upper-space-name

(upper-space-name x)(upper-space-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
uppercase letters.  Each word will be separated by \space.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (upper-space-name :Foo-the-Bar) => "FOO THE BAR"

upper-space-symbol

(upper-space-symbol s)(upper-space-symbol s re)(upper-space-symbol ns s)(upper-space-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \space.  Word boundaries will be determined by
re if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-space-symbol "Foo the Bar") => FOO THE BAR

upper-symbol

(upper-symbol s)(upper-symbol s re)(upper-symbol ns s)(upper-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  The words
will not be separated.  Word boundaries will be determined by re if
provided, otherwise they will be determined by the default pattern
returned by separator-pattern.

Example: (upper-symbol "Foo the Bar") => FOOTHEBAR

upper-underscore

(upper-underscore s)(upper-underscore s re)
Returns a new string by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \_.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-underscore "Foo the Bar") => "FOO_THE_BAR"

upper-underscore-keyword

(upper-underscore-keyword s)(upper-underscore-keyword s re)(upper-underscore-keyword ns s)(upper-underscore-keyword ns s re)
Returns a keyword by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \_.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-underscore-keyword "Foo the Bar") => :FOO_THE_BAR

upper-underscore-name

(upper-underscore-name x)(upper-underscore-name x re)
Returns a string by manipulating the lettercase of the name of the
string, symbol, or keyword s.  Each word will be converted to all
uppercase letters.  Each word will be separated by \_.  Word
boundaries will be determined by re if provided, otherwise they will
be determined by the default pattern returned by separator-pattern.

Example: (upper-underscore-name :Foo-the-Bar) => "FOO_THE_BAR"

upper-underscore-symbol

(upper-underscore-symbol s)(upper-underscore-symbol s re)(upper-underscore-symbol ns s)(upper-underscore-symbol ns s re)
Returns a symbol by manipulating the lettercase of the string s.
Each word will be converted to all uppercase letters.  Each word
will be separated by \_.  Word boundaries will be determined by re
if provided, otherwise they will be determined by the default
pattern returned by separator-pattern.

Example: (upper-underscore-symbol "Foo the Bar") => FOO_THE_BAR