tupelo.string — tupelo 21.03.25

A superset of clojure.string with many added functions.

->kabob-kw clj/s

(->kabob-kw arg)

Inputs: [arg :- (s/cond-pre s/Keyword s/Str s/Symbol)] Returns: s/Keyword

->kabob-str clj/s

(->kabob-str arg)

Inputs: [arg :- (s/cond-pre s/Keyword s/Str s/Symbol)] Returns: s/Str

Coerce a string, keyword, or symbol to a kabob-case-string

->snake-kw clj/s

(->snake-kw arg)

Inputs: [arg :- (s/cond-pre s/Keyword s/Str s/Symbol)] Returns: s/Keyword

->snake-str clj/s

(->snake-str arg)

Inputs: [arg :- (s/cond-pre s/Keyword s/Str s/Symbol)] Returns: s/Str

Coerce a string, keyword, or symbol to a snake_case_string

alpha? clj/s

(alpha? & args)

Returns true iff every char passes tupelo.chars/alpha?

alphanumeric? clj/s

(alphanumeric? & args)

Returns true iff every char passes tupelo.chars/alphanumeric?

blank? clj/s

Alias for clojure.string/blank?

capitalize clj/s

Alias for clojure.string/capitalize

char->code-point cljs

(char->code-point char-val)

REturns the code-point of a character (len=1 string)

clip-text clj/s

(clip-text N src-str)

Inputs: [N :- s/Int src-str :- s/Str] Returns: s/Str

Given a multi-line string, returns a string with each line clipped to a max of N chars

clojurize-key clj/s

(clojurize-key arg)

Given a string or keyword, converts to lowercase and calls str->kw-normalized

code-point->char cljs

(code-point->char code-point)

Inputs: [code-point :- s/Int]

REturns the code-point of a character (len=1 string)

collapse-whitespace clj/s deprecated

contains-match? clj/s

(contains-match? search-str re)

Inputs: [search-str :- s/Str re :- s/Any] Returns: s/Bool

Returns true if the regex matches any portion of the intput string.

contains-str-frags? clj/s≠

clj

(contains-str-frags? src & frags)

cljs

(contains-str-frags? G__127700 & rest127701)

Inputs: [src :- s/Str & frags :- [s/Str]] Returns: s/Bool

Returns true if the intput string contains the target string fragments. Search fragments may be separated by zero-or-more arbitrary chars in src

contains-str? clj/s

(contains-str? search-str tgt-str)

Inputs: [search-str :- s/Str tgt-str :- s/Str] Returns: s/Bool

Returns true if the intput string contains the target string.

digit? clj/s

(digit? & args)

Returns true iff every char passes tupelo.chars/digit?

drop clj/s

