munyo 0.8.0

A data language which aims to be the most efficient way to handwrite data.
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
93
94
95
96
97
98
99
100
101
102

use std::fmt::Display;

use anyhow::{anyhow, Error};
use pest::error::{Error as PestError, InputLocation};
use pest::RuleType;

use crate::lang::munyo_parser::Pair;

pub(crate) struct ParseFail {
    pub(crate) start_index: usize,
    pub(crate) message: anyhow::Error,
}

impl ParseFail {
    pub(crate) fn new(start_index: usize, message: anyhow::Error) -> Self {
        Self {
            start_index,
            message,
        }
    }

    pub(crate) fn msg(start_index: usize, message: String) -> Self {
        Self {
            start_index,
            message: anyhow!(message),
        }
    }

    pub(crate) fn from_pest_err<R: RuleType>(e: PestError<R>) -> Self {
        let start_index = match e.location {
            InputLocation::Pos(start) => start,
            InputLocation::Span((start, _end)) => start,
        };

        Self {
            start_index,
            message: anyhow!("{e}"),
        }
    }
}

pub(crate) fn parse_fail(pair: &Pair, s: &str) -> ParseFail {
    ParseFail::msg(pair.as_span().start(), s.to_string())
}

pub(crate) trait ParseFailHelper<T> {
    fn op(self, pair: &Pair) -> Result<T, ParseFail>;
    fn os(self, index: usize) -> Result<T, ParseFail>;
}

pub(crate) trait ParseFailHelper2<T> {
    fn oe(self, index: usize) -> Result<T, ParseFail>;
}

impl<T> ParseFailHelper2<T> for Result<T, Error> {
    fn oe(self, index: usize) -> Result<T, ParseFail> {
        match self {
            Ok(t) => Ok(t),
            Err(e) => Err(ParseFail::new(index, e)),
        }
    }
}

impl<T> ParseFailHelper<T> for Result<T, String> {
    fn op(self, pair: &Pair) -> Result<T, ParseFail> {
        match self {
            Ok(r) => Ok(r),
            Err(s) => Err(parse_fail(pair, &s)),
        }
    }

    fn os(self, index: usize) -> Result<T, ParseFail> {
        match self {
            Ok(r) => Ok(r),
            Err(s) => Err(ParseFail::msg(index, s)),
        }
    }
}

pub(crate) trait PairHelper {
    fn start_index(&self) -> usize;
}

impl<'a> PairHelper for Pair<'a> {
    fn start_index(&self) -> usize {
        self.as_span().start()
    }
}

impl std::error::Error for ParseFail {}

impl std::fmt::Display for ParseFail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.message, f)
    }
}

impl std::fmt::Debug for ParseFail {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}\n{}", &self.message, self.message.backtrace())
    }
}