Struct Regex 

pub struct Regex { /* private fields */ }

A compiled regular expression.

A Regex is obtained by compiling a pattern with Regex::new (default flags) or Regex::new_with_flags, then used to search text via methods like find, is_match, find_iter, find_partial, replace and split.

Compilation is somewhat expensive; compile once and reuse the same Regex across many inputs. A Regex is Send + Sync once compiled (it owns no thread-local state) and is cheap to share by reference.

Examples

use eregex::{flags, Regex};

let re = Regex::new(r"(\w+)@(\w+)")?;
let m = re.find("ping alice@work").unwrap();
assert_eq!(m.group(1), Some("alice"));
assert_eq!(m.group(2), Some("work"));

Implementations

impl Regex

pub fn new(pattern: &str) -> Result<Regex>

Compile pattern with the default flags.

Errors

Returns Error if pattern is syntactically invalid (unbalanced parentheses, bad escape sequences, invalid quantifiers, unknown group names, etc.). See ErrorKind for the full list.

Examples

use eregex::Regex;

let re = Regex::new(r"\d{3}-\d{2}")?;
assert!(re.is_match("123-45"));
assert!(Regex::new(r"(").is_err());

Examples found in repository

examples/gap_match.rs (line 106)

fn stm32_segments() -> Vec<Segment> {
    vec![
        Segment {
            re: Regex::new(r"STM32F").unwrap(),
            label: "STM32F",
        },
        Segment {
            re: Regex::new(r"[0-9]{3}[A-Z0-9]{4}").unwrap(),
            label: "407VGT6",
        },
    ]
}

/// The full, contiguous pattern used to re-validate the reconstruction and to
/// recover clean capture groups (STM32 / F407 / VGT6).
const FULL: &str = r"(STM32)(F[0-9]{3})([A-Z0-9]{4})";

fn report(name: &str, hay: &str, max_gap: usize) {
    println!("\n=== {name} ===");
    println!("haystack: {hay:?}");

    // (1) Show what the bare engine does — both strict and end-anchored partial.
    let full = Regex::new(FULL).unwrap();
    println!(
        "  find         : {:?}",
        full.find(hay).map(|m| m.as_str().to_string())
    );
    println!(
        "  find_partial : {:?}",
        match full.find_partial(hay) {
            None => "None".to_string(),
            Some(p) => format!("{:?} matched={:?}", p.status, p.matched),
        }
    );

    // (2) Gap-tolerant shift-and-resume search.
    match gap_find(hay, &stm32_segments(), max_gap) {
        Some(gm) => {
            println!("  gap_find     : OK");
            println!("    reconstructed = {:?}", gm.reconstructed);
            for (label, s, e) in &gm.segments {
                println!("    segment {label:<8} = [{s}..{e}] {:?}", &hay[*s..*e]);
            }
            for (s, e) in &gm.skipped {
                println!("    skipped        = [{s}..{e}] {:?}", &hay[*s..*e]);
            }

            // (3) Re-validate the reconstruction with the FULL pattern and
            //     report clean groups. This is also where `find_partial`
            //     earns its keep: it confirms Full vs Partial.
            let p = full
                .find_partial(&gm.reconstructed)
                .expect("reconstruction must re-match the full pattern");
            assert_eq!(p.status, MatchStatus::Full, "reconstruction must be Full");
            println!(
                "    groups = [STM32={:?}, F407={:?}, VGT6={:?}]",
                p.group(1),
                p.group(2),
                p.group(3),
            );

            // The caller asked specifically about #2: group 2 (`F407`) is
            // assembled from TWO non-contiguous haystack ranges — the `F` at
            // the tail of segment 1 and the `407` at the head of segment 2.
            if name.contains("#2") {
                let (_, _, seg1_end) = gm.segments[0];
                let (_, seg2_start, _) = gm.segments[1];
                println!(
                    "    group F407 split = [{}..{}] + [{}..{}]  (\"F\" + \"407\")",
                    seg1_end - 1,
                    seg1_end,
                    seg2_start,
                    seg2_start + 3
                );
            }
        }
        None => println!("  gap_find     : None (NoMatch)"),
    }
}

