The regular-expressions Library

Overview

The regular-expressions library exports the regular-expressions module, which contains functions that compile and search for regular expressions. The module has the same semantics as Perl (version 4) unless otherwise noted.

A regular expression that is grammatically correct may still be illegal if it contains an infinitely quantified sub-regex that matches the empty string. That is, if R is a regex that can match the empty string, then any regex containing R*, R+, and R{n,} is illegal. In this case, the regular-expressions library will signal an <invalid-regex> error when the regex is parsed.

Quick Start

The most common use of regular expressions is probably to perform a search and figure out what text matched and/or where it occurred in a string. You need to use regular-expressions; in both your library and your module, and then…

define constant $re :: <regex> = compile-regex("^abc(.+)123$");

let match :: false-or(<regex-match>) = regex-search($re, "abcdef123");
// match is #f if search failed.

if (match)
  let text = match-group(match, 1);
  // text = "def"

  let (text, start, _end) = match-group(match, 1);
  // text = "def", start = 3, _end = 6

  match-group(match, 2) => error: <invalid-match-group>
  // group 0 is the entire match
  ...
end;

compile-regex("*") => error: <invalid-regex>

Reference

<regex> Sealed Class

A compiled regular expression object. These should only be created via compile-regex.

<regex-error> Sealed Class

The superclass of all regular expression-related errors.

Superclasses

<format-string-condition>, <error>

<invalid-regex> Sealed Class

Signalled by compile-regex when the given regular expression cannot be compiled.

Superclasses

<regex-error>

Init-Keywords
  • pattern

regex-error-pattern Sealed Generic function

Return the pattern that caused an <invalid-regex> error.

Signature

regex-error-pattern error => pattern

Parameters
Values
<invalid-match-group> Sealed Class

Signalled when an invalid group identifier is passed to match-group.

Superclasses

<regex-error>

<regex-match> Sealed Class

Stores the match groups and other information about a specific regex search result.

Superclasses

<object>

Init-Keywords
  • regular-expression

compile-regex Sealed Generic function

Compile a string into a <regex>.

Signature

compile-regex pattern #key case-sensitive verbose multi-line dot-matches-all use-cache => regex

Parameters
  • pattern – A <string>.

  • case-sensitive (#key) – A <boolean>, default #t.

  • verbose (#key) – A <boolean>, default #f.

  • multi-line (#key) – A <boolean>, default #f.

  • dot-matches-all (#key) – A <boolean>, default #f.

  • use-cache (#key) – A <boolean>, default #t. If true, the resulting regular expression will be cached and re-used the next time the same string is compiled.

Values
Conditions

<invalid-regex> is signalled if pattern can’t be compiled.

regex-pattern Sealed Generic function

Return the <string> from which regex was created.

Signature

regex-pattern regex => pattern

Parameters
Values
regex-group-count Sealed Generic function

Return the number of groups in a <regex>.

Signature

regex-group-count regex => num-groups

Parameters
Values
regex-position Sealed Generic function

Find the position of pattern in text.

Signature

regex-position pattern text #key start end case-sensitive => regex-start, #rest marks

Parameters
  • pattern – A <regex>.

  • text – A <string>.

  • start (#key) – A <integer>, default 0. The index at which to start the search.

  • end (#key) – An <integer>, default *text*.size. The index at which to end the search.

  • case-sensitive (#key) – A <boolean>, default #t.

Values
  • regex-start – An instance of false-or(<integer>).

  • #rest marks – An instance of <object>.

A match will only be found if it fits entirely within the range specified by start and end.

If the regular expression is not found, return #f, otherwise return a variable number of indices marking the start and end of groups.

This is a low-level API. Use regex-search if you want to get a <regex-match> object back.

regex-replace Sealed Generic function

Replace occurrences of pattern within big with replacement.

Signature

regex-replace big pattern replacement #key start end count case-sensitive => new-string

Parameters
  • big – The <string> within which to search.

  • pattern – The <regex> to search for.

  • replacement – The <string> to replace pattern with.

  • start (#key) – An <integer>, default 0. The index in big at which to start searching.

  • end (#key) – An <integer>, default *big*.size. The index at which to end the search.

  • case-sensitive (#key) – A <boolean>, default #t.

  • count (#key) – An instance of false-or(<integer>), default #f. The number of matches to replace. #f means to replace all.

Values
  • new-string – An instance of <string>.

A match will only be found if it fits entirely within the range specified by start and end.

Search for a pattern within text.

Signature

regex-search pattern text #key anchored start end case-sensitive => match

Parameters
  • pattern – The <regex> to search for.

  • text – The <string> in which to search.

  • anchored (#key) – A <boolean>, default #f. Whether or not the search should be anchored at the start position. This is useful because “^…” will only match at the beginning of a string, or after n if the regex was compiled with multi-line = #t.

  • start (#key) – An <integer>, default 0. The index in text at which to start searching.

  • end (#key) – An <integer>, default *text*.size. The index at which to end the search.

  • case-sensitive (#key) – A <boolean>, default #t.

Values
  • match – An instance of false-or(<regex-match>). #f is returned if no match was found.

A match will only be found if it fits entirely within the range specified by start and end.

regex-search-strings Sealed Generic function

Find all matches for a regular expression within a string.

Signature

regex-search-strings pattern text #key anchored start end case-sensitive => #rest strings

Parameters
  • pattern – An instance of <regex>.

  • text – An instance of <string>.

  • anchored (#key) – An instance of <boolean>.

  • start (#key) – An <integer>, default 0. The index in text at which to start searching.

  • end (#key) – An <integer>, default *text*.size. The index at which to end the search.

  • case-sensitive (#key) – A <boolean>, default #t.

Values
  • #rest strings – An instance of <object>.

A match will only be found if it fits entirely within the range specified by start and end.

match-group Sealed Generic function

Return information about a specific match group in a <regex-match>.

Signature

match-group match group => text start-index end-index

Parameters
Values
  • text – An instance of false-or(<string>).

  • start-index – An instance of false-or(<integer>).

  • end-index – An instance of false-or(<integer>).

Conditions

<invalid-match-group> is signalled if group does not name a valid group.

The requested group may be an <integer> to access groups by number, or a <string> to access groups by name. Accessing groups by name only works if they were given names in the compiled regular expression via the (?<foo>...) syntax.

Group 0 is always the entire regular expression match.

It is possible for the group identifier to be valid and for #f to be returned. This can happen, for example, if the group was in the part of an | (or) expression that didn’t match.