join_impl/chain/group/
action_group.rs

1//!
2//! Definition of `ActionGroup` with parser's mappings.
3//!
4
5use super::{ApplicationType, Combinator, ExprGroup, MoveType};
6use crate::{
7    chain::expr::{ActionExpr, ErrExpr, InitialExpr, ProcessExpr},
8    parse::{
9        empty::Empty,
10        unit::{ParseUnit, Unit, UnitResult},
11    },
12};
13use syn::{parse::ParseStream, parse_quote};
14
15///
16/// `Combinator` with configuration.
17///
18#[derive(Copy, Clone, PartialEq, Eq, Debug)]
19pub struct ActionGroup {
20    pub combinator: Combinator,
21    pub application_type: ApplicationType,
22    pub move_type: MoveType,
23}
24
25impl ActionGroup {
26    ///
27    /// Creates new `ActionGroup` using provided configuration.
28    ///
29    pub fn new(
30        combinator: Combinator,
31        application_type: ApplicationType,
32        move_type: MoveType,
33    ) -> Self {
34        Self {
35            combinator,
36            application_type,
37            move_type,
38        }
39    }
40
41    ///
42    /// Parses `ParseStream` as `ExprGroup`<`ActionExpr`> using given `ParseUnit`.
43    ///
44    pub fn parse_stream(
45        &self,
46        unit_parser: &impl ParseUnit<ActionGroup>,
47        input: ParseStream<'_>,
48    ) -> UnitResult<ExprGroup<ActionExpr>, ActionGroup> {
49        let &Self {
50            combinator,
51            move_type,
52            ..
53        } = self;
54
55        if move_type == MoveType::Wrap {
56            self.to_wrapper_action_expr()
57                .ok_or_else(|| {
58                    input.error(format!("combinator {:?} can't be a wrapper", combinator))
59                })
60                .and_then(|val| {
61                    Ok(Unit {
62                        parsed: val,
63                        next: unit_parser.parse_unit::<Empty>(input, true)?.next,
64                    })
65                })
66        } else {
67            self.parse_action_expr(unit_parser, input)
68        }
69    }
70
71    ///
72    /// Attempts to build a wrapper expression from `Self` using provided `ActionGroup`.
73    ///
74    fn to_wrapper_action_expr(self) -> Option<ExprGroup<ActionExpr>> {
75        let return_val = parse_quote! { |__v| __v };
76
77        Some(ExprGroup::new(
78            match self.combinator {
79                Combinator::Map => ActionExpr::Process(ProcessExpr::Map([return_val])),
80                Combinator::AndThen => ActionExpr::Process(ProcessExpr::AndThen([return_val])),
81                Combinator::Filter => ActionExpr::Process(ProcessExpr::Filter([return_val])),
82                Combinator::Inspect => ActionExpr::Process(ProcessExpr::Inspect([return_val])),
83                Combinator::FilterMap => ActionExpr::Process(ProcessExpr::FilterMap([return_val])),
84                Combinator::Find => ActionExpr::Process(ProcessExpr::Find([return_val])),
85                Combinator::FindMap => ActionExpr::Process(ProcessExpr::FindMap([return_val])),
86                Combinator::Partition => ActionExpr::Process(ProcessExpr::Partition([return_val])),
87                Combinator::OrElse => ActionExpr::Err(ErrExpr::OrElse([return_val])),
88                Combinator::MapErr => ActionExpr::Err(ErrExpr::MapErr([return_val])),
89                _ => return None,
90            },
91            self,
92        ))
93    }
94
95    ///
96    /// Attempts to parse given `ParseStream` as `ExprGroup`<`ActionExpr`>.
97    ///
98    #[cfg(not(feature = "full"))]
99    fn parse_action_expr(
100        &self,
101        unit_parser: &impl ParseUnit<ActionGroup>,
102        input: ParseStream,
103    ) -> UnitResult<ExprGroup<ActionExpr>, ActionGroup> {
104        match self.combinator {
105            Combinator::Map => {
106                ExprGroup::parse_single_unit(ProcessExpr::Map, unit_parser, self, input)
107            }
108            Combinator::AndThen => {
109                ExprGroup::parse_single_unit(ProcessExpr::AndThen, unit_parser, self, input)
110            }
111            Combinator::Filter => {
112                ExprGroup::parse_single_unit(ProcessExpr::Filter, unit_parser, self, input)
113            }
114            Combinator::Flatten => {
115                ExprGroup::parse_empty_unit(ProcessExpr::Flatten, unit_parser, self, input)
116            }
117            Combinator::Dot => {
118                ExprGroup::parse_single_unit(ProcessExpr::Dot, unit_parser, self, input)
119            }
120            Combinator::Then => {
121                ExprGroup::parse_single_unit(ProcessExpr::Then, unit_parser, self, input)
122            }
123            Combinator::Inspect => {
124                ExprGroup::parse_single_unit(ProcessExpr::Inspect, unit_parser, self, input)
125            }
126            Combinator::Chain => {
127                ExprGroup::parse_single_unit(ProcessExpr::Chain, unit_parser, self, input)
128            }
129            Combinator::Collect => ExprGroup::parse_single_or_empty_unit(
130                ProcessExpr::Collect,
131                unit_parser,
132                self,
133                input,
134            ),
135            Combinator::Enumerate => {
136                ExprGroup::parse_empty_unit(ProcessExpr::Enumerate, unit_parser, self, input)
137            }
138            Combinator::FilterMap => {
139                ExprGroup::parse_single_unit(ProcessExpr::FilterMap, unit_parser, self, input)
140            }
141            Combinator::Find => {
142                ExprGroup::parse_single_unit(ProcessExpr::Find, unit_parser, self, input)
143            }
144            Combinator::Fold => {
145                ExprGroup::parse_double_unit(ProcessExpr::Fold, unit_parser, self, input)
146            }
147            Combinator::FindMap => {
148                ExprGroup::parse_single_unit(ProcessExpr::FindMap, unit_parser, self, input)
149            }
150            Combinator::Partition => {
151                ExprGroup::parse_single_unit(ProcessExpr::Partition, unit_parser, self, input)
152            }
153            Combinator::TryFold => {
154                ExprGroup::parse_double_unit(ProcessExpr::TryFold, unit_parser, self, input)
155            }
156            Combinator::Unzip => {
157                ExprGroup::parse_quatro_or_empty_unit(ProcessExpr::Unzip, unit_parser, self, input)
158            }
159            Combinator::Zip => {
160                ExprGroup::parse_single_unit(ProcessExpr::Zip, unit_parser, self, input)
161            }
162            Combinator::UNWRAP => {
163                ExprGroup::parse_empty_unit(ProcessExpr::UNWRAP, unit_parser, self, input)
164            }
165            Combinator::Or => ExprGroup::parse_single_unit(ErrExpr::Or, unit_parser, self, input),
166            Combinator::OrElse => {
167                ExprGroup::parse_single_unit(ErrExpr::OrElse, unit_parser, self, input)
168            }
169            Combinator::MapErr => {
170                ExprGroup::parse_single_unit(ErrExpr::MapErr, unit_parser, self, input)
171            }
172            Combinator::Initial => {
173                ExprGroup::parse_single_unit(InitialExpr::Single, unit_parser, self, input)
174            }
175        }
176    }
177
178    ///
179    /// Attempts to parse given `ParseStream` as `ExprGroup`<`ActionExpr`>.
180    ///
181    #[cfg(feature = "full")]
182    fn parse_action_expr(
183        &self,
184        unit_parser: &impl ParseUnit<ActionGroup>,
185        input: ParseStream,
186    ) -> UnitResult<ExprGroup<ActionExpr>, ActionGroup> {
187        match self.combinator {
188            Combinator::Map => {
189                ExprGroup::parse_single_unit(ProcessExpr::Map, unit_parser, self, input)
190            }
191            Combinator::AndThen => {
192                ExprGroup::parse_single_unit(ProcessExpr::AndThen, unit_parser, self, input)
193            }
194            Combinator::Filter => {
195                ExprGroup::parse_single_unit(ProcessExpr::Filter, unit_parser, self, input)
196            }
197            Combinator::Dot => {
198                ExprGroup::parse_single_unit(ProcessExpr::Dot, unit_parser, self, input)
199            }
200            Combinator::Then => {
201                ExprGroup::parse_single_unit(ProcessExpr::Then, unit_parser, self, input)
202            }
203            Combinator::Inspect => {
204                ExprGroup::parse_single_unit(ProcessExpr::Inspect, unit_parser, self, input)
205            }
206            Combinator::All => {
207                ExprGroup::parse_single_unit(ProcessExpr::All, unit_parser, self, input)
208            }
209            Combinator::Any => {
210                ExprGroup::parse_single_unit(ProcessExpr::Any, unit_parser, self, input)
211            }
212            Combinator::ByRef => {
213                ExprGroup::parse_empty_unit(ProcessExpr::ByRef, unit_parser, self, input)
214            }
215            Combinator::Chain => {
216                ExprGroup::parse_single_unit(ProcessExpr::Chain, unit_parser, self, input)
217            }
218            Combinator::Cloned => {
219                ExprGroup::parse_empty_unit(ProcessExpr::Cloned, unit_parser, self, input)
220            }
221            Combinator::Cmp => {
222                ExprGroup::parse_single_unit(ProcessExpr::Cmp, unit_parser, self, input)
223            }
224            Combinator::Collect => ExprGroup::parse_single_or_empty_unit(
225                ProcessExpr::Collect,
226                unit_parser,
227                self,
228                input,
229            ),
230            Combinator::Copied => {
231                ExprGroup::parse_empty_unit(ProcessExpr::Copied, unit_parser, self, input)
232            }
233            Combinator::Count => {
234                ExprGroup::parse_empty_unit(ProcessExpr::Count, unit_parser, self, input)
235            }
236            Combinator::Cycle => {
237                ExprGroup::parse_empty_unit(ProcessExpr::Cycle, unit_parser, self, input)
238            }
239            Combinator::Enumerate => {
240                ExprGroup::parse_empty_unit(ProcessExpr::Enumerate, unit_parser, self, input)
241            }
242            Combinator::Eq => {
243                ExprGroup::parse_single_unit(ProcessExpr::Eq, unit_parser, self, input)
244            }
245            Combinator::FilterMap => {
246                ExprGroup::parse_single_unit(ProcessExpr::FilterMap, unit_parser, self, input)
247            }
248            Combinator::Find => {
249                ExprGroup::parse_single_unit(ProcessExpr::Find, unit_parser, self, input)
250            }
251            Combinator::FindMap => {
252                ExprGroup::parse_single_unit(ProcessExpr::FindMap, unit_parser, self, input)
253            }
254            Combinator::FlatMap => {
255                ExprGroup::parse_single_unit(ProcessExpr::FlatMap, unit_parser, self, input)
256            }
257            Combinator::Flatten => {
258                ExprGroup::parse_empty_unit(ProcessExpr::Flatten, unit_parser, self, input)
259            }
260            Combinator::Fold => {
261                ExprGroup::parse_double_unit(ProcessExpr::Fold, unit_parser, self, input)
262            }
263            Combinator::ForEach => {
264                ExprGroup::parse_single_unit(ProcessExpr::ForEach, unit_parser, self, input)
265            }
266            Combinator::Fuse => {
267                ExprGroup::parse_empty_unit(ProcessExpr::Fuse, unit_parser, self, input)
268            }
269            Combinator::Ge => {
270                ExprGroup::parse_single_unit(ProcessExpr::Ge, unit_parser, self, input)
271            }
272            Combinator::Gt => {
273                ExprGroup::parse_single_unit(ProcessExpr::Gt, unit_parser, self, input)
274            }
275            Combinator::IsSorted => {
276                ExprGroup::parse_empty_unit(ProcessExpr::IsSorted, unit_parser, self, input)
277            }
278            Combinator::IsSortedBy => {
279                ExprGroup::parse_single_unit(ProcessExpr::IsSortedBy, unit_parser, self, input)
280            }
281            Combinator::IsSortedByKey => {
282                ExprGroup::parse_single_unit(ProcessExpr::IsSortedByKey, unit_parser, self, input)
283            }
284            Combinator::IsPartitioned => {
285                ExprGroup::parse_empty_unit(ProcessExpr::IsPartitioned, unit_parser, self, input)
286            }
287            Combinator::Last => {
288                ExprGroup::parse_empty_unit(ProcessExpr::Last, unit_parser, self, input)
289            }
290            Combinator::Le => {
291                ExprGroup::parse_single_unit(ProcessExpr::Le, unit_parser, self, input)
292            }
293            Combinator::Lt => {
294                ExprGroup::parse_single_unit(ProcessExpr::Lt, unit_parser, self, input)
295            }
296            Combinator::Max => {
297                ExprGroup::parse_empty_unit(ProcessExpr::Max, unit_parser, self, input)
298            }
299            Combinator::MaxBy => {
300                ExprGroup::parse_single_unit(ProcessExpr::MaxBy, unit_parser, self, input)
301            }
302            Combinator::MaxByKey => {
303                ExprGroup::parse_single_unit(ProcessExpr::MaxByKey, unit_parser, self, input)
304            }
305            Combinator::Min => {
306                ExprGroup::parse_empty_unit(ProcessExpr::Min, unit_parser, self, input)
307            }
308            Combinator::MinBy => {
309                ExprGroup::parse_single_unit(ProcessExpr::MinBy, unit_parser, self, input)
310            }
311            Combinator::MinByKey => {
312                ExprGroup::parse_single_unit(ProcessExpr::MinByKey, unit_parser, self, input)
313            }
314            Combinator::Ne => {
315                ExprGroup::parse_single_unit(ProcessExpr::Ne, unit_parser, self, input)
316            }
317            Combinator::Nth => {
318                ExprGroup::parse_single_unit(ProcessExpr::Nth, unit_parser, self, input)
319            }
320            Combinator::PartialCmp => {
321                ExprGroup::parse_single_unit(ProcessExpr::PartialCmp, unit_parser, self, input)
322            }
323            Combinator::Partition => {
324                ExprGroup::parse_single_unit(ProcessExpr::Partition, unit_parser, self, input)
325            }
326            Combinator::PartitionInPlace => ExprGroup::parse_single_unit(
327                ProcessExpr::PartitionInPlace,
328                unit_parser,
329                self,
330                input,
331            ),
332            Combinator::Peekable => {
333                ExprGroup::parse_empty_unit(ProcessExpr::Peekable, unit_parser, self, input)
334            }
335            Combinator::Position => {
336                ExprGroup::parse_single_unit(ProcessExpr::Position, unit_parser, self, input)
337            }
338            Combinator::Product => {
339                ExprGroup::parse_empty_unit(ProcessExpr::Product, unit_parser, self, input)
340            }
341            Combinator::Rev => {
342                ExprGroup::parse_empty_unit(ProcessExpr::Rev, unit_parser, self, input)
343            }
344            Combinator::Rposition => {
345                ExprGroup::parse_single_unit(ProcessExpr::Rposition, unit_parser, self, input)
346            }
347            Combinator::Scan => {
348                ExprGroup::parse_single_unit(ProcessExpr::Scan, unit_parser, self, input)
349            }
350            Combinator::SizeHint => {
351                ExprGroup::parse_empty_unit(ProcessExpr::SizeHint, unit_parser, self, input)
352            }
353            Combinator::Skip => {
354                ExprGroup::parse_single_unit(ProcessExpr::Skip, unit_parser, self, input)
355            }
356            Combinator::SkipWhile => {
357                ExprGroup::parse_single_unit(ProcessExpr::SkipWhile, unit_parser, self, input)
358            }
359            Combinator::StepBy => {
360                ExprGroup::parse_single_unit(ProcessExpr::StepBy, unit_parser, self, input)
361            }
362            Combinator::Sum => {
363                ExprGroup::parse_empty_unit(ProcessExpr::Sum, unit_parser, self, input)
364            }
365            Combinator::Take => {
366                ExprGroup::parse_single_unit(ProcessExpr::Take, unit_parser, self, input)
367            }
368            Combinator::TakeWhile => {
369                ExprGroup::parse_single_unit(ProcessExpr::TakeWhile, unit_parser, self, input)
370            }
371            Combinator::TryFold => {
372                ExprGroup::parse_double_unit(ProcessExpr::TryFold, unit_parser, self, input)
373            }
374            Combinator::TryForEach => {
375                ExprGroup::parse_single_unit(ProcessExpr::TryForEach, unit_parser, self, input)
376            }
377            Combinator::Unzip => {
378                ExprGroup::parse_quatro_or_empty_unit(ProcessExpr::Unzip, unit_parser, self, input)
379            }
380            Combinator::Zip => {
381                ExprGroup::parse_single_unit(ProcessExpr::Zip, unit_parser, self, input)
382            }
383            Combinator::UNWRAP => {
384                ExprGroup::parse_empty_unit(ProcessExpr::UNWRAP, unit_parser, self, input)
385            }
386            Combinator::Or => ExprGroup::parse_single_unit(ErrExpr::Or, unit_parser, self, input),
387            Combinator::OrElse => {
388                ExprGroup::parse_single_unit(ErrExpr::OrElse, unit_parser, self, input)
389            }
390            Combinator::MapErr => {
391                ExprGroup::parse_single_unit(ErrExpr::MapErr, unit_parser, self, input)
392            }
393            Combinator::Initial => {
394                ExprGroup::parse_single_unit(InitialExpr::Single, unit_parser, self, input)
395            }
396        }
397    }
398}
join_impl/chain/group/action_group.rs

join_impl/chain/group/
action_group.rs