fn main() {
    // #2 / #10 — the main case: real noise between `F` and `407`.
    // Gap = the " dutyu7 8 " run (≤ 16 bytes), so it is accepted.
    report(
        "#2 split by noise (max_gap=16)",
        "Microcontroller STM32F dutyu7 8 407VGT6   ",
        16,
    );

    // #9 — same shape, but max_gap=8 rejects the run.
    report(
        "#9 gap too long (max_gap=8)",
        "Microcontroller STM32F very very very long unrelated text 407VGT6",
        8,
    );

    // #7 — a wrong char *inside* the digits segment (`X` where a digit is
    // expected). No `[0-9]{3}` run exists, so the segment search fails.
    report(
        "#7 wrong char inside series",
        "Microcontroller STM32FX07VGT6",
        16,
    );

    // #8 — wrong family (`STM8` instead of `STM32`): the first segment is
    // never found.
    report("#8 wrong family", "Microcontroller STM8F407VGT6", 16);

    // #1 — the contiguous happy path: no gap, reconstruction == input tail.
    report(
        "#1 contiguous full match",
        "Microcontroller STM32F407VGT6",
        16,
    );

    println!("\n--- end-of-input partials (find_partial alone, no gap mode) ---");
    let full = Regex::new(FULL).unwrap();
    for hay in [
        "Microcontroller STM32F",
        "Microcontroller STM32F40",
        "Microcontroller STM32F407VG",
    ] {
        let p = full.find_partial(hay).unwrap();
        println!(
            "  {:<32} -> {:?} matched={:?} g1={:?} g2={:?} g3={:?}",
            hay,
            p.status,
            p.matched,
            p.group(1),
            p.group(2),
            p.group(3)
        );
    }

    println!("\nAll reconstruction checks passed.");
}

examples/demo.rs (line 6)

fn main() {
    let re = Regex::new(r"(?P<word>\w+)\s+(?P<num>\d+)").unwrap();
    let m = re.find("hello 42 world").unwrap();
    println!("match: {:?}", m.as_str());
    println!("word = {:?}", m.name("word"));
    println!("num  = {:?}", m.name("num"));

    // Repeated captures — a signature mrab-regex feature.
    let re = Regex::new(r"(\w)+").unwrap();
    let m = re.find("abc").unwrap();
    println!("captures of group 1: {:?}", m.captures(1));

    // Lookbehind (variable length) + case-insensitive.
    let re = Regex::new(r"(?i)(?<=foo)bar").unwrap();
    println!("lookbehind: {:?}", re.find("FOObar"));

    // Atomic group prevents catastrophic backtracking.
    let re = Regex::new(r"a(?>b*)b").unwrap();
    println!("atomic find: {:?}", re.find("abbbbc"));

    // Replace with named groups.
    let re = Regex::new(r"(?P<first>\w+),(?P<second>\w+)").unwrap();
    println!(
        "replace: {}",
        re.replace_all("a,b x,y", "${second} ${first}")
    );

    // Flags constant.
    let re = Regex::new_with_flags(r"hello", flags::IGNORECASE | flags::MULTILINE).unwrap();
    println!("flags: {:x}", re.flags().bits());
}

pub fn new_with_flags(pattern: &str, flags: Flags) -> Result<Regex>

Compile pattern with the given Flags.

Errors

Returns Error on the same conditions as Regex::new.

Examples

use eregex::{flags, Regex};

let re = Regex::new_with_flags(r"hello", flags::IGNORECASE)?;
assert_eq!(re.find("HELLO, World").unwrap().as_str(), "HELLO");

Examples found in repository

examples/demo.rs (line 33)

fn main() {
    let re = Regex::new(r"(?P<word>\w+)\s+(?P<num>\d+)").unwrap();
    let m = re.find("hello 42 world").unwrap();
    println!("match: {:?}", m.as_str());
    println!("word = {:?}", m.name("word"));
    println!("num  = {:?}", m.name("num"));

    // Repeated captures — a signature mrab-regex feature.
    let re = Regex::new(r"(\w)+").unwrap();
    let m = re.find("abc").unwrap();
    println!("captures of group 1: {:?}", m.captures(1));

    // Lookbehind (variable length) + case-insensitive.
    let re = Regex::new(r"(?i)(?<=foo)bar").unwrap();
    println!("lookbehind: {:?}", re.find("FOObar"));

    // Atomic group prevents catastrophic backtracking.
    let re = Regex::new(r"a(?>b*)b").unwrap();
    println!("atomic find: {:?}", re.find("abbbbc"));

    // Replace with named groups.
    let re = Regex::new(r"(?P<first>\w+),(?P<second>\w+)").unwrap();
    println!(
        "replace: {}",
        re.replace_all("a,b x,y", "${second} ${first}")
    );

    // Flags constant.
    let re = Regex::new_with_flags(r"hello", flags::IGNORECASE | flags::MULTILINE).unwrap();
    println!("flags: {:x}", re.flags().bits());
}

