${re g regexp [ arg...]}

Yields a list of each arg that matches regexp.

${re v regexp [ arg...]}

Yields a list of each arg that does not match regexp.

${re m regexp arg}

Yields the portion of arg that matches regexp, or an empty list if there was no match.

${re M regexp arg}

Yields a list consisting of the portion of arg that matches regexp, followed by list elements giving the portion of arg that matched each parenthesized subexpression in turn.

${re mg regexp arg}

Similar to re m except that it applies the match consecutively through arg, yielding a list of all the portions of arg that match regexp. If a match is made to the null string, no subsequent substitutions will take place.

${re s regexp subs [ arg... ]}

For each arg, re s substitutes the first occurrence of regexp (if any) by subs. If subs contains a sequence of the form \d where d is a single decimal digit, the dth parenthesised subexpression in regexp will be substituted in its place. \0 is substituted by the entire match. If any other character follows a backslash (\), that character will be substituted. Arguments which contain no match to regexp will be left unchanged.

${re sg regexp subs [ arg... ]}

Similar to re s except that all matches of regexp within each arg will be substituted for, rather than just the first match. Only one occurrence of the null string is substituted.

	ls -l ${re g '\.(sbl|dis)$' *}

Break string up into its constituent characters, putting the result in shell variable x:

	x = ${re mg '.|\n' string}

Quote a string s so that it can be used as a literal regular expression without worrying about metacharacters:

	s = ${re sg '[*|[\\+.^$()?]' '\\\0' $s}

Define a substitution function pat2regexp to convert shell-style patterns into equivalent regular expressions (e.g. ``?.sbl*'' would become ``^.\.sbl.*$''):

	load std
	subfn pat2regexp {
		result = '^' ^ ${re sg '\*' '.*'
			${re sg '?' '.'
				${re sg '[()+\\.^$|]' '\\\0' $*}
			}
		} ^ '$'
	}