(drop n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Drops the first N chars of a string, returning a string result.

ends-with? clj/s

Alias for clojure.string/ends-with?

equals-ignore-spacing? clj/s deprecated

(equals-ignore-spacing? & args)

Renamed => nonblank=

escape clj/s

Alias for clojure.string/escape

fgrep clj/s

(fgrep tgt text)

Inputs: [tgt :- s/Str text :- s/Str]

Given a multi-line text string, returns a string containing lines matching the target string.

format clj/s≠

clj

(format fmtstr & args)

cljs

(format G__127750 & rest127751)

Inputs: [fmtstr :- s/Str & args] Returns: s/Str

Performs sprintf-like formatting for CLJ & CLJS:

   (format "%8.2f" 123.456789) => '  123.46'

grep clj/s

(grep pattern text)

Inputs: [pattern :- s/Regex text :- s/Str]

Given a multi-line text string, returns a string containing lines matching a regex pattern.

hex? clj/s

(hex? & args)

Returns true iff every char passes tupelo.chars/hex?

includes? clj/s

Alias for clojure.string/includes?

increasing-or-equal? clj/s

(increasing-or-equal? a b)

Inputs: [a :- s/Str b :- s/Str] Returns: s/Bool

Returns true if a pair of strings are in increasing lexicographic order, or equal.

increasing? clj/s

(increasing? a b)

Inputs: [a :- s/Str b :- s/Str] Returns: s/Bool

Returns true if a pair of strings are in increasing lexicographic order.

indent clj/s

(indent n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Indents a string by pre-pending N spaces. Returns a string result.

indent-lines clj/s

(indent-lines n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Splits out each line of txt using clojure.string/split-lines, then indents each line by prepending N spaces. Joins lines together into a single string result, with each line terminated by a single ewline.

indent-lines-with clj/s

(indent-lines-with indent-str txt)

Inputs: [indent-str :- s/Str txt :- s/Str] Returns: s/Str

Splits out each line of txt using clojure.string/split-lines, then indents each line by prepending it with the supplied string. Joins lines together into a single string result, with each line terminated by a single ewline.

index-of clj/s

Alias for clojure.string/index-of

join clj/s

Alias for clojure.string/join

last-index-of clj/s

Alias for clojure.string/last-index-of

lower-case clj/s

Alias for clojure.string/lower-case

lowercase= clj/s≠

clj

(lowercase= & args)

cljs

(lowercase= & rest127594)

Inputs: [& args :- [s/Str]] Returns: s/Bool

Compares strings for equality after applying clojure.string/lower-case.

lowercase? clj/s

(lowercase? & args)

Returns true iff every char passes tupelo.chars/lowercase?

nonblank-lines= clj/s≠

clj

(nonblank-lines= & args)

cljs

(nonblank-lines= & rest127576)

Inputs: [& args :- [s/Str]] Returns: s/Bool

Compares corresponding lines of input strings for equality using tupelo.misc/collapse-whitespace.

nonblank= clj/s≠

clj

(nonblank= & args)

cljs

(nonblank= & rest127570)

Inputs: [& args :- [s/Str]] Returns: s/Bool

Compares strings for equality using tupelo.misc/collapse-whitespace. Equivalent to separating tokens by whitespace and comparing the resulting sequences.

normalize-str clj/s

(normalize-str str-in)

Returns a 'normalized' version of str-in, stripped of leading/trailing blanks, and with all non-alphanumeric chars converted to hyphens.

not-blank? clj/s

(not-blank? it)

Returns true if the string is not blank.

pad-left clj/s≠

clj

(pad-left str-val N)

(pad-left str-val N pad-char)

cljs

(pad-left G__127722 G__127723)

(pad-left G__127727 G__127728 G__127729)

Inputs: ([str-val :- s/Str N :- s/Int] [str-val :- s/Str N :- s/Int pad-char]) Returns: s/Str

Pads a string on the left until it is at least N chars in size

pad-right clj/s≠

clj

(pad-right str-val N)

(pad-right str-val N pad-char)

cljs

(pad-right G__127736 G__127737)

(pad-right G__127741 G__127742 G__127743)

Inputs: ([str-val :- s/Str N :- s/Int] [str-val :- s/Str N :- s/Int pad-char]) Returns: s/Str

Pads a string on the right until it is at least N chars in size

phonetic-alphabet clj/s

A map from keyword character to string phonetic name:

{:a 'alpha' :b 'bravo' :c 'charlie' :d 'delta' :e 'echo' :f 'foxtrot' :g 'golf' :h 'hotel' :i 'india' :j 'juliett' :k 'kilo' :l 'lima' :m 'mike' :n 'november' :o 'oscar' :p 'papa' :q 'quebec' :r 'romeo ' :s 'sierra' :t 'tango' :u 'uniform' :v 'victor' :w 'whiskey' :x 'x-ray' :y 'yankee' :z 'zulu' }

pluralize-with clj/s

(pluralize-with N base-str)

Returns base-str when N=1; otherwise appends an s

quotes->double clj/s

(quotes->double arg)

Inputs: [arg :- s/Str] Returns: s/Str

Converts all single-quotes in a string to double-quotes

quotes->single clj/s

(quotes->single arg)

Inputs: [arg :- s/Str] Returns: s/Str

Converts all double-quotes in a string to single-quotes

re-quote-replacement clj

Alias for clojure.string/re-quote-replacement

replace clj/s

Alias for clojure.string/replace

replace-first clj/s

Alias for clojure.string/replace-first

reverse clj/s

Alias for clojure.string/reverse

split clj/s

Alias for clojure.string/split

split-lines clj/s

Alias for clojure.string/split-lines

starts-with? clj/s

Alias for clojure.string/starts-with?

str->kw-normalized clj/s

(str->kw-normalized arg)

Returns a keyword constructed from a normalized string

str-keep-left clj/s

(str-keep-left str-val n)

Keeps the N left-most chars of a string

str-keep-right clj/s

(str-keep-right str-val n)

Keeps the N right-most chars of a string

string->stream clj

(string->stream str-val)

Inputs: [str-val :- s/Str] Returns: InputStream

tabs->spaces clj/s≠

clj

(tabs->spaces src-str)

(tabs->spaces tab-size src-str)

cljs

(tabs->spaces G__127544)

(tabs->spaces G__127548 G__127549)

Inputs: ([src-str :- s/Str] [tab-size :- s/Int src-str :- s/Str]) Returns: s/Str

Replaces all tabs with appropriate number of spaces (default tab-size => 8) Usage:

  (tabs->spaces   'abc<tab>def'  => 'ab      cd'
  (tabs->spaces 4 'ab<tab>cd'    => 'ab  cd'

take clj/s

(take n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Drops the first N chars of a string, returning a string result.

text? clj/s

(text? & args)

Returns true iff every char passes tupelo.chars/text?

trim clj/s

Alias for clojure.string/trim

trim-newline clj/s

Alias for clojure.string/trim-newline

triml clj/s

Alias for clojure.string/triml

trimr clj/s

Alias for clojure.string/trimr

upper-case clj/s

Alias for clojure.string/upper-case

uppercase? clj/s

(uppercase? & args)

Returns true iff every char passes tupelo.chars/uppercase?

visible? clj/s

(visible? & args)

Returns true iff every char passes tupelo.chars/visible?

walk-clojurize-keys clj/s

(walk-clojurize-keys form)

Recursively walks form, normalizing all map keys via clojurize-key.

walk-keywords->strings clj/s

(walk-keywords->strings form)

Recursively walks form, converting all keywords to strings.

walk-strings->keywords clj/s

(walk-strings->keywords form)

Recursively walks form, converting all strings to keywords.

whitespace-collapse clj/s

(whitespace-collapse arg)

Inputs: [arg :- s/Str] Returns: s/Str

Replaces all consecutive runs of whitespace characters (including newlines) with a single space. Removes any leading or trailing whitespace. Returns a string composed of all tokens separated by a single space.

whitespace-eol? clj/s

(whitespace-eol? & args)

Returns true iff every char passes tupelo.chars/whitespace-eol?

whitespace-horiz? clj/s

(whitespace-horiz? & args)

Returns true iff every char passes tupelo.chars/whitespace-horiz?

whitespace-remove clj/s

(whitespace-remove arg)

Inputs: [arg :- s/Str] Returns: s/Str

Removes all whitespace characters (including newlines) from string.

whitespace? clj/s

(whitespace? & args)

Returns true iff every char passes tupelo.chars/whitespace?