pub fn as_str(&self) -> &str

The original pattern string.

pub fn flags(&self) -> Flags

The resolved flags in effect.

Examples found in repository

examples/demo.rs (line 34)

fn main() {
    let re = Regex::new(r"(?P<word>\w+)\s+(?P<num>\d+)").unwrap();
    let m = re.find("hello 42 world").unwrap();
    println!("match: {:?}", m.as_str());
    println!("word = {:?}", m.name("word"));
    println!("num  = {:?}", m.name("num"));

    // Repeated captures — a signature mrab-regex feature.
    let re = Regex::new(r"(\w)+").unwrap();
    let m = re.find("abc").unwrap();
    println!("captures of group 1: {:?}", m.captures(1));

    // Lookbehind (variable length) + case-insensitive.
    let re = Regex::new(r"(?i)(?<=foo)bar").unwrap();
    println!("lookbehind: {:?}", re.find("FOObar"));

    // Atomic group prevents catastrophic backtracking.
    let re = Regex::new(r"a(?>b*)b").unwrap();
    println!("atomic find: {:?}", re.find("abbbbc"));

    // Replace with named groups.
    let re = Regex::new(r"(?P<first>\w+),(?P<second>\w+)").unwrap();
    println!(
        "replace: {}",
        re.replace_all("a,b x,y", "${second} ${first}")
    );

    // Flags constant.
    let re = Regex::new_with_flags(r"hello", flags::IGNORECASE | flags::MULTILINE).unwrap();
    println!("flags: {:x}", re.flags().bits());
}

pub fn capture_count(&self) -> usize

The number of capturing groups.

pub fn group_names(&self) -> &HashMap<String, usize>

A map from group name to group index.

pub fn group_index(&self, name: &str) -> Option<usize>

Look up a group index by name.

pub fn dump(&self) -> String

Pretty-print the parsed AST (debug aid).

pub fn is_match(&self, haystack: &str) -> bool

Returns true if the pattern matches anywhere in haystack.

Cheaper than find when the match text is not needed — it short-circuits as soon as any match is found.

Examples

use eregex::Regex;
let re = Regex::new(r"\d+")?;
assert!(re.is_match("abc 123"));
assert!(!re.is_match("no digits here"));

pub fn find<'h>(&self, haystack: &'h str) -> Option<Match<'h>>

Search for the first match, anywhere in haystack. Returns None if there is no match. The returned Match carries the whole-match span and all capture groups.

For end-anchored / partial matching use find_partial.

Examples

use eregex::Regex;
let re = Regex::new(r"([a-z]+)(\d+)")?;
let m = re.find("x abc42 y").unwrap();
assert_eq!(m.as_str(), "abc42");
assert_eq!(m.start(), 2);
assert_eq!(m.group(2), Some("42"));

Examples found in repository

examples/demo.rs (line 7)

fn main() {
    let re = Regex::new(r"(?P<word>\w+)\s+(?P<num>\d+)").unwrap();
    let m = re.find("hello 42 world").unwrap();
    println!("match: {:?}", m.as_str());
    println!("word = {:?}", m.name("word"));
    println!("num  = {:?}", m.name("num"));

    // Repeated captures — a signature mrab-regex feature.
    let re = Regex::new(r"(\w)+").unwrap();
    let m = re.find("abc").unwrap();
    println!("captures of group 1: {:?}", m.captures(1));

    // Lookbehind (variable length) + case-insensitive.
    let re = Regex::new(r"(?i)(?<=foo)bar").unwrap();
    println!("lookbehind: {:?}", re.find("FOObar"));

    // Atomic group prevents catastrophic backtracking.
    let re = Regex::new(r"a(?>b*)b").unwrap();
    println!("atomic find: {:?}", re.find("abbbbc"));

    // Replace with named groups.
    let re = Regex::new(r"(?P<first>\w+),(?P<second>\w+)").unwrap();
    println!(
        "replace: {}",
        re.replace_all("a,b x,y", "${second} ${first}")
    );

    // Flags constant.
    let re = Regex::new_with_flags(r"hello", flags::IGNORECASE | flags::MULTILINE).unwrap();
    println!("flags: {:x}", re.flags().bits());
}

examples/gap_match.rs (line 128)

