klunk - smol lang


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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use super::types::*;

macro_rules! tok {
    (ident) => {
        select! { Token::Ident(ident) => ident }.labelled("ident")
    };
    (fnname) => {
        select! { Token::Ident(x) | Token::FnIdent(x) => x }.labelled("function name")
    };
    (let) => {
        just(Token::Let)
    };
    (looser_than) => {
        just(Token::LooserThan)
    };
    (tighter_than) => {
        just(Token::TighterThan)
    };
    (associativity) => {
        just(Token::Associativity)
    };
    (if) => {
        just(Token::If)
    };
    (alias) => {
        just(Token::Alias)
    };
    (like) => {
        just(Token::Like)
    };
    (infix) => {
        just(Token::Infix)
    };
    (prefix) => {
        just(Token::Prefix)
    };
    (postfix) => {
        just(Token::Postfix)
    };
    (else) => {
        just(Token::Else)
    };
    (=) => {
        just(Token::Equal)
    };
    (;) => {
        just(Token::Semicolon)
    };
    (,) => {
        just(Token::Comma)
    };
    (:) => {
        just(Token::Colon)
    };
    (->) => {
        just(Token::ThinArrow)
    };
    (()) => {
        just(Token::Unit)
    };
    (lparen) => {
        just(Token::OpeningBracket('('))
    };
    (rparen) => {
        just(Token::ClosingBracket(')'))
    };
    (lbrack) => {
        just(Token::OpeningBracket('['))
    };
    (rbrack) => {
        just(Token::ClosingBracket(']'))
    };
    (lbrace) => {
        just(Token::OpeningBracket('{'))
    };
    (rbrace) => {
        just(Token::ClosingBracket('}'))
    };
}
macro_rules! parser {
    ($t:ty) => {
        impl Parser<'s, SpannedInput<Token<'s>, SimpleSpan, Stream<Lexer<'s>>>, $t, extra::Err<Error<'s>>> + Clone
    }
}

macro_rules! spanned {
    () => {
        |a, extra| (a, extra.span())
    };
}

pub(crate) use parser;
pub(crate) use spanned;
pub(crate) use tok;

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)
    }
}
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)
    }
}