Struct parser_compose::Input

pub struct Input<T> { /* private fields */ }

Input to parsers should either be a &str or a slice (i.e. &[T])

If you have either of those you can convert it into an Input by using .into() or Into::from()

Input implements Deref<Target = T>, and so inherits all of Ts methods.

Input implements PartialEq<Rhs=T>, so you can compare an instance of Input<T> with a T

Implementations

impl<T> Input<T>where T: Clone,

pub fn pop(&self, count: usize) -> Input<T>

Returns a new instance of Input with count elements removed from the start

impl<T> Input<T>

pub fn get_position(&self) -> usize

Returns the current position

Trait Implementations

impl<T: Clone> Clone for Input<T>

fn clone(&self) -> Input<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Input<T>

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

Formats the value using the given formatter.

impl<T> Deref for Input<T>where T: Deref, <T as Deref>::Target: Index<RangeFrom<usize>>,

type Target = <<T as Deref>::Target as Index<RangeFrom<usize>>>::Output

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'i, T> From<&'i [T]> for Input<&'i [T]>

fn from(value: &'i [T]) -> Self

Converts to this type from the input type.

impl<'i> From<&'i str> for Input<&'i str>

fn from(value: &'i str) -> Self

Converts to this type from the input type.

impl<T> PartialEq<&[T]> for Input<&[T]>where [T]: Eq,

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&str> for Input<&str>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.