fn report(name: &str, hay: &str, max_gap: usize) {
    println!("\n=== {name} ===");
    println!("haystack: {hay:?}");

    // (1) Show what the bare engine does — both strict and end-anchored partial.
    let full = Regex::new(FULL).unwrap();
    println!(
        "  find         : {:?}",
        full.find(hay).map(|m| m.as_str().to_string())
    );
    println!(
        "  find_partial : {:?}",
        match full.find_partial(hay) {
            None => "None".to_string(),
            Some(p) => format!("{:?} matched={:?}", p.status, p.matched),
        }
    );

    // (2) Gap-tolerant shift-and-resume search.
    match gap_find(hay, &stm32_segments(), max_gap) {
        Some(gm) => {
            println!("  gap_find     : OK");
            println!("    reconstructed = {:?}", gm.reconstructed);
            for (label, s, e) in &gm.segments {
                println!("    segment {label:<8} = [{s}..{e}] {:?}", &hay[*s..*e]);
            }
            for (s, e) in &gm.skipped {
                println!("    skipped        = [{s}..{e}] {:?}", &hay[*s..*e]);
            }

            // (3) Re-validate the reconstruction with the FULL pattern and
            //     report clean groups. This is also where `find_partial`
            //     earns its keep: it confirms Full vs Partial.
            let p = full
                .find_partial(&gm.reconstructed)
                .expect("reconstruction must re-match the full pattern");
            assert_eq!(p.status, MatchStatus::Full, "reconstruction must be Full");
            println!(
                "    groups = [STM32={:?}, F407={:?}, VGT6={:?}]",
                p.group(1),
                p.group(2),
                p.group(3),
            );

            // The caller asked specifically about #2: group 2 (`F407`) is
            // assembled from TWO non-contiguous haystack ranges — the `F` at
            // the tail of segment 1 and the `407` at the head of segment 2.
            if name.contains("#2") {
                let (_, _, seg1_end) = gm.segments[0];
                let (_, seg2_start, _) = gm.segments[1];
                println!(
                    "    group F407 split = [{}..{}] + [{}..{}]  (\"F\" + \"407\")",
                    seg1_end - 1,
                    seg1_end,
                    seg2_start,
                    seg2_start + 3
                );
            }
        }
        None => println!("  gap_find     : None (NoMatch)"),
    }
}

pub fn find_at<'h>(&self, haystack: &'h str, start: usize) -> Option<Match<'h>>

Search for the first match at or after byte offset start.

start is clamped to haystack.len(); it counts bytes, not chars, but may fall in the middle of a UTF-8 sequence only if it lies beyond the haystack end. Useful for resuming a scan after a previous match.

Examples

use eregex::Regex;
let re = Regex::new(r"\d+")?;
let hay = "a1 b2 c3";
let first = re.find(hay).unwrap();
let next = re.find_at(hay, first.end()).unwrap();
assert_eq!(next.as_str(), "2");

Examples found in repository

examples/gap_match.rs (line 77)

fn gap_find(haystack: &str, segments: &[Segment], max_gap: usize) -> Option<GapMatch> {
    let mut reconstructed = String::new();
    let mut hits = Vec::with_capacity(segments.len());
    let mut skipped = Vec::new();
    let mut cursor = 0usize; // byte offset to search from

    for (i, seg) in segments.iter().enumerate() {
        // Shift-and-resume: find this segment at or after the cursor.
        let m = seg.re.find_at(haystack, cursor)?;
        let (s, e) = (m.start(), m.end());
        if i > 0 {
            let gap = s - cursor;
            if gap > max_gap {
                return None; // noise too long → NoMatch (#9)
            }
            if gap > 0 {
                skipped.push((cursor, s));
            }
        }
        hits.push((seg.label, s, e));
        reconstructed.push_str(m.as_str());
        cursor = e;
    }

    Some(GapMatch {
        reconstructed,
        segments: hits,
        skipped,
    })
}

pub fn captures<'h>(&self, haystack: &'h str) -> Option<Match<'h>>

Like find — included for symmetry with captures_iter.

pub fn match_at_start<'h>(&self, haystack: &'h str) -> Option<Match<'h>>

Require a match anchored at the start of the haystack (like Python’s re.match). The match need not reach the end.

Examples

use eregex::Regex;
let re = Regex::new(r"\d+")?;
assert_eq!(re.match_at_start("123abc").unwrap().as_str(), "123");
assert!(re.match_at_start("abc123").is_none());

pub fn fullmatch<'h>(&self, haystack: &'h str) -> Option<Match<'h>>

