Struct rec::Ch

pub struct Ch { /* fields omitted */ }

Represents a match of one character.

A Ch is composed of Strings (AKA parts) combined with an [Operation].

Methods

impl Ch

pub fn either(chars: &str) -> Self

Creates a Ch that matches with any of the given characters.

Examples

use rec::{Ch, prelude::*};

assert_eq!(Ch::either("abc"), Rec::from("[abc]"));

- is not interpreted as range

use rec::{Ch, prelude::*};

assert_eq!(Ch::either("a-c"), Rec::from(r"[a\-c]"));

pub fn range(start: char, end: char) -> Self

Creates a Ch that is a range between and including start and end.

use rec::{Ch, prelude::*};

assert_eq!(Ch::range('a', 'c'), Rec::from("[a-c]"));

Trait Implementations

impl Atom for Ch

fn to_part(&self) -> String

Converts self to a String that contains everything inside the [] brackets.

impl Element for Ch

fn to_regex(&self) -> String

Converts self to a regular expression compatible with regex.

fn is_atom(&self) -> bool

Returns if self is an Atom.

fn alternate(&self, other: &dyn Element) -> Rec

Creates a Rec consisting of the alternation of self and other.

fn concatenate(&self, other: &dyn Element) -> Rec

Creates a Rec consisting of the concatenation of self and other.

fn is_equal(&self, other: &dyn Element) -> bool

Returns if the regular expression of self is equal to that of other.

fn isolate(&self) -> String

Returns the regular expression of self such that it can be concatenated.

fn group(&self) -> String

Returns the regular expression of self as a single Atom.

impl<T: Element> PartialEq<T> for Ch

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Clone for Ch

fn clone(&self) -> Ch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Rhs: Element> Add<Rhs> for Ch

type Output = Rec

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<'_> Add<Ch> for &'_ str

type Output = Rec

The resulting type after applying the + operator.

fn add(self, rhs: Ch) -> Self::Output

use rec::{Ch, prelude::*};

assert_eq!("25" + Ch::range('0', '5'), Rec::from("25[0-5]"));

impl BitOr<Ch> for Ch

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

use rec::{Ch, prelude::*};

assert_eq!(Ch::either("ab") | Ch::either("cd"), Rec::from("[abcd]"));

use rec::{Ch, prelude::*};

assert_eq!(Ch::range('a', 'c') | Ch::either("xyz"), Rec::from("[a-cxyz]"));

impl BitOr<char> for Ch

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: char) -> Self::Output

use rec::{Ch, prelude::*};

assert_eq!(Ch::either("ab") | 'c', Rec::from("[abc]"));

impl BitOr<Rec> for Ch

type Output = Rec

The resulting type after applying the | operator.

fn bitor(self, rhs: Rec) -> Self::Output

Performs the | operation.

impl<'_> BitOr<&'_ str> for Ch

type Output = Rec

The resulting type after applying the | operator.

fn bitor(self, rhs: &str) -> Self::Output

Performs the | operation.

impl BitOr<Ch> for Rec

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Ch) -> Self::Output

Performs the | operation.

impl Debug for Ch

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

Formats the value using the given formatter.