clojure-contrib v1.1 API
Namespaces
Other Versions
Clojure Home

API for str-utils2 - clojure-contrib v1.1 (stable)

by Stuart Sierra
Full namespace name: clojure.contrib.str-utils2

Overview

This is a library of string manipulation functions.  It
is intented as a replacement for clojure.contrib.str-utils.

You cannot (use 'clojure.contrib.str-utils2) because it defines
functions with the same names as functions in clojure.core.
Instead, do (require '[clojure.contrib.str-utils2 :as s]) 
or something similar.

Goals:
  1. Be functional
  2. String argument first, to work with ->
  3. Performance linear in string length

Some ideas are borrowed from
http://github.com/francoisdevlin/devlinsf-clojure-utils/

Public Variables and Functions


blank?

function
Usage: (blank? s)

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

butlast

function
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 ->
Source

capitalize

function
Usage: (capitalize s)

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

chomp

function
Usage: (chomp s)

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

chop

function
Usage: (chop s)

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

codepoints

function
Usage: (codepoints s)

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

contains?

function
Usage: (contains? s substring)

True if s contains the substring.
Source

dochars

macro
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).
Source

docodepoints

macro
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.
Source

drop

function
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 ->
Source

escape

function
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.
Source

get

function
Usage: (get s i)

Gets the i'th character in string.
Source

grep

function
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.
Source

join

function
Usage: (join separator coll)

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

lower-case

function
Usage: (lower-case s)

Converts string to all lower-case.
Source

ltrim

function
Usage: (ltrim s)

Removes whitespace from the left side of string.
Source

map-str

function
Usage: (map-str f coll)

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

partial

function
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))
Source

partition

function
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")
Source

repeat

function
Usage: (repeat s n)

Returns a new String containing s repeated n times.
Source

replace

multimethod
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.)
Source

replace-first

multimethod
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
Source

reverse

function
Usage: (reverse s)

Returns s with its characters reversed.
Source

rtrim

function
Usage: (rtrim s)

Removes whitespace from the right side of string.
Source

split

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

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

split-lines

function
Usage: (split-lines s)

Splits s on \n or \r\n.
Source

swap-case

function
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.
Source

tail

function
Usage: (tail s n)

Returns the last n characters of s.
Source

take

function
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 ->
Source

trim

function
Usage: (trim s)

Removes whitespace from both ends of string.
Source

upper-case

function
Usage: (upper-case s)

Converts string to all upper-case.
Source
Logo & site design by Tom Hickey.
Clojure auto-documentation system by Tom Faulhaber.