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 (of type  <regexp>) for repeated matches.

 

 

Figure 2.2: Grammar for regular expressions

The format of a regular expression is specified by the grammar in Figure 2.2. The regular expression procedures are:

•   (regexp str) takes a string representation of a regular expression and compiles it into a regexp value. Other regular expression procedures can take 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 or #f otherwise.
•   (regexp-match pattern str) attempts to match pattern (a string or a regexp value) to a portion of str. If the match fails, #f is returned. If the match succeeds, a list of strings is returned. The first string in this list is the portion of str that matched pattern. If two portions of str can match pattern, then the earliest and longest match is found.

  Additional strings are returned in the list if pattern contains parenthesized subexpressions; matches for the subexpressions are provided in the order of the opening parentheses in pattern. When sub-expressions occur in different branches of an ``or'' (|), a #f is returned for each sub-expression that was not used in the match. When a single sub-expression is used multiple times in a match (e.g., a sub-expression is followed by ``*''), then the rightmost match associated with the sub-expression is returned in the list.

•   (regexp-match-positions pattern str) is like regexp-match, but instead of returning a list of strings, a list of number pairs is returned. Each pair of numbers refers to the range of characters in str that matched the corresponding (sub-)expression.
•   (regexp-replace pattern src insert) performs a match using pattern on src and then returns a string in which the matching portion of src is replaced with insert. If pattern matches no part of src, then src is returned unmodified.

  If insert contains ``&'', then ``&'' is replaced with the matching portion of src before it is substituted into src. If insert contains `` n'' (for some integer n), then it is replaced with the nth matching sub-expression from src. ``&'' 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.

Examples:

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