jay-toml-config 0.1.0

Internal dependency of the Jay compositor
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

use crate::{
    config::parser::{ParseResult, Parser},
    toml::{toml_span::Spanned, toml_value::Value},
};

impl Spanned<&Value> {
    pub fn parse<P: Parser>(&self, parser: &mut P) -> ParseResult<P> {
        self.value.parse(self.span, parser)
    }

    pub fn parse_map<P: Parser, E>(
        &self,
        parser: &mut P,
    ) -> Result<<P as Parser>::Value, Spanned<E>>
    where
        <P as Parser>::Error: Into<E>,
    {
        self.parse(parser).map_spanned_err(|e| e.into())
    }
}

impl Spanned<Value> {
    pub fn parse<P: Parser>(&self, parser: &mut P) -> ParseResult<P> {
        self.as_ref().parse(parser)
    }

    pub fn parse_map<P: Parser, E>(
        &self,
        parser: &mut P,
    ) -> Result<<P as Parser>::Value, Spanned<E>>
    where
        <P as Parser>::Error: Into<E>,
    {
        self.as_ref().parse_map(parser)
    }
}

pub trait SpannedErrorExt {
    type T;
    type E;

    fn map_spanned_err<U, F>(self, f: F) -> Result<Self::T, Spanned<U>>
    where
        F: FnOnce(Self::E) -> U;
}

impl<T, E> SpannedErrorExt for Result<T, Spanned<E>> {
    type T = T;
    type E = E;

    fn map_spanned_err<U, F>(self, f: F) -> Result<Self::T, Spanned<U>>
    where
        F: FnOnce(Self::E) -> U,
    {
        match self {
            Ok(v) => Ok(v),
            Err(e) => Err(Spanned {
                span: e.span,
                value: f(e.value),
            }),
        }
    }
}