CrossClj

1.2.0 docs

SourceDocs



RECENT
    VARS
    blank?
    butlast
    capitalize
    chomp
    chop
    codepoints
    contains?
    dochars
    docodepoints
    drop
    escape
    get
    grep
    join
    lower-case
    ltrim
    map-str
    partial
    partition
    repeat
    replace
    replace-first
    reverse
    rtrim
    split
    split-lines
    swap-case
    tail
    take
    title-case
    trim
    upper-case

    « Index of all namespaces of this project

    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/

    — Stuart Sierra

    (blank? s)
    True if s is nil, empty, or contains only whitespace.
    
    (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 ->
    (capitalize s)
    Converts first character of the string to upper-case, all other
    characters to lower-case.
    (chomp s)
    Removes all trailing newline \n or return \r characters from
    string.  Note: String.trim() is similar and faster.
    (chop s)
    Removes the last character of string, does nothing on a zero-length
    string.
    (codepoints s)
    Returns a sequence of integer Unicode code points in s.  Handles
    Unicode supplementary characters (above U+FFFF) correctly.
    (contains? s substring)
    True if s contains the substring.
    
    macro
    (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).
    macro
    (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.
    (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 ->
    (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.
    (get s i)
    Gets the i'th character in string.
    
    (grep re coll)
    Filters elements of coll by a regular expression.  The String
    representation (with str) of each element is tested with re-find.
    (join separator coll)
    Returns a string of all elements in coll, separated by
    separator.  Like Perl's join.
    (lower-case s)
    Converts string to all lower-case.
    
    (ltrim s)
    Removes whitespace from the left side of string.
    
    (map-str f coll)
    Apply f to each element of coll, concatenate all results into a
    String.
    (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))
    (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")
    (repeat s n)
    Returns a new String containing s repeated n times.
    
    multimethod
    (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.)
    multimethod
    (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
    (reverse s)
    Returns s with its characters reversed.
    
    (rtrim s)
    Removes whitespace from the right side of string.
    
    (split s re)(split s re limit)
    Splits string on a regular expression.  Optional argument limit is
    the maximum number of splits.
    (split-lines s)
    Splits s on \n or \r\n.
    
    (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.
    (tail s n)
    Returns the last n characters of s.
    
    (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 ->
    (trim s)
    Removes whitespace from both ends of string.
    
    (upper-case s)
    Converts string to all upper-case.