tokit 0.0.0

Blazing fast parser combinators: parse-while-lexing (zero-copy), deterministic LALR-style parsing, no backtracking. Flexible emitters for fail-fast runtime or greedy compiler diagnostics
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;

/// An iterator over the tokens produced by a [`Input`].
#[derive(derive_more::From, derive_more::Into)]
pub struct IntoIter<'a, T: Token<'a>, L: Lexer<'a, T>, C> {
  stream: Input<'a, T, L, C>,
}

impl<'a, T, L, C> IntoIter<'a, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
{
  pub(super) const fn new(stream: Input<'a, T, L, C>) -> Self {
    Self { stream }
  }
}

impl<'a, T: Token<'a>, L: Lexer<'a, T>, C> Clone for IntoIter<'a, T, L, C>
where
  L::State: Clone,
  C: Clone,
{
  #[cfg_attr(not(tarpaulin), inline(always))]
  fn clone(&self) -> Self {
    Self {
      stream: self.stream.clone(),
    }
  }
}

impl<'a, T, L, C> core::fmt::Debug for IntoIter<'a, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
  L::Source: core::fmt::Debug,
  L::State: core::fmt::Debug,
  C: core::fmt::Debug,
{
  #[cfg_attr(not(tarpaulin), inline(always))]
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    self.stream.fmt(f)
  }
}

impl<'a, T, L, C> IntoIterator for Input<'a, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
  L::State: Clone,
  C: Cache<'a, T, L>,
{
  type Item = Spanned<Lexed<'a, T>>;
  type IntoIter = IntoIter<'a, T, L, C>;

  #[cfg_attr(not(tarpaulin), inline(always))]
  fn into_iter(self) -> Self::IntoIter {
    self.into_iter()
  }
}

impl<'a, T, L, C> Iterator for IntoIter<'a, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
  L::State: Clone,
  C: Cache<'a, T, L>,
{
  type Item = Spanned<Lexed<'a, T>>;

  #[cfg_attr(not(tarpaulin), inline(always))]
  fn next(&mut self) -> Option<Self::Item> {
    Input::next(&mut self.stream)
  }
}

/// An iterator over the tokens produced by a [`Input`].
#[derive(derive_more::From, derive_more::Into)]
pub struct Iter<'a, 'b, T: Token<'a>, L: Lexer<'a, T>, C> {
  stream: &'b mut Input<'a, T, L, C>,
}

impl<'a, 'b, T, L, C> Iter<'a, 'b, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
{
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub(super) const fn new(stream: &'b mut Input<'a, T, L, C>) -> Self {
    Self { stream }
  }
}

impl<'a, 'b, T, L, C> IntoIterator for &'b mut Input<'a, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
  L::State: Clone,
  C: Cache<'a, T, L>,
{
  type Item = Spanned<Lexed<'a, T>>;
  type IntoIter = Iter<'a, 'b, T, L, C>;

  #[cfg_attr(not(tarpaulin), inline(always))]
  fn into_iter(self) -> Self::IntoIter {
    self.iter()
  }
}

impl<'a, T, L, C> Iterator for Iter<'a, '_, T, L, C>
where
  T: Token<'a>,
  L: Lexer<'a, T>,
  L::State: Clone,
  C: Cache<'a, T, L>,
{
  type Item = Spanned<Lexed<'a, T>>;

  #[cfg_attr(not(tarpaulin), inline(always))]
  fn next(&mut self) -> Option<Self::Item> {
    Input::next(self.stream)
  }
}