join_impl 0.3.0

Implementation of the `join!` macro.
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

//!
//! `Unit` module describes one unit of expression parsing which contains currently parsed `T`
//! and optional next `N`
//!
//!
use std::fmt::Debug;
use syn::parse::{Parse, ParseStream};

///
/// Defines one unit of expression parsing.
///
#[derive(Debug, Clone)]
pub struct Unit<T: Clone + Debug, N: Clone + Debug> {
    ///
    /// Parsed value (for example `Expr` { Ok(1) }).
    ///
    pub parsed: T,
    ///
    /// Next `N` if provided.
    ///
    pub next: Option<N>,
}

///
/// Defines `Result` of one unit expression parsing.
///
pub type UnitResult<T, N> = syn::Result<Unit<T, N>>;

pub trait ParseUnit<N: Clone + Debug> {
    ///
    /// Parses input stream until next `N`.
    ///
    fn parse_unit<T: Parse + Clone + Debug>(
        &self,
        input: ParseStream,
        allow_empty_parsed: bool,
    ) -> UnitResult<T, N>;
}

///
/// Allows to map `Self` over some parsed.
///
pub trait MapParsed<T, R> {
    type Output: Clone + Debug;

    fn map_parsed<F>(self, f: F) -> Self::Output
    where
        F: FnOnce(T) -> R;
}

impl<T: Clone + Debug, R: Clone + Debug, N: Clone + Debug> MapParsed<T, R> for UnitResult<T, N> {
    type Output = UnitResult<R, N>;

    fn map_parsed<F>(self, f: F) -> Self::Output
    where
        F: FnOnce(T) -> R,
    {
        self.map(|Unit { parsed, next }| Unit {
            parsed: f(parsed),
            next,
        })
    }
}