checks if string is empty or nil

(blank? nil) => true

(blank? "") => true

converts a string-like object to camel case representation

(camel-case “hello-world”) => “helloWorld”

((wrap camel-case) ’hello_world) => ’helloWorld

converts a string object to capital case

(capital-case “hello.World”) => “Hello.world”

((wrap capital-case) ’hello.World) => ’Hello.world

converts a string-like object to captital case representation

(capital-sep-case “hello world”) => “Hello World”

(str ((wrap capital-sep-case) :hello-world)) => “:Hello World”

capitalize the first letter

(capitalize “hello”) => “Hello”

compares two values ignoring case

(caseless= “heLLo” “HellO”) => true

((wrap caseless=) ’heLLo :HellO) => true

lowercase the first letter

(decapitalize “HELLO”) => “hELLO”

creates a dot-case representation

(dot-case “hello-world”) => “hello.world”

((wrap dot-case) ’helloWorld) => ’hello.world

checks if string ends with another

(ends-with? “hello” “lo”) => true

((wrap ends-with?) ’hello ’lo) => true

uses a map to replace chars

for regex purposes, escape dollar signs in strings

(escape-dollars “$”) => string?

makes sure that newlines are printable

(escape-escapes "
") => "\ "

makes sure that newlines are printable

(escape-newlines "
") => "
"

makes sure that quotes are printable in string form

(escape-quotes “"hello"”) => “\“hello\””

filter empty line

(filter-empty-lines (common/join “\n” [“a” " " " " “b”])) => “a\nb”

converts a string to an object

(from-string “a” clojure.lang.Symbol) => ’a

(from-string “std.string” clojure.lang.Namespace) => (find-ns ’std.string)

checks if a string has quotes

(has-quotes? “"hello"”) => true

checks if first string contains the second

(includes? “hello” “ell”) => true

((wrap includes?) ’hello ’ell) => true

indents a block of string

(indent (write-lines “a” “b” “c”) 2) => “a\n b\n c”

indents the rest of the boiy

(indent-rest (write-lines “a” “b” “c”) 2) => “a\n b\n c”

like join but used with ->> opts

(join “.” “a” “b” “c”) => “a.b.c”

;;(join “.” ’a b c) ;;=> ’a.b.c

join non empty elements in array

(join-lines "" “hello” “world”) => “helloworld”

joins an array using a separator

(joinl “a” “b” “c” “.”) => “a.b.c”

(joinl “a” “b” “c”) => “abc”

((wrap joinl) :a :b :c “-”) => :a-b-c

layout tokens in lines depending on max length

(layout-lines “hello” “world” “again” “a” “b” 8) => “hello\nworld\nagain a\nb”

transforms string to seperated newlines

(lines “abc\ndef”) => ’(std.string.prose/| “abc” “def”)

converts a string object to lower case

(lower-case “Hello.World”) => “hello.world”

((wrap lower-case) ’Hello.World) => ’hello.world

converts a string-like object to a lower case representation

(lower-sep-case “helloWorld”) => “hello world”

((wrap lower-sep-case) ’hello-world) => (symbol “hello world”)

check that a string has newlines

converts a string-like object to a pascal case representation

(pascal-case “helloWorld”) => “HelloWorld”

((wrap pascal-case) :hello-world) => :HelloWorld

counts the number of elements in a given path

(path/path-count “a/b/c”) => 3

((wrap path/path-count) ns) => 3

joins a sequence of elements into a path separated value

(path/path-join “a” “b” “c”) => “a/b/c”

((wrap path/path-join) ’:a :b :c “-”) => :a-b-c

((wrap path/path-join) ’a b c ’-) => ’a-b-c

returns the path namespace of the string

(path/path-ns “a/b/c/d”) => “a/b/c”

((wrap path/path-ns) :a.b.c “.”) => :a.b

returns the path vector of the string

(path/path-ns-array “a/b/c/d”) => “a” “b” “c”

((wrap path/path-ns-array) (keyword “a/b/c/d”)) => :a :b :c

check for the val of the string

(path/path-nth “a/b/c/d” 2) => “c”

returns the path root of the string

(path/path-root “a/b/c/d”) => “a”

((wrap path/path-root) ’a.b.c “.”) => ’a

returns the default path separator for an object

(path-separator clojure.lang.Namespace) => “.”

(path-separator clojure.lang.Keyword) => “/”

splits a sequence of elements into a path separated value

(path/path-split “a/b/c/d”) => ’“a” “b” “c” “d”

(path/path-split “a.b.c.d” “.”) => “a” “b” “c” “d”

((wrap path/path-split) :hello/world) => :hello :world

((wrap path/path-split) :hello.world “.”) => :hello :world

returns the path stem of the string

(path/path-stem “a/b/c/d”) => “b/c/d”

((wrap path/path-stem) ’a.b.c.d “.”) => ’b.c.d

returns the path stem vector of the string

(path/path-stem-array “a/b/c/d”) => “b” “c” “d”

((wrap path/path-stem-array) ’a.b.c.d “.”) => ’b c d

returns a subsection of the path within the string

(path/path-sub “a/b/c/d” 1 2) => “b/c”

((wrap path/path-sub) (symbol “a/b/c/d”) 1 2) => ’b/c

returns a sub array of the path within the string

(path/path-sub-array “a/b/c/d” 1 2) => “b” “c”

((wrap path/path-sub-array) (symbol “a/b/c/d”) 1 2) => ’b c

returns the val of the string

(path/path-val “a/b/c/d”) => “d”

((wrap path/path-val) ’a.b.c.d “.”) => ’d

converts a string-like object to snake case representation

(phrase-case “hello-world”) => “Hello world”

replace value in string with another

(replace “hello” “el” “AL”) => “hALlo”

((wrap replace) :hello “el” “AL”) => :hALlo

shortcut for .replaceAll

(replace-all “hello” “l” “o”) => “heooo”

reverses the string

(reverse “hello”) => “olleh”

((wrap reverse) :hello) => :olleh

replace newlines with spaces

check that a string does not have newlines

converts a string-like object to snake case representation

(snake-case “hello-world”) => “hello_world”

((wrap snake-case) ’helloWorld) => ’hello_world

create n spaces

(spaces 4) => ""

converts a string-like object to spear case representation

(spear-case “hello_world”) => “hello-world”

((wrap spear-case) ’helloWorld) => ’hello-world

splits the string into tokens

(split “a b c” #" ") => “a” “b” “c”

((wrap split) :a.b.c (re-pattern “.”)) => :a :b :c

splits the string into separate lines

(split-lines “a\nb\nc”) => “a” “b” “c”

checks if string starts with another

(starts-with? “hello” “hel”) => true

((wrap starts-with?) ’hello ’hel) => true

wraps a function so that it can compare any two string-like inputs

((str:compare =) :hello ’hello) => true

wraps a string function such that it can take any string-like input

((str:op str false) :hello ’hello) => :hellohello

((str:op str true) :hello ’hello) => “hellohello”

gets rid of quotes in a string

(strip-quotes “"hello"”) => “hello”

converts an object to a string

(to-string :hello/world) => “hello/world”

(to-string ns) => “std.string.coerce-test”

trims the string of whitespace

(trim " hello ") => “hello”

trims the string of whitespace on left

(trim-left " hello ") => "hello "

removes newlines from right

(trim-newlines “\n\n hello \n\n”) => "\n\n hello "

trims the string of whitespace on right

(trim-right " hello ") => “hello”

truncates a word

(truncate “hello there” 5) => “hello”

compares two representations

(typeless= “helloWorld” “hello_world”) => true

((wrap typeless=) :a-b-c “a b c”) => true

((wrap typeless=) ’getMethod :get-method) => true

convert string to uppercase camel

(upper-camel-case “hello-world”) => “HelloWorld”

converts a string object to upper case

(upper-case “hello-world”) => “HELLO-WORLD”

((wrap upper-case) :hello-world) => :HELLO-WORLD

converts a string-like object to upper case representation

(upper-sep-case “hello world”) => “HELLO WORLD”

(str ((wrap upper-sep-case) ’hello-world)) => “HELLO WORLD”

checks if the string is all whitespace

(whitespace? " ") => true

enables string-like ops for more types

((wrap #(str ’+ % ’+)) ’hello) => ’+hello+

writes a line based on data structure

writes a block of string

shortcut for join lines

(| “abc” “def”) => “abc\ndef”