Overview
API Index
Namespaces:

API for str-utils2

by Stuart Sierra

Usage: 
(ns your-namespace
  (:require 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.