Regular Expressions

MzScheme provides built-in support for regular expression pattern matching on strings, implemented by Henry Spencer's package. Regular expressions are specified as strings, using the same pattern language as the Unix utility egrep. String-based regular expressions can be compiled into a regexp value for repeated matches. The internal size of a regexp value is limited to 32 kilobytes; this limit roughly corresponds to a source string with 32,000 literal characters or 5,000 special characters.

Figure 10.1: Grammar for regular expressions

The format of a regular expression is specified by the grammar in Figure 10.1. A few subtle points about the regexp language are worth noting:

• When an opening square bracket (``['') that starts a range is immediately followed by a closing square bracket (``]''), then the closing square bracket is part of the range, instead of ending an empty range. For example, "[]a]" matches any string that contains a lowercase ``a'' or a closing square bracket. A dash (``-'') at the start or end of a range is treated specially in the same way.
• When a caret (``^'') or dollar sign (``$'') appears in the middle of a regular expression (not in a range), the resulting regexp is legal even though it is usually not matchable. For example, "a$b" is unmatchable, because no string can contain the letter ``b'' after the end of the string. In contrast, "a$b*" matches any string that ends with a lowercase ``a'', since zero ``b''s will match the part of the regexp after ``$''.
• A backslash (``\'') in a regexp pattern specified with a Scheme string literal must be protected with an additional backslash. For example, the string "\\." describes a pattern that matches any string containing a period. In this case, the first backslash protects the second to generate a Scheme string containing two characters; the second backslash (which is the first slash in the actual string value) protects the period in the regexp pattern.

The regular expression procedures are:

• (regexp string) takes a string representation of a regular expression and compiles it into a regexp value. Other regular expression procedures accept either a string or a regexp value as the matching pattern. If a regular expression string is used multiple times, it is faster to compile the string once to a regexp value and use it for repeated matches instead of using the string each time.
• (regexp? v) returns #t if v is a regexp value created by regexp, #f otherwise.
• (regexp-match pattern string [start end]) attempts to match pattern (a string or a regexp value) to a portion of string. The optional start and end arguments select a substring of string for matching (where the default is the entire string). If the match fails, #f is returned. If the match succeeds, a list containing strings, and possibly #f, is returned. The first string in this list is the portion of string that matched pattern. If two portions of string can match pattern, then the earliest and longest match is found.

  Additional strings are returned in the list if pattern contains parenthesized sub-expressions; matches for the sub-expressions are provided in the order of the opening parentheses in pattern. When sub-expressions occur in branches of an ``or'' (``|''), in a ``zero or more'' pattern (``*''), or in a ``zero or one'' pattern (``?''), a #f is returned for the expression if it did not contribute to the final match. When a single sub-expression occurs in a ``zero or more'' pattern (``*'') or a ``one or more'' pattern (``+'') and is used multiple times in a match, then the rightmost match associated with the sub-expression is returned in the list.

• (regexp-match-positions pattern string [start end]) is like regexp-match, but returns a list of number pairs instead of a list of strings. Each pair of numbers refers to a range of characters in string in a substring-compatible manner. Regardless of whether start is specified, the returned positions correspond to positions within string.
• (regexp-replace pattern string insert-string) performs a match using pattern on string and then returns a string in which the matching portion of string is replaced with insert-string. If pattern matches no part of string, then string is returned unmodified.

  If insert-string contains ``&'', then ``&'' is replaced with the matching portion of string before it is substituted into string. If insert-string contains ``\n'' (for some integer n), then it is replaced with the nth matching sub-expression from string. ``&'' and ``\0'' are synonymous. If the nth sub-expression was not used in the match or if n is greater than the number of sub-expressions in pattern, then ``\n'' is replaced with the empty string.

  A literal ``&'' or ``\'' is specified as ``\&'' or ``\\'', respectively. If insert-string contains ``\$'', then ``\$'' is replaced with the empty string. (This can be used to terminate a number n following a backslash.) If a ``\'' is followed by anything other than a digit, ``&'', ``\'', or ``$'', then it is treated as ``\0''.

  (regexp-replace* pattern string insert-string) is the same as regexp-replace, except that every instance of pattern in string is replaced with insert-string. Only non-overlapping instances of pattern in the original string are replaced, so instances of pattern within inserted strings are not replaced recursively.

Examples:

  (define r (regexp "(-[0-9]*)+")) 
  (regexp-match r "a-12-345b") ; => ("-12-345" "-345") 
  (regexp-match-positions r "a-12-345b") ; => ((1 . 10) (5 . 10)) 
  (regexp-match "x+" "12345") ; => #f 
  (regexp-replace "mi" "mi casa" "su") ; => "su casa" 
  (define r2 (regexp "([Mm])i ([a-zA-Z]*)")) 
  (define insert "\\1y \\2") 
  (regexp-replace r2 "Mi Casa" insert) ; => "My Casa" 
  (regexp-replace r2 "mi cerveza Mi Mi Mi" insert) ; => "my cerveza Mi Mi Mi"
  (regexp-replace* r2 "mi cerveza Mi Mi Mi" insert) ; => "my cerveza My Mi Mi"