wasm_reader_traits/
reader.rs

1use crate::{
2    iter::{IntoParserIter, ParserIter},
3    Parser,
4};
5use frunk_core::hlist::{HCons, HNil};
6use std::{io::Read, marker::PhantomData};
7
8pub struct Iter<F>(pub F);
9pub struct Simple<F>(pub F);
10
11pub trait ReaderRead {
12    type Out;
13    type Error;
14
15    fn read<R: Read>(self, reader: R) -> Result<Self::Out, Self::Error>;
16}
17
18pub struct Reader<P, S = (), F = HNil> {
19    parsers: P,
20    funcs: F,
21    state: S,
22}
23
24impl<P> Reader<P> {
25    #[inline]
26    pub fn new(parsers: P) -> Self {
27        Reader {
28            parsers: parsers,
29            funcs: HNil,
30            state: (),
31        }
32    }
33}
34
35impl<P, S> Reader<P, S> {
36    #[inline]
37    pub fn with_state<NS>(self, state: NS) -> Reader<P, NS> {
38        Reader {
39            parsers: self.parsers,
40            funcs: self.funcs,
41            state,
42        }
43    }
44}
45
46pub trait ReaderReadHelper {
47    type Out;
48    type Error;
49
50    fn exec<R: Read>(self, reader: R) -> Result<Self::Out, Self::Error>;
51}
52
53impl<S, P, F, Rest> ReaderReadHelper for (P, HCons<Simple<F>, Rest>, S)
54where
55    P: Parser,
56    (P::Next, Rest, S): ReaderReadHelper<Out = S, Error = P::Error>,
57    F: FnOnce(&mut S, P::Item) -> Result<(), P::Error>,
58{
59    type Out = S;
60    type Error = P::Error;
61
62    #[inline]
63    fn exec<R: Read>(self, mut reader: R) -> Result<S, Self::Error> {
64        let (
65            p,
66            HCons {
67                head: Simple(f),
68                tail,
69            },
70            mut state,
71        ) = self;
72        let (item, next) = p.next(&mut reader)?;
73        f(&mut state, item)?;
74        Ok((next, tail, state).exec(reader)?)
75    }
76}
77
78impl<S, P, F> ReaderReadHelper for (P, HCons<Simple<F>, HNil>, S)
79where
80    P: Parser<Next = ()>,
81    F: FnOnce(&mut S, P::Item) -> Result<(), P::Error>,
82{
83    type Out = S;
84    type Error = P::Error;
85
86    #[inline]
87    fn exec<R: Read>(self, mut reader: R) -> Result<S, Self::Error> {
88        let (
89            p,
90            HCons {
91                head: Simple(f),
92                tail: HNil,
93            },
94            mut state,
95        ) = self;
96        let (item, ()) = p.next(&mut reader)?;
97        f(&mut state, item)?;
98        Ok(state)
99    }
100}
101
102impl<S, I, P, F, Rest> ReaderReadHelper for (P, HCons<Iter<F>, Rest>, S)
103where
104    P: Parser<Item = Option<I>>,
105    I: Parser<Next = Option<I>>,
106    (P::Next, Rest, S): ReaderReadHelper<Out = S, Error = P::Error>,
107    F: FnOnce(&mut S, ParserIter<&mut dyn Read, Option<I>>) -> Result<(), P::Error>,
108{
109    type Out = S;
110    type Error = P::Error;
111
112    #[inline]
113    fn exec<R: Read>(self, mut reader: R) -> Result<S, Self::Error> {
114        let (
115            p,
116            HCons {
117                head: Iter(f),
118                tail,
119            },
120            mut state,
121        ) = self;
122        let (item, next) = p.next(&mut reader)?;
123        f(&mut state, item.parse_iter(&mut reader))?;
124        Ok((next, tail, state).exec(reader)?)
125    }
126}
127
128impl<PS, FS, S> ReaderRead for Reader<PS, S, FS>
129where
130    (PS, FS, S): ReaderReadHelper<Out = S>,
131{
132    type Out = S;
133    type Error = <(PS, FS, S) as ReaderReadHelper>::Error;
134
135    #[inline]
136    fn read<R: Read>(self, reader: R) -> Result<S, Self::Error> {
137        let Reader {
138            parsers,
139            funcs,
140            state,
141        } = self;
142
143        (parsers, funcs, state).exec(reader)
144    }
145}
146
147pub trait ReaderBuildHelper<S, F> {
148    type New;
149
150    fn then(self, func: F) -> Self::New;
151}
152
153impl<S, P, F, O> ReaderBuildHelper<S, Simple<F>> for (PhantomData<P>, HNil)
154where
155    P: Parser,
156    F: FnOnce(&mut S, P::Item) -> O,
157    O: Into<Result<(), P::Error>>,
158{
159    type New = HCons<Simple<F>, HNil>;
160
161    #[inline]
162    fn then(self, func: Simple<F>) -> Self::New {
163        HCons {
164            head: func,
165            tail: HNil,
166        }
167    }
168}
169
170impl<S, P, I, F, O> ReaderBuildHelper<S, Iter<F>> for (PhantomData<P>, HNil)
171where
172    P: Parser<Item = Option<I>>,
173    I: Parser<Next = Option<I>>,
174    F: FnOnce(&mut S, ParserIter<&mut dyn Read, Option<I>>) -> O,
175    O: Into<Result<(), P::Error>>,
176{
177    type New = HCons<Iter<F>, HNil>;
178
179    #[inline]
180    fn then(self, func: Iter<F>) -> Self::New {
181        HCons {
182            head: func,
183            tail: HNil,
184        }
185    }
186}
187
188impl<S, P, ExistingF, Rest, F> ReaderBuildHelper<S, F> for (PhantomData<P>, HCons<ExistingF, Rest>)
189where
190    P: Parser,
191    (PhantomData<P::Next>, Rest): ReaderBuildHelper<S, F>,
192{
193    type New = HCons<ExistingF, <(PhantomData<P::Next>, Rest) as ReaderBuildHelper<S, F>>::New>;
194
195    #[inline]
196    fn then(self, func: F) -> Self::New {
197        let (_, HCons { head, tail }) = self;
198        HCons {
199            head,
200            tail: (PhantomData, tail).then(func),
201        }
202    }
203}
204
205pub trait ReaderBuild<F> {
206    type New;
207
208    fn then(self, func: F) -> Self::New;
209}
210
211pub trait ReaderBuildIter<F> {
212    type New;
213
214    fn then_iter(self, func: F) -> Self::New;
215}
216
217impl<PS, FS, F, S> ReaderBuild<F> for Reader<PS, S, FS>
218where
219    (PhantomData<PS>, FS): ReaderBuildHelper<S, Simple<F>>,
220{
221    type New = Reader<PS, S, <(PhantomData<PS>, FS) as ReaderBuildHelper<S, Simple<F>>>::New>;
222
223    #[inline]
224    fn then(self, func: F) -> Self::New {
225        Reader {
226            parsers: self.parsers,
227            funcs: (PhantomData, self.funcs).then(Simple(func)),
228            state: self.state,
229        }
230    }
231}
232
233impl<PS, FS, F, S> ReaderBuildIter<F> for Reader<PS, S, FS>
234where
235    (PhantomData<PS>, FS): ReaderBuildHelper<S, Iter<F>>,
236{
237    type New = Reader<PS, S, <(PhantomData<PS>, FS) as ReaderBuildHelper<S, Iter<F>>>::New>;
238
239    #[inline]
240    fn then_iter(self, func: F) -> Self::New {
241        Reader {
242            parsers: self.parsers,
243            funcs: (PhantomData, self.funcs).then(Iter(func)),
244            state: self.state,
245        }
246    }
247}
wasm_reader_traits/reader.rs

wasm_reader_traits/
reader.rs