Require a match that covers the entire haystack (Python’s re.fullmatch).

Examples

use eregex::Regex;
let re = Regex::new(r"\d{3}")?;
assert!(re.fullmatch("123").is_some());
assert!(re.fullmatch("1234").is_none());

pub fn find_iter<'r, 'h>(&'r self, haystack: &'h str) -> FindIter<'r, 'h>

Iterate over non-overlapping matches.

Zero-width matches are yielded once per position and do not loop infinitely: after one, the iterator advances past the next character.

Examples

use eregex::Regex;
let re = Regex::new(r"\d+")?;
let ms: Vec<_> = re.find_iter("a1 bb 22").map(|m| m.as_str().to_string()).collect();
assert_eq!(ms, vec!["1", "22"]);

pub fn captures_iter<'r, 'h>(&'r self, haystack: &'h str) -> FindIter<'r, 'h>

Iterate over non-overlapping matches (alias of find_iter).

pub fn find_partial<'h>(&self, haystack: &'h str) -> Option<PartialMatch<'h>>

Partial / end-anchored match.

Unlike find, the match must consume the haystack all the way to its end. The result is:

• None — the input cannot be a prefix of any match (a hard mismatch occurred before end-of-input), or nothing matched at all.
• Some(Full) — the pattern matched and consumed the entire haystack.
• Some(Partial) — the pattern consumed the entire haystack but was still asking for more input; in other words, the haystack is a prefix of some full match.

Group state within a PartialMatch distinguishes groups that completed (GroupMatch::Matched) from the group that was entered but not completed (GroupMatch::Partial).

Examples

use eregex::{MatchStatus, Regex};
let re = Regex::new(r"token=([a-z]+)([0-9]+)")?;

// Incomplete input — more could turn it into a full match.
let p = re.find_partial("x token=abc").unwrap();
assert_eq!(p.status, MatchStatus::Partial);
assert_eq!(p.group(1), Some("abc")); // fully matched
assert_eq!(p.group(2), Some(""));    // entered but empty

// A wrong character rules out any continuation -> no match at all.
assert!(re.find_partial("x token=abc!").is_none());

Examples found in repository

examples/gap_match.rs (line 132)

fn report(name: &str, hay: &str, max_gap: usize) {
    println!("\n=== {name} ===");
    println!("haystack: {hay:?}");

    // (1) Show what the bare engine does — both strict and end-anchored partial.
    let full = Regex::new(FULL).unwrap();
    println!(
        "  find         : {:?}",
        full.find(hay).map(|m| m.as_str().to_string())
    );
    println!(
        "  find_partial : {:?}",
        match full.find_partial(hay) {
            None => "None".to_string(),
            Some(p) => format!("{:?} matched={:?}", p.status, p.matched),
        }
    );

    // (2) Gap-tolerant shift-and-resume search.
    match gap_find(hay, &stm32_segments(), max_gap) {
        Some(gm) => {
            println!("  gap_find     : OK");
            println!("    reconstructed = {:?}", gm.reconstructed);
            for (label, s, e) in &gm.segments {
                println!("    segment {label:<8} = [{s}..{e}] {:?}", &hay[*s..*e]);
            }
            for (s, e) in &gm.skipped {
                println!("    skipped        = [{s}..{e}] {:?}", &hay[*s..*e]);
            }

            // (3) Re-validate the reconstruction with the FULL pattern and
            //     report clean groups. This is also where `find_partial`
            //     earns its keep: it confirms Full vs Partial.
            let p = full
                .find_partial(&gm.reconstructed)
                .expect("reconstruction must re-match the full pattern");
            assert_eq!(p.status, MatchStatus::Full, "reconstruction must be Full");
            println!(
                "    groups = [STM32={:?}, F407={:?}, VGT6={:?}]",
                p.group(1),
                p.group(2),
                p.group(3),
            );

            // The caller asked specifically about #2: group 2 (`F407`) is
            // assembled from TWO non-contiguous haystack ranges — the `F` at
            // the tail of segment 1 and the `407` at the head of segment 2.
            if name.contains("#2") {
                let (_, _, seg1_end) = gm.segments[0];
                let (_, seg2_start, _) = gm.segments[1];
                println!(
                    "    group F407 split = [{}..{}] + [{}..{}]  (\"F\" + \"407\")",
                    seg1_end - 1,
                    seg1_end,
                    seg2_start,
                    seg2_start + 3
                );
            }
        }
        None => println!("  gap_find     : None (NoMatch)"),
    }
}

