Trait AnonRegex 

pub trait AnonRegex<I, const N: usize>: Regex<I, N>
where
    I: HaystackItem,
{
    // Provided methods
    fn is_match<'a, H>(&self, hay: impl IntoHaystack<'a, H>) -> bool
       where H: HaystackOf<'a, I> { ... }
    fn contains_match<'a, H>(&self, hay: impl IntoHaystack<'a, H>) -> bool
       where H: HaystackOf<'a, I> { ... }
    fn count_matches<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
        overlapping: bool,
    ) -> usize
       where H: HaystackOf<'a, I> { ... }
    fn range_of_match<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
    ) -> Option<Range<usize>>
       where H: HaystackOf<'a, I> { ... }
    fn range_of_all_matches<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
        overlapping: bool,
    ) -> RangeOfAllMatches<'a, I, H, Self::Pattern> 
       where H: HaystackOf<'a, I> { ... }
    fn slice_match<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
    ) -> Option<<H as HaystackIter<'a>>::Slice>
       where H: HaystackOf<'a, I> { ... }
    fn slice_all_matches<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
        overlapping: bool,
    ) -> SliceAllMatches<'a, I, H, Self::Pattern> 
       where H: HaystackOf<'a, I> { ... }
    fn do_capture<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
    ) -> Option<Self::Capture<'a, <H as HaystackIter<'a>>::Slice>>
       where H: HaystackOf<'a, I> { ... }
    fn find_capture<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
    ) -> Option<Self::Capture<'a, <H as HaystackIter<'a>>::Slice>>
       where H: HaystackOf<'a, I> { ... }
    fn find_all_captures<'a, H>(
        &self,
        hay: impl IntoHaystack<'a, H>,
        overlapping: bool,
    ) -> FindAllCaptures<'a, Self, I, H, N> 
       where H: HaystackOf<'a, I> { ... }
    fn replace<'a, M>(
        &self,
        hay_mut: &mut M,
        with: <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice,
    ) -> bool
       where M: OwnedHaystackable<I> { ... }
    fn replace_all<'a, M>(
        &self,
        hay_mut: &mut M,
        with: <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice,
    ) -> usize
       where M: OwnedHaystackable<I> { ... }
    fn replace_all_using<M>(
        &self,
        hay_mut: &mut M,
        using: impl FnMut() -> M,
    ) -> usize
       where M: OwnedHaystackable<I> { ... }
    fn replace_captured<M, F>(&self, hay_mut: &mut M, replacer: F) -> bool
       where M: OwnedHaystackable<I>,
             F: for<'a> FnOnce(Self::Capture<'a, <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice>) -> M { ... }
    fn replace_all_captured<M, F>(&self, hay_mut: &mut M, replacer: F) -> usize
       where M: OwnedHaystackable<I>,
             F: for<'a> FnMut(Self::Capture<'a, <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice>) -> M { ... }
}

A trait that is automatically implemented for ‘anonymous’ regular expression types. There is only one difference between this and Regex: all functions take self as the first parameter, removing the need to name the expression itself.

An AnonRegex can be created by invoking regex!() without a type identifier or visibility. The result is an instance of an unnamable type implementing AnonRegex.

Provided Methods

fn is_match<'a, H>(&self, hay: impl IntoHaystack<'a, H>) -> bool

where H: HaystackOf<'a, I>,

See Regex::is_match.

fn contains_match<'a, H>(&self, hay: impl IntoHaystack<'a, H>) -> bool

where H: HaystackOf<'a, I>,

See Regex::contains_match.

fn count_matches<'a, H>( &self, hay: impl IntoHaystack<'a, H>, overlapping: bool, ) -> usize

where H: HaystackOf<'a, I>,

See Regex::count_matches.

fn range_of_match<'a, H>( &self, hay: impl IntoHaystack<'a, H>, ) -> Option<Range<usize>>

where H: HaystackOf<'a, I>,

See Regex::range_of_match.

fn range_of_all_matches<'a, H>( &self, hay: impl IntoHaystack<'a, H>, overlapping: bool, ) -> RangeOfAllMatches<'a, I, H, Self::Pattern>

where H: HaystackOf<'a, I>,

See Regex::range_of_all_matches.

fn slice_match<'a, H>( &self, hay: impl IntoHaystack<'a, H>, ) -> Option<<H as HaystackIter<'a>>::Slice>

where H: HaystackOf<'a, I>,

See Regex::slice_match.

fn slice_all_matches<'a, H>( &self, hay: impl IntoHaystack<'a, H>, overlapping: bool, ) -> SliceAllMatches<'a, I, H, Self::Pattern>

where H: HaystackOf<'a, I>,

See Regex::slice_all_matches.

fn do_capture<'a, H>( &self, hay: impl IntoHaystack<'a, H>, ) -> Option<Self::Capture<'a, <H as HaystackIter<'a>>::Slice>>

where H: HaystackOf<'a, I>,

See Regex::do_capture.

fn find_capture<'a, H>( &self, hay: impl IntoHaystack<'a, H>, ) -> Option<Self::Capture<'a, <H as HaystackIter<'a>>::Slice>>

where H: HaystackOf<'a, I>,

See Regex::find_capture.

fn find_all_captures<'a, H>( &self, hay: impl IntoHaystack<'a, H>, overlapping: bool, ) -> FindAllCaptures<'a, Self, I, H, N>

where H: HaystackOf<'a, I>,

See Regex::find_all_captures.

fn replace<'a, M>( &self, hay_mut: &mut M, with: <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice, ) -> bool

where M: OwnedHaystackable<I>,

See Regex::replace.

fn replace_all<'a, M>( &self, hay_mut: &mut M, with: <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice, ) -> usize

where M: OwnedHaystackable<I>,

See Regex::replace_all.

fn replace_all_using<M>( &self, hay_mut: &mut M, using: impl FnMut() -> M, ) -> usize

where M: OwnedHaystackable<I>,

See Regex::replace_all_using.

fn replace_captured<M, F>(&self, hay_mut: &mut M, replacer: F) -> bool

where M: OwnedHaystackable<I>, F: for<'a> FnOnce(Self::Capture<'a, <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice>) -> M,

See Regex::replace_captured.

fn replace_all_captured<M, F>(&self, hay_mut: &mut M, replacer: F) -> usize

where M: OwnedHaystackable<I>, F: for<'a> FnMut(Self::Capture<'a, <<M as OwnedHaystackable<I>>::Hay<'a> as HaystackIter<'a>>::Slice>) -> M,

See Regex::replace_all_captured.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors