Trait neure::neu::Neu

pub trait Neu<T: ?Sized> {
    // Required method
    fn is_match(&self, other: &T) -> bool;
}

Required Methods

fn is_match(&self, other: &T) -> bool

Trait Implementations

impl<T> Neu<T> for Box<dyn Neu<T>>

fn is_match(&self, other: &T) -> bool

Implementations on Foreign Types

impl<'a, T: 'a + ?Sized + PartialOrd + MayDebug> Neu<T> for (Bound<&'a T>, Bound<&'a T>)

Match value in the range.

Example

    let hex = (Bound::Included(&'a'), Bound::Excluded(&'g'));
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<U, T> Neu<T> for Rc<U>where U: Neu<T>,

fn is_match(&self, other: &T) -> bool

impl<T> Neu<T> for Box<dyn Neu<T>>

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for Range<&T>

Match value in the range.

Example

    let hex = &'a' .. &'g';
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<U, T> Neu<T> for Cell<U>where U: Neu<T> + Copy,

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeToInclusive<&T>

Match value in the range.

Example

    let to = ..= &'f';
    let to = re!((to){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&to)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for (Bound<T>, Bound<T>)

Match value in the range.

Example

    let hex = (Bound::Included('a'), Bound::Excluded('g'));
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeFrom<T>

Match value in the range.

Example

    let from = 'a' ..;
    let from = re!((from){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&from)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeTo<T>

Match value in the range.

Example

    let to = .. 'g';
    let to = re!((to){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&to)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for Range<T>

Match value in the range.

Example

    let hex = 'a' .. 'g';
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<const N: usize, T: PartialEq + MayDebug> Neu<T> for [T; N]

Match any value in the array.

Example

  let arr = ['a', 'c', 'f', 'e'];
  let mut ctx1 = CharsCtx::new("aaffeeeaccc");
  let mut ctx2 = CharsCtx::new("acdde");

  assert_eq!(ctx1.try_mat(&arr.repeat_range(2..6)).unwrap(), Span::new(0, 5));
  assert_eq!(ctx2.try_mat(&arr.repeat_range(2..6)).unwrap(), Span::new(0, 2));

fn is_match(&self, other: &T) -> bool

impl<T: PartialEq + MayDebug> Neu<T> for Vec<T>

Match any value in the vector.

Example

    let hex = vec!['a', 'b', 'c', 'd', 'e', 'f'];
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    let mut ctx = CharsCtx::new("0xbbb");

    assert!(ctx.try_mat(&hex).is_err());

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeFrom<&T>

Match value in the range.

Example

    let from = &'a' ..;
    let from = re!((from){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&from)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<'a, T: PartialEq + MayDebug> Neu<T> for &'a [T]

Match any value in the array.

Example

  let arr = &[b'a', b'c', b'f', b'e'] as &[u8];
  let arr = Neu2Re::repeat_range(arr, 2..6);
  let mut ctx1 = BytesCtx::new(b"aaffeeeaccc");
  let mut ctx2 = BytesCtx::new(b"acdde");

  assert_eq!(ctx1.try_mat(&arr).unwrap(), Span::new(0, 5));
  assert_eq!(ctx2.try_mat(&arr).unwrap(), Span::new(0, 2));

fn is_match(&self, other: &T) -> bool

impl<T> Neu<T> for charwhere T: MayDebug, Self: PartialEq<T>,

fn is_match(&self, other: &T) -> bool

impl<U, T> Neu<T> for RefCell<U>where U: Neu<T>,

fn is_match(&self, other: &T) -> bool

impl<T> Neu<T> for Arc<dyn Neu<T>>

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeInclusive<&T>

Match value in the range.

Example

    let hex = &'a' ..= &'f';
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeInclusive<T>

Match value in the range.

Example

    let hex = 'a' ..= 'f';
    let hex = re!((hex){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&hex)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<U, T> Neu<T> for Arc<U>where U: Neu<T>,

fn is_match(&self, other: &T) -> bool

impl<U, T> Neu<T> for Mutex<U>where U: Neu<T> + Copy,

fn is_match(&self, other: &T) -> bool

impl<T: ?Sized + PartialOrd + MayDebug> Neu<T> for RangeFull

Match value in the range.

Example

    let full = ..;
    let full = re!((full){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&full)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeToInclusive<T>

Match value in the range.

Example

    let to = ..= 'f';
    let to = re!((to){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&to)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

impl<T> Neu<T> for u8where T: MayDebug, Self: PartialEq<T>,

fn is_match(&self, other: &T) -> bool

impl<T> Neu<T> for Rc<dyn Neu<T>>

fn is_match(&self, other: &T) -> bool

impl<T: PartialOrd + MayDebug> Neu<T> for RangeTo<&T>

Match value in the range.

Example

    let to = .. &'g';
    let to = re!((to){1,6});
    let mut ctx = CharsCtx::new("aabbccgg");

    assert_eq!(ctx.try_mat(&to)?, Span::new(0, 6));

    Ok(())

fn is_match(&self, other: &T) -> bool

Implementors

impl Neu<char> for Alphabetic

impl Neu<char> for Alphanumeric

impl Neu<char> for Ascii

impl Neu<char> for AsciiAlphabetic

impl Neu<char> for AsciiAlphanumeric

impl Neu<char> for AsciiControl

impl Neu<char> for AsciiDigit

impl Neu<char> for AsciiGraphic

impl Neu<char> for AsciiHexDigit

impl Neu<char> for AsciiLowercase

impl Neu<char> for AsciiPunctuation

impl Neu<char> for AsciiUppercase

impl Neu<char> for AsciiWhiteSpace

impl Neu<char> for Control

impl Neu<char> for Digit

impl Neu<char> for Lowercase

impl Neu<char> for Numeric

impl Neu<char> for Uppercase

impl Neu<char> for WhiteSpace

impl Neu<char> for Wild

impl Neu<u8> for Ascii

impl Neu<u8> for AsciiAlphabetic

impl Neu<u8> for AsciiAlphanumeric

impl Neu<u8> for AsciiControl

impl Neu<u8> for AsciiDigit

impl Neu<u8> for AsciiGraphic

impl Neu<u8> for AsciiHexDigit

impl Neu<u8> for AsciiLowercase

impl Neu<u8> for AsciiPunctuation

impl Neu<u8> for AsciiUppercase

impl Neu<u8> for AsciiWhiteSpace

impl<L, R, T> Neu<T> for And<L, R, T>where L: Neu<T>, R: Neu<T>,

impl<L, R, T> Neu<T> for Or<L, R, T>where L: Neu<T>, R: Neu<T>,

impl<T, F> Neu<T> for Fwhere T: MayDebug, F: Fn(&T) -> bool,

impl<T: MayDebug> Neu<T> for False<T>

impl<T: MayDebug> Neu<T> for True<T>

impl<T: PartialEq + MayDebug> Neu<T> for Equal<T>

impl<T: PartialOrd + MayDebug> Neu<T> for CRange<T>

impl<U, I, T> Neu<T> for MayUnit<U, I, T>where U: Neu<T>, I: Neu<T>, T: MayDebug,

impl<U, T> Neu<T> for Not<U, T>where U: Neu<T>,