fn main() {
    // #2 / #10 — the main case: real noise between `F` and `407`.
    // Gap = the " dutyu7 8 " run (≤ 16 bytes), so it is accepted.
    report(
        "#2 split by noise (max_gap=16)",
        "Microcontroller STM32F dutyu7 8 407VGT6   ",
        16,
    );

    // #9 — same shape, but max_gap=8 rejects the run.
    report(
        "#9 gap too long (max_gap=8)",
        "Microcontroller STM32F very very very long unrelated text 407VGT6",
        8,
    );

    // #7 — a wrong char *inside* the digits segment (`X` where a digit is
    // expected). No `[0-9]{3}` run exists, so the segment search fails.
    report(
        "#7 wrong char inside series",
        "Microcontroller STM32FX07VGT6",
        16,
    );

    // #8 — wrong family (`STM8` instead of `STM32`): the first segment is
    // never found.
    report("#8 wrong family", "Microcontroller STM8F407VGT6", 16);

    // #1 — the contiguous happy path: no gap, reconstruction == input tail.
    report(
        "#1 contiguous full match",
        "Microcontroller STM32F407VGT6",
        16,
    );

    println!("\n--- end-of-input partials (find_partial alone, no gap mode) ---");
    let full = Regex::new(FULL).unwrap();
    for hay in [
        "Microcontroller STM32F",
        "Microcontroller STM32F40",
        "Microcontroller STM32F407VG",
    ] {
        let p = full.find_partial(hay).unwrap();
        println!(
            "  {:<32} -> {:?} matched={:?} g1={:?} g2={:?} g3={:?}",
            hay,
            p.status,
            p.matched,
            p.group(1),
            p.group(2),
            p.group(3)
        );
    }

    println!("\nAll reconstruction checks passed.");
}

pub fn replace(&self, haystack: &str, repl: &str) -> String

Replace the first match with the expansion of repl.

repl supports $1/${name}/$&/$$ templates (see the module docs for the full syntax). If nothing matches, haystack is returned unchanged.

Examples

use eregex::Regex;
let re = Regex::new(r"(\w+) (\w+)")?;
assert_eq!(re.replace("hello world", "$2 $1"), "world hello");

pub fn replace_all(&self, haystack: &str, repl: &str) -> String

Replace every non-overlapping match with the expansion of repl.

See replace for the template syntax.

Examples

use eregex::Regex;
let re = Regex::new(r"(?P<a>\d)(?P<b>\d)")?;
assert_eq!(re.replace_all("12 34", "${b}${a}"), "21 43");

Examples found in repository

examples/demo.rs (line 29)

fn main() {
    let re = Regex::new(r"(?P<word>\w+)\s+(?P<num>\d+)").unwrap();
    let m = re.find("hello 42 world").unwrap();
    println!("match: {:?}", m.as_str());
    println!("word = {:?}", m.name("word"));
    println!("num  = {:?}", m.name("num"));

    // Repeated captures — a signature mrab-regex feature.
    let re = Regex::new(r"(\w)+").unwrap();
    let m = re.find("abc").unwrap();
    println!("captures of group 1: {:?}", m.captures(1));

    // Lookbehind (variable length) + case-insensitive.
    let re = Regex::new(r"(?i)(?<=foo)bar").unwrap();
    println!("lookbehind: {:?}", re.find("FOObar"));

    // Atomic group prevents catastrophic backtracking.
    let re = Regex::new(r"a(?>b*)b").unwrap();
    println!("atomic find: {:?}", re.find("abbbbc"));

    // Replace with named groups.
    let re = Regex::new(r"(?P<first>\w+),(?P<second>\w+)").unwrap();
    println!(
        "replace: {}",
        re.replace_all("a,b x,y", "${second} ${first}")
    );

    // Flags constant.
    let re = Regex::new_with_flags(r"hello", flags::IGNORECASE | flags::MULTILINE).unwrap();
    println!("flags: {:x}", re.flags().bits());
}

pub fn split(&self, haystack: &str) -> Vec<String>

Split haystack by this pattern, including capturing-group text between parts (matching Python’s re.split semantics).

Examples

use eregex::Regex;
let re = Regex::new(r"\s+")?;
assert_eq!(re.split("a  b c"), vec!["a", "b", "c"]);

pub fn split_iter<'r, 'h>(&'r self, haystack: &'h str) -> SplitIter<'r, 'h>

An iterator yielding the pieces produced by split.

Trait Implementations

impl Debug for Regex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.