Regular Expressions in Prolog

Our first example demonstrates how to use regular expressions in Prolog. Here’s the full source code:

:- use_module(library(pcre)).

main :-
    % This tests whether a pattern matches a string.
    re_match("p([a-z]+)ch", "peach"),
    writeln(true),

    % Compile an optimized regex pattern
    re_compile("p([a-z]+)ch", [], Regex),

    % Test if the compiled regex matches a string
    re_match(Regex, "peach"),
    writeln(true),

    % Find the first match for the regex
    re_matchsub(Regex, "peach punch", _{0:Match}),
    writeln(Match),

    % Find the start and end indexes for the match
    re_matchsub(Regex, "peach punch", _{0:Match}, [offset(Offset)]),
    format("idx: [~w ~w]~n", [Offset, Offset + string_length(Match, _)]),

    % Find submatch information
    re_matchsub(Regex, "peach punch", Captures),
    writeln(Captures),

    % Find all matches
    findall(Match, re_matchsub(Regex, "peach punch pinch", _{0:Match}), Matches),
    writeln(Matches),

    % Replace subsets of strings
    re_replace("p([a-z]+)ch", "<fruit>", "a peach", Result),
    writeln(Result),

    % Transform matched text with a given predicate
    re_replace("p([a-z]+)ch", upper, "a peach", UpperResult),
    writeln(UpperResult).

upper(Match, Upper) :-
    string_upper(Match, Upper).

To run the program, save it as regular_expressions.pl and use the Prolog interpreter:

$ swipl -s regular_expressions.pl -g main -t halt
true
true
peach
idx: [0 5]
_{0:"peach",1:"ea"}
["peach","punch","pinch"]
a <fruit>
a PEACH

In this Prolog example, we’re using the PCRE (Perl Compatible Regular Expressions) library, which provides powerful regular expression capabilities.

We start by testing if a pattern matches a string using re_match/2. Then, we compile an optimized regex pattern with re_compile/3 for more efficient repeated use.

The re_matchsub/3 predicate is used to find matches and submatches. It returns a dict with the full match and any captured groups.

To find all matches, we use findall/3 in combination with re_matchsub/3.

The re_replace/4 predicate is used for replacing subsets of strings. We can either provide a replacement string or a predicate (like upper/2) to transform the matched text.

Note that Prolog’s approach to regular expressions is somewhat different from imperative languages. It uses pattern matching and backtracking, which can be very powerful for certain types of problems.

For a complete reference on Prolog’s PCRE library, check the SWI-Prolog documentation.

Text Templates in Prolog

Random Numbers in Prolog

Learn X By Example

Title here

Regular Expressions in Prolog