kale -


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
103
104
105
106
107

use super::types::*;

macro_rules! t {
    (ident) => {
        select! { Token::Ident(ident) => ident }.labelled("ident")
    };
    (if) => {
        just(Token::If)
    };
    (else) => {
        just(Token::Else)
    };
    (=) => {
        just(Token::Equal)
    };
    (λ) => {
        just(Token::Lambda)
    };
    (<-) => {
        just(Token::Place)
    };
    (,) => {
        just(Token::Comma)
    };
    (:) => {
        just(Token::Colon)
    };
    (->) => {
        just(Token::Place)
    };
    (()) => {
        just(Token::Call)
    };
    ('(') => {
        just(Token::OpeningBracket('('))
    };
    (')') => {
        just(Token::ClosingBracket(')'))
    };
    ('[') => {
        just(Token::OpeningBracket('['))
    };
    (']') => {
        just(Token::ClosingBracket(']'))
    };
    ('{') => {
        just(Token::OpeningBracket('{'))
    };
    ('}') => {
        just(Token::ClosingBracket('}'))
    };
}
macro_rules! parser {
    ($t:ty) => {
        impl Parser<'s, crate::parser::types::Input<'s>, $t, extra::Err<Error<'s>>> + Clone + 's
    }
}

pub trait TakeSpan {
    fn tspn<T>(&mut self, x: T) -> Spanned<T>;
}

impl<'a, 'b> TakeSpan for MapExtra<'a, 'b, Input<'a>, chumsky::extra::Err<Error<'a>>> {
    fn tspn<T>(&mut self, x: T) -> Spanned<T> {
        Spanned::from((x, self.span()))
    }
}
macro_rules! spanned {
    () => {
        |a, extra| Spanned::from((a, extra.span()))
    };
}

use chumsky::input::MapExtra;
pub(crate) use parser;
pub(crate) use spanned;
pub(crate) use t;

pub trait Unit<T> {
    fn empty(&self) -> T;
}

impl<T> Unit<Option<()>> for Option<T> {
    fn empty(&self) -> Option<()> {
        self.as_ref().map(|_| ())
    }
}

pub trait Spanner {
    fn spun(self, s: Span) -> Spanned<Self>
    where
        Self: Sized,
    {
        (self, s).into()
    }
}
impl<T> Spanner for T {}

pub trait MapLeft<T, V> {
    fn ml<U>(self, f: impl Fn(T) -> U) -> (U, V);
}

impl<T, V> MapLeft<T, V> for (T, V) {
    fn ml<U>(self, f: impl Fn(T) -> U) -> (U, V) {
        (f(self.0), self.1)
    }
}