Crate ere

This crate provides tools for compiling and using regular expressions. It is intended as a simple but compiler-checked version of the regex crate, as it does regular expression compilation at compile-time, but only supports POSIX Extended Regular Expressions.

Usage

use ere::prelude::*;

const PHONE_REGEX: Regex<2> = compile_regex!(r"^(\+1 )?[0-9]{3}-[0-9]{3}-[0-9]{4}$");
fn test() {
    assert!(PHONE_REGEX.test("012-345-6789"));
    assert!(PHONE_REGEX.test("987-654-3210"));
    assert!(PHONE_REGEX.test("+1 555-555-5555"));
    assert!(PHONE_REGEX.test("123-555-9876"));

    assert!(!PHONE_REGEX.test("abcd"));
    assert!(!PHONE_REGEX.test("0123456789"));
    assert!(!PHONE_REGEX.test("012--345-6789"));
    assert!(!PHONE_REGEX.test("(555) 555-5555"));
    assert!(!PHONE_REGEX.test("1 555-555-5555"));
}

const COLOR_REGEX: Regex<5> = compile_regex!(
    r"^#?([[:xdigit:]]{2})([[:xdigit:]]{2})([[:xdigit:]]{2})([[:xdigit:]]{2})?$"
);
fn exec() {
    assert_eq!(
        COLOR_REGEX.exec("#000000"),
        Some([
            Some("#000000"),
            Some("00"),
            Some("00"),
            Some("00"),
            None,
        ]),
    );
    assert_eq!(
        COLOR_REGEX.exec("1F2e3D"),
        Some([
            Some("1F2E3D"),
            Some("1F"),
            Some("2e"),
            Some("3D"),
            None,
        ]),
    );
    assert_eq!(
        COLOR_REGEX.exec("ffffff80"),
        Some([
            Some("ffffff80"),
            Some("ff"),
            Some("ff"),
            Some("ff"),
            Some("80"),
        ]),
    );

    assert_eq!(PHONE_REGEX.exec("green"), None);
    assert_eq!(PHONE_REGEX.exec("%FFFFFF"), None);
    assert_eq!(PHONE_REGEX.exec("#2"), None);
}

To minimize memory overhead and binary size, it is recommended to create a single instance of each regular expression (using a const variable) rather than creating multiple.

Some features are not fully implemented, such as POSIX-mode ambiguous submatch rules (we currently use greedy mode, which is the much more common and efficient method). See the roadmap for more details.

Alternatives

ere is intended as an alternative to regex that provides compile-time checking and regex compilation. However, ere is less featureful, so here are a few reasons you might prefer regex:

• You require more complex regular expressions with features like backreferences and word boundary checking (which are unavailable in POSIX EREs).
• You need run-time-compiled regular expressions (such as when provided by the user).
• Your regular expression runs significantly more efficiently on a specific regex engine not currently available in ere.

Modules

nfa_static

Implements a version of WorkingNFA that can be serialized statically into a binary.

parse_tree

Implements the ERE parser and primitive types (like Atom).

pike_vm

Implements a Pike VM-like regex engine.

pike_vm_u8

Implements a Pike VM-like regex engine for u8s.

prelude

Includes the basic things you’ll need.

simplified_tree

Implements a simplified intermediate representation of a regular expression.

working_nfa

Implements the primary compile-time intermediate WorkingNFA structure for optimization.

Macros

compile_regex

This is the primary entrypoint to the ere crate. Checks and compiles a regular expression into a Regex<N>.

compile_regex_pikevm

Checks and compiles a regular expression into a [ere_core::pike_vm::PikeVM<N>]. Unless you specifically want this engine, you might want to use compile_regex! instead.

compile_regex_u8onepass

Checks and compiles a regular expression into a [ere_core::one_pass_u8::U8OnePass<N>]. Unless you specifically want this engine, you might want to use compile_regex! instead.

compile_regex_u8pikevm

Checks and compiles a regular expression into a [ere_core::pike_vm_u8::U8PikeVM<N>]. Unless you specifically want this engine, you might want to use compile_regex! instead.

Structs

Regex

A regular expression (specifically, a POSIX ERE).