Struct Span

pub struct Span<I, P>(pub I, pub P);

This input type keeps track of the position within the input it wraps.

Tuple Fields

0: I

1: P

Implementations

impl<I, P: Position<I>> Span<I, P>

pub fn new(input: I) -> Self

Examples found in repository

examples/lisp.rs (line 122)

pub fn parse(i: &str) -> Result<Value, ParserError> {
    (cf::f(parse_partial) >> -sp::ws(..)).parse(ParserInput::new(i))
}

Trait Implementations

impl<I, P: Position<I>, E: AltError<I>> AltError<Span<I, P>> for PositionedError<P, E>

fn alt(self, other: Self, at: Span<I, P>) -> Self

impl<I: Clone, P: Clone> Clone for Span<I, P>

fn clone(&self) -> Span<I, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: SplitFirst + Clone, P: Position<I>, E> ConsumeError<Span<I, P>> for PositionedError<P, E>

where E: ConsumeError<I>,

fn eof(at: Span<I, P>) -> Self

fn condition_failed(element: I::Element, at: Span<I, P>) -> Self

impl<I: Debug, P: Debug> Debug for Span<I, P>

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

Formats the value using the given formatter.

impl<I, P: Position<I>, E: EofError<I>> EofError<Span<I, P>> for PositionedError<P, E>

fn no_eof(at: Span<I, P>) -> Self

impl<I: HasEof, P> HasEof for Span<I, P>

fn at_eof(&self) -> bool

impl<I: Hash, P: Hash> Hash for Span<I, P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, P: Position<I>, E: NotError<O, I>, O> NotError<O, Span<I, P>> for PositionedError<P, E>

fn not(out: O, at: Span<I, P>) -> Self

impl<I: PartialEq, P: PartialEq> PartialEq for Span<I, P>

fn eq(&self, other: &Span<I, P>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<I: Recordable, P> Recordable for Span<I, P>

type Output = <I as Recordable>::Output

fn record(self, later: Self) -> Self::Output

impl<I: Clone + SplitFirst, P: Position<I>> SplitFirst for Span<I, P>

type Element = <I as SplitFirst>::Element

fn split_first(self) -> Option<(Self::Element, Self)>

impl<'a, I, P: Position<I>, E, T: ?Sized> TagError<'a, T, Span<I, P>> for PositionedError<P, E>

where E: TagError<'a, T, I>,

fn tag(tag: &'a T, at: Span<I, P>) -> Self

impl<I: Copy, P: Copy> Copy for Span<I, P>

impl<I: Eq, P: Eq> Eq for Span<I, P>

impl<I, P> StructuralPartialEq for Span<I, P>