neure 0.10.1

A fast little combinational parsing library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use core::marker::PhantomData;

use crate::ctor::Handler;
use crate::ctx::Context;
use crate::err::Error;
use crate::span::Span;

#[derive(Debug)]
pub struct Extract<T> {
    marker: PhantomData<T>,
}

impl<T> Default for Extract<T> {
    fn default() -> Self {
        Self {
            marker: Default::default(),
        }
    }
}

impl<T> Clone for Extract<T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T> Copy for Extract<T> {}

impl<T> Extract<T> {
    pub const fn new() -> Self {
        Self {
            marker: PhantomData,
        }
    }
}

pub const fn extract<T>() -> Extract<T> {
    Extract::new()
}

impl<'a, C: Context<'a, Orig<'a> = &'a str>> Handler<C> for Extract<&'a str> {
    type Out = &'a str;

    type Error = Error;

    fn invoke(&mut self, ctx: &C, span: &Span) -> Result<Self::Out, Self::Error> {
        ctx.orig_sub(span.beg(), span.len())
    }
}

impl<'a, C: Context<'a, Orig<'a> = &'a [u8]>> Handler<C> for Extract<&'a [u8]> {
    type Out = &'a [u8];

    type Error = Error;

    fn invoke(&mut self, ctx: &C, span: &Span) -> Result<Self::Out, Self::Error> {
        ctx.orig_sub(span.beg(), span.len())
    }
}

#[cfg(feature = "alloc")]
impl<'a, C: Context<'a, Orig<'a> = &'a str>> Handler<C> for Extract<crate::alloc::String> {
    type Out = crate::alloc::String;

    type Error = Error;

    fn invoke(&mut self, ctx: &C, span: &Span) -> Result<Self::Out, Self::Error> {
        Ok(crate::alloc::String::from(
            ctx.orig_sub(span.beg(), span.len())?,
        ))
    }
}

impl<'a, C: Context<'a>> Handler<C> for Extract<Span> {
    type Out = Span;

    type Error = Error;

    fn invoke(&mut self, _: &C, span: &Span) -> Result<Self::Out, Self::Error> {
        Ok(*span)
    }
}

impl<'a, C: Context<'a>> Handler<C> for Extract<()> {
    type Out = ();

    type Error = Error;

    fn invoke(&mut self, _: &C, _: &Span) -> Result<Self::Out, Self::Error> {
        Ok(())
    }
}