unsynn/
container.rs

1//! This module provides parsers for types that contain possibly multiple values. This
2//! includes stdlib types like [`Option`], [`Vec`], [`Box`], [`Rc`], [`RefCell`] and types
3//! for delimited and repeated values with numbered repeats.
4
5use crate::{
6    Colon, Comma, Cons, Delimited, Dot, EndOfStream, Error, Except, Expect, Nothing, Parse, Parser,
7    PathSep, RefineErr, Result, Semicolon, ToTokens, TokenIter, TokenStream,
8};
9
10use std::{cell::RefCell, marker::PhantomData, ops::Deref, rc::Rc};
11
12// PLANNED: investigate which collections can impl FromIterator
13// PLANNED: Which unsynn types should impl Deref?
14
15/// Zero or One of T.
16impl<T: Parse> Parser for Option<T> {
17    fn parser(tokens: &mut TokenIter) -> Result<Self> {
18        match T::parse(tokens) {
19            Ok(value) => Ok(Some(value)),
20            Err(_) => Ok(None),
21        }
22    }
23}
24
25impl<T: ToTokens> ToTokens for Option<T> {
26    fn to_tokens(&self, tokens: &mut TokenStream) {
27        if let Some(t) = self.as_ref() {
28            t.to_tokens(tokens);
29        }
30    }
31}
32
33/// Any number of T
34impl<T: Parse> Parser for Vec<T> {
35    fn parser(tokens: &mut TokenIter) -> Result<Self> {
36        let mut output = Vec::new();
37        let mut track_pos = tokens.counter();
38
39        while let Ok(value) = T::parse(tokens) {
40            if tokens.counter() == track_pos {
41                return Error::infinite_loop::<Vec<T>>(tokens.clone().next(), tokens);
42            }
43            track_pos = tokens.counter();
44            output.push(value);
45        }
46        Ok(output)
47    }
48}
49
50impl<T: ToTokens> ToTokens for Vec<T> {
51    fn to_tokens(&self, tokens: &mut TokenStream) {
52        for value in self {
53            value.to_tokens(tokens);
54        }
55    }
56}
57
58/// `NonEmptyOption<T>` prevents `Option` from matching when `T` can succeed with empty
59/// input. It ensures `None` is returned when no tokens remain, regardless of whether `T`
60/// could succeed on an empty stream. This is crucial when parsing optional trailing content
61/// that should only match if tokens are actually available to consume.
62///
63/// # Example
64///
65/// ```
66/// # use unsynn::*;
67/// let mut token_iter = "ident".to_token_iter();
68///
69/// let parsed = NonEmptyOption::<Punct>::parser(&mut token_iter).unwrap();
70/// assert_tokens_eq!(parsed, "");
71/// # assert_tokens_eq!(NonEmptyOption::<Punct>::parser(&mut ".".to_token_iter()).unwrap(), ".");
72/// ```
73///
74/// # Contrast with `Option<T>`
75///
76/// ```
77/// # use unsynn::*;
78/// // Vec<T> can succeed with zero items
79/// let mut token_iter = "".to_token_iter();
80///
81/// // Option<T> returns Some(empty_vec) even at EndOfStream
82/// let parsed = Option::<Vec<Ident>>::parser(&mut token_iter).unwrap();
83/// assert!(parsed.is_some());
84///
85/// // NonEmptyOption<T> returns None at EndOfStream
86/// let mut token_iter = "".to_token_iter();
87/// let parsed = NonEmptyOption::<Vec<Ident>>::parser(&mut token_iter).unwrap();
88/// assert!(parsed.is_none());
89/// ```
90#[derive(Clone)]
91pub struct NonEmptyOption<T>(pub Option<T>);
92
93impl<T: Parse> Parser for NonEmptyOption<T> {
94    fn parser(tokens: &mut TokenIter) -> Result<Self> {
95        Ok(Self(<Option<Cons<Except<EndOfStream>, T>>>::parse_with(
96            tokens,
97            |t, _| Ok(t.map(|t| t.second)),
98        )?))
99    }
100}
101
102impl<T: ToTokens> ToTokens for NonEmptyOption<T> {
103    #[inline]
104    fn to_tokens(&self, tokens: &mut TokenStream) {
105        self.0.to_tokens(tokens);
106    }
107}
108
109#[mutants::skip]
110impl<T: std::fmt::Debug> std::fmt::Debug for NonEmptyOption<T> {
111    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
112        f.debug_struct(&format!("NonEmptyOption<{}>", std::any::type_name::<T>()))
113            .finish()
114    }
115}
116
117impl<T> std::ops::Deref for NonEmptyOption<T> {
118    type Target = Option<T>;
119
120    fn deref(&self) -> &Self::Target {
121        &self.0
122    }
123}
124
125/// A trait for parsing a repeating `T` with a minimum and maximum limit.
126/// Sometimes the number of elements to be parsed is determined at runtime eg. a number of
127/// header items needs a matching number of values.
128///
129/// # Example
130///
131/// Parse at table with a number of headers followed by values.
132///
133/// ```
134/// # use unsynn::*;
135/// let mut token_iter = "
136///     foo:       bar:
137///     foo_value  bar_value
138/// ".to_token_iter();
139///
140/// let headers = Vec::<Cons<Ident,Colon>>::parse(&mut token_iter).unwrap();
141/// let values = Vec::<Ident>::parse_exactly(&mut token_iter, headers.len()).unwrap();
142/// ```
143#[allow(clippy::missing_errors_doc)]
144pub trait RangedRepeats: Sized {
145    /// Parse at least `min` and up to `max` (inclusive) elements.
146    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self>;
147
148    /// Parse any number of elements.
149    fn parse_any(tokens: &mut TokenIter) -> Result<Self> {
150        Self::parse_repeats(tokens, 0, usize::MAX)
151    }
152
153    /// Parse at least one element.
154    fn parse_many(tokens: &mut TokenIter) -> Result<Self> {
155        Self::parse_repeats(tokens, 1, usize::MAX)
156    }
157
158    /// Parse zero or one element.
159    fn parse_optional(tokens: &mut TokenIter) -> Result<Self> {
160        Self::parse_repeats(tokens, 0, 1)
161    }
162
163    /// Parse exactly `n` elements.
164    fn parse_exactly(tokens: &mut TokenIter, n: usize) -> Result<Self> {
165        Self::parse_repeats(tokens, n, n)
166    }
167
168    /// Parse at most `n` elements.
169    fn parse_at_most(tokens: &mut TokenIter, n: usize) -> Result<Self> {
170        Self::parse_repeats(tokens, 0, n)
171    }
172
173    /// Parse at least `n` elements.
174    fn parse_at_least(tokens: &mut TokenIter, n: usize) -> Result<Self> {
175        Self::parse_repeats(tokens, n, usize::MAX)
176    }
177}
178
179impl<T: Parse> RangedRepeats for Vec<T> {
180    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self> {
181        let mut output = Vec::with_capacity(min);
182        let mut at = tokens.clone().next();
183        for _ in 0..max {
184            let pos_before = tokens.counter();
185            at = tokens.clone().next();
186            if let Ok(value) = T::parse(tokens) {
187                if tokens.counter() == pos_before {
188                    return Error::infinite_loop::<Vec<T>>(at, tokens);
189                }
190                output.push(value);
191            } else {
192                break;
193            }
194        }
195
196        if output.len() >= min {
197            Ok(output)
198        } else {
199            Error::other(
200                at,
201                tokens,
202                format!("less than {} elements, got {}", min, output.len()),
203            )
204        }
205    }
206}
207
208/// Box a parseable entity. In a enum it may happen that most variants are rather small while
209/// few variants are large. In this case it may be beneficial to box the large variants to
210/// keep the enum lean. `Box` or `Rc` are required for parsing recursive grammars.
211impl<T: Parse> Parser for Box<T> {
212    fn parser(tokens: &mut TokenIter) -> Result<Self> {
213        Ok(Box::new(T::parser(tokens).refine_err::<Self>()?))
214    }
215}
216
217impl<T: ToTokens> ToTokens for Box<T> {
218    fn to_tokens(&self, tokens: &mut TokenStream) {
219        self.as_ref().to_tokens(tokens);
220    }
221}
222
223/// Rc a parseable entity. Just because we can. Sometimes when a value is shared between
224/// multiple entities it may be beneficial to use Rc. `Box` or `Rc` are required for parsing recursive grammars.
225impl<T: Parse> Parser for Rc<T> {
226    fn parser(tokens: &mut TokenIter) -> Result<Self> {
227        Ok(Rc::new(T::parser(tokens).refine_err::<Self>()?))
228    }
229}
230
231impl<T: ToTokens> ToTokens for Rc<T> {
232    fn to_tokens(&self, tokens: &mut TokenStream) {
233        self.as_ref().to_tokens(tokens);
234    }
235}
236
237/// Put any parseable entity in a `RefCell`. In case one wants to mutate the a parse tree on the
238/// fly.
239impl<T: Parse> Parser for RefCell<T> {
240    fn parser(tokens: &mut TokenIter) -> Result<Self> {
241        Ok(RefCell::new(T::parser(tokens).refine_err::<Self>()?))
242    }
243}
244
245impl<T: ToTokens> ToTokens for RefCell<T> {
246    fn to_tokens(&self, tokens: &mut TokenStream) {
247        self.borrow().to_tokens(tokens);
248    }
249}
250
251/// A `Vec<T>` that is filled up to the first appearance of an terminating `S`.  This `S` may
252/// be a subset of `T`, thus parsing become lazy.  This is the same as
253/// `Cons<Vec<Cons<Except<S>,T>>,S>` but more convenient and efficient.
254///
255/// # Example
256///
257/// Parse anything until a `;`.
258///
259/// ```
260/// # use unsynn::*;
261/// let mut token_iter = "foo bar ; baz ;".to_token_iter();
262///
263/// type Example = LazyVec<TokenTree, Semicolon>;
264///
265/// let _example = Example::parse(&mut token_iter).unwrap();
266/// let _example = Example::parse(&mut token_iter).unwrap();
267/// ```
268#[derive(Clone)]
269pub struct LazyVec<T, S> {
270    /// The vector of repeating `T`
271    pub vec: Vec<T>,
272    /// The terminating `S`
273    pub terminator: S,
274}
275
276impl<T: Parse, S: Parse> Parser for LazyVec<T, S> {
277    fn parser(tokens: &mut TokenIter) -> Result<Self> {
278        let mut vec = Vec::new();
279
280        loop {
281            if let Ok(terminator) = S::parse(tokens) {
282                return Ok(Self { vec, terminator });
283            }
284
285            let pos_before_t = tokens.counter();
286            let value = T::parse(tokens)?;
287
288            if tokens.counter() == pos_before_t {
289                return Error::infinite_loop::<LazyVec<T, S>>(tokens.clone().next(), tokens);
290            }
291
292            vec.push(value);
293        }
294    }
295}
296
297impl<T: ToTokens, S: ToTokens> ToTokens for LazyVec<T, S> {
298    fn to_tokens(&self, tokens: &mut TokenStream) {
299        self.vec.iter().for_each(|value| value.to_tokens(tokens));
300        self.terminator.to_tokens(tokens);
301    }
302}
303
304impl<T: Parse, S: Parse> RangedRepeats for LazyVec<T, S> {
305    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self> {
306        let mut vec = Vec::with_capacity(min);
307        let mut at = tokens.clone().next();
308        for _ in 0..max {
309            at = tokens.clone().next();
310            if let Ok(terminator) = S::parse(tokens) {
311                return if vec.len() >= min {
312                    Ok(Self { vec, terminator })
313                } else {
314                    Error::other(
315                        at,
316                        tokens,
317                        format!("less than {} elements, got {}", min, vec.len()),
318                    )
319                };
320            }
321
322            let pos_before_t = tokens.counter();
323            let value = T::parse(tokens)?;
324            if tokens.counter() == pos_before_t {
325                return Error::infinite_loop::<LazyVec<T, S>>(at, tokens);
326            }
327
328            vec.push(value);
329        }
330        Error::other(at, tokens, format!("more than {max} elements"))
331    }
332}
333
334impl<T, S> IntoIterator for LazyVec<T, S> {
335    type Item = T;
336    type IntoIter = std::vec::IntoIter<Self::Item>;
337
338    fn into_iter(self) -> Self::IntoIter {
339        self.vec.into_iter()
340    }
341}
342
343#[mutants::skip]
344impl<T: std::fmt::Debug, S: std::fmt::Debug> std::fmt::Debug for LazyVec<T, S> {
345    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
346        f.debug_struct(&format!(
347            "LazyVec<{}, {}>",
348            std::any::type_name::<T>(),
349            std::any::type_name::<S>()
350        ))
351        .field("vec", &self.vec)
352        .field("terminator", &self.terminator)
353        .finish()
354    }
355}
356
357/// A `Vec<T>` that is filled up to the first appearance of an terminating `S`.  This `S` may
358/// be a subset of `T`, thus parsing become lazy.  Unlike `LazyVec` this variant does not consume
359/// the final terminator. This is the same as `Vec<Cons<Except<S>,T>>>` but more convenient.
360///
361/// # Example
362///
363/// Parse anything until a `;`.
364///
365/// ```
366/// # use unsynn::*;
367/// let mut token_iter = "foo bar ; baz ;".to_token_iter();
368///
369/// type Example = LazyVecUntil<TokenTree, Semicolon>;
370///
371/// let _example = Example::parse(&mut token_iter).unwrap();
372/// let _example = Semicolon::parse(&mut token_iter).unwrap();
373/// let _example = Example::parse(&mut token_iter).unwrap();
374/// let _example = Semicolon::parse(&mut token_iter).unwrap();
375/// ```
376#[derive(Clone)]
377pub struct LazyVecUntil<T, S> {
378    /// The vector of repeating `T`
379    pub vec: Vec<T>,
380    phantom: PhantomData<S>,
381}
382
383impl<T: Parse, S: Parse> Parser for LazyVecUntil<T, S> {
384    fn parser(tokens: &mut TokenIter) -> Result<Self> {
385        let mut vec = Vec::new();
386
387        loop {
388            if <Expect<S>>::parse(tokens).is_ok() {
389                return Ok(Self {
390                    vec,
391                    phantom: PhantomData,
392                });
393            }
394
395            let pos_before_t = tokens.counter();
396            let value = T::parse(tokens)?;
397            if tokens.counter() == pos_before_t {
398                return Error::infinite_loop::<LazyVecUntil<T, S>>(tokens.clone().next(), tokens);
399            }
400
401            vec.push(value);
402        }
403    }
404}
405
406impl<T: ToTokens, S: ToTokens> ToTokens for LazyVecUntil<T, S> {
407    fn to_tokens(&self, tokens: &mut TokenStream) {
408        self.vec.iter().for_each(|value| value.to_tokens(tokens));
409    }
410}
411
412impl<T: Parse, S: Parse> RangedRepeats for LazyVecUntil<T, S> {
413    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self> {
414        let mut vec = Vec::with_capacity(min);
415        let mut at = tokens.clone().next();
416        for _ in 0..max {
417            at = tokens.clone().next();
418            if <Expect<S>>::parse(tokens).is_ok() {
419                return if vec.len() >= min {
420                    Ok(Self {
421                        vec,
422                        phantom: PhantomData,
423                    })
424                } else {
425                    Error::other(
426                        at,
427                        tokens,
428                        format!("less than {} elements, got {}", min, vec.len()),
429                    )
430                };
431            }
432
433            let pos_before_t = tokens.counter();
434            let value = T::parse(tokens)?;
435            if tokens.counter() == pos_before_t {
436                return Error::infinite_loop::<LazyVecUntil<T, S>>(at, tokens);
437            }
438
439            vec.push(value);
440        }
441        Error::other(at, tokens, format!("more than {max} elements"))
442    }
443}
444
445impl<T, S> IntoIterator for LazyVecUntil<T, S> {
446    type Item = T;
447    type IntoIter = std::vec::IntoIter<Self::Item>;
448
449    fn into_iter(self) -> Self::IntoIter {
450        self.vec.into_iter()
451    }
452}
453
454#[mutants::skip]
455impl<T: std::fmt::Debug, S: std::fmt::Debug> std::fmt::Debug for LazyVecUntil<T, S> {
456    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
457        f.debug_struct(&format!(
458            "LazyVec<{}, {}>",
459            std::any::type_name::<T>(),
460            std::any::type_name::<S>()
461        ))
462        .field("vec", &self.vec)
463        .finish()
464    }
465}
466
467/// Policy for the delimiter of the last element in a sequence.  Note that delimiters are
468/// after some element, for cases where you have leading delimiters you need to define
469/// grammars that start with `Delimiter` or `Option<Delimiter>`.
470#[allow(non_snake_case)]
471pub mod TrailingDelimiter {
472    /// The delimiter at the end must be present `a; b; c;`.
473    #[derive(Copy, Clone, Debug)]
474    pub struct Mandatory;
475
476    /// The delimiter at the end is optional `a, b` or `a, b,`.
477    #[derive(Copy, Clone, Debug)]
478    pub struct Optional;
479
480    /// There must be no delimiter at the end `a::b`.
481    #[derive(Copy, Clone, Debug)]
482    pub struct Forbidden;
483}
484
485/// Since the delimiter in [`Delimited<T,D>`] is optional a [`Vec<Delimited<T,D>>`] would
486/// parse consecutive values even without delimiters. [`DelimitedVec<T, D, MIN, MAX, P>`] will
487/// stop parsing by MIN/MAX number of elements and depending on the policy defined by `P`
488/// which can be one of [`TrailingDelimiter`].
489#[derive(Clone)]
490pub struct DelimitedVec<
491    T,
492    D,
493    P = TrailingDelimiter::Optional,
494    const MIN: usize = 0,
495    const MAX: usize = { usize::MAX },
496>(Vec<Delimited<T, D>>, PhantomData<P>);
497
498impl<T: Parse, D: Parse, const MIN: usize, const MAX: usize> Parser
499    for DelimitedVec<T, D, TrailingDelimiter::Optional, MIN, MAX>
500{
501    fn parser(tokens: &mut TokenIter) -> Result<Self> {
502        const { assert!(MIN <= MAX) };
503        let mut output = Vec::new();
504        let mut at = tokens.clone().next();
505        while output.len() < MAX {
506            let pos_before = tokens.counter();
507            if let Ok(delimited) = Delimited::<T, D>::parse(tokens) {
508                if tokens.counter() == pos_before {
509                    return Error::infinite_loop::<
510                        DelimitedVec<T, D, TrailingDelimiter::Optional, MIN, MAX>,
511                    >(at, tokens);
512                }
513                at = tokens.clone().next();
514                let done = delimited.delimiter.is_none();
515                output.push(delimited);
516                if done {
517                    break;
518                }
519            } else {
520                break;
521            }
522        }
523
524        #[allow(unused_comparisons)]
525        if output.len() >= MIN {
526            Ok(Self(output, PhantomData))
527        } else {
528            Error::other(
529                at,
530                tokens,
531                format!(
532                    "Expected at least {MIN} elements in DelimitedVec<{}, {}, {MIN}, {MAX}, {:?}> but got only {}",
533                    std::any::type_name::<T>(),
534                    std::any::type_name::<D>(),
535                    TrailingDelimiter::Optional,
536                    output.len(),
537                ),
538            )
539        }
540    }
541}
542
543impl<T: Parse + ToTokens, D: Parse, const MIN: usize, const MAX: usize> Parser
544    for DelimitedVec<T, D, TrailingDelimiter::Mandatory, MIN, MAX>
545{
546    fn parser(tokens: &mut TokenIter) -> Result<Self> {
547        const { assert!(MIN <= MAX) };
548        let mut output = Vec::new();
549        let at = tokens.clone().next();
550        #[allow(unused_comparisons)]
551        while output.len() < MAX {
552            let pos_before = tokens.counter();
553            match Delimited::<T, D>::parse_with(tokens, |d, tokens| {
554                if d.delimiter.is_some() {
555                    Ok(d)
556                } else {
557                    Error::unexpected_token(d.value.to_token_iter().next(), tokens)
558                }
559            }) {
560                Ok(delimited) => {
561                    if tokens.counter() == pos_before {
562                        return Error::infinite_loop::<
563                            DelimitedVec<T, D, TrailingDelimiter::Mandatory, MIN, MAX>,
564                        >(at, tokens);
565                    }
566                    output.push(delimited);
567                }
568                Err(_) => break,
569            }
570        }
571
572        #[allow(unused_comparisons)]
573        if output.len() >= MIN {
574            Ok(Self(output, PhantomData))
575        } else {
576            Error::other(
577                at,
578                tokens,
579                format!(
580                    "Expected at least {MIN} elements in DelimitedVec<{}, {}, {MIN}, {MAX}, {:?}> but got only {}",
581                    std::any::type_name::<T>(),
582                    std::any::type_name::<D>(),
583                    TrailingDelimiter::Mandatory,
584                    output.len(),
585                ),
586            )
587        }
588    }
589}
590
591impl<T: Parse + ToTokens, D: Parse, const MIN: usize, const MAX: usize> Parser
592    for DelimitedVec<T, D, TrailingDelimiter::Forbidden, MIN, MAX>
593{
594    fn parser(tokens: &mut TokenIter) -> Result<Self> {
595        const { assert!(MIN <= MAX) };
596        let mut output = Vec::new();
597        let at = tokens.clone().next();
598
599        while output.len() < MAX {
600            let pos_before = tokens.counter();
601            if let Ok(delimited) = Delimited::<T, D>::parse(tokens) {
602                if tokens.counter() == pos_before {
603                    return Error::infinite_loop::<
604                        DelimitedVec<T, D, TrailingDelimiter::Forbidden, MIN, MAX>,
605                    >(at, tokens);
606                }
607                let done = delimited.delimiter.is_none();
608                output.push(delimited);
609                if done {
610                    break;
611                }
612            } else {
613                break;
614            }
615        }
616
617        #[allow(unused_comparisons)]
618        if output.len() >= MIN {
619            if let Some(last) = output.last() {
620                if last.delimiter.is_some() {
621                    return Error::unexpected_token::<Self>(tokens.clone().next(), tokens);
622                }
623            }
624            Ok(Self(output, PhantomData))
625        } else {
626            Error::other(
627                        at,
628                        tokens,
629                        format!(
630                            "Expected at least {MIN} elements in DelimitedVec<{}, {}, {MIN}, {MAX}, {:?}> but got only {}",
631                            std::any::type_name::<T>(),
632                            std::any::type_name::<D>(),
633                            TrailingDelimiter::Forbidden,
634                            output.len(),
635                        ),
636                    )
637        }
638    }
639}
640
641/// Converts a [`DelimitedVec<T, D>`] into a [`Vec<T>`].
642/// This loses all delimiters, which may have been stateful (eg. `Either`).
643impl<T, D, P, const MIN: usize, const MAX: usize> From<DelimitedVec<T, D, P, MIN, MAX>> for Vec<T> {
644    fn from(delimited_vec: DelimitedVec<T, D, P, MIN, MAX>) -> Self {
645        const { assert!(MIN <= MAX) };
646        delimited_vec
647            .0
648            .into_iter()
649            .map(|delimited| delimited.value)
650            .collect()
651    }
652}
653
654impl<T: ToTokens, D: ToTokens, P, const MIN: usize, const MAX: usize> ToTokens
655    for DelimitedVec<T, D, P, MIN, MAX>
656{
657    fn to_tokens(&self, tokens: &mut TokenStream) {
658        self.0.iter().for_each(|value| value.to_tokens(tokens));
659    }
660}
661
662impl<T: Parse, D: Parse, const MIN: usize, const MAX: usize> RangedRepeats
663    for DelimitedVec<T, D, TrailingDelimiter::Optional, MIN, MAX>
664{
665    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self> {
666        const { assert!(MIN <= MAX) };
667        if min < MIN {
668            Error::out_of_range::<MIN, _>(min, tokens.clone().next(), tokens)?;
669        }
670        if max > MAX {
671            Error::out_of_range::<MAX, _>(max, tokens.clone().next(), tokens)?;
672        }
673        let mut output = Vec::with_capacity(min);
674        let mut at = tokens.clone().next();
675        for _ in 0..max {
676            at = tokens.clone().next();
677            if let Ok(delimited) = Delimited::<T, D>::parse(tokens) {
678                let done = delimited.delimiter.is_none();
679                output.push(delimited);
680                if done {
681                    break;
682                }
683            } else {
684                break;
685            }
686        }
687
688        if output.len() >= min {
689            Ok(Self(output, PhantomData))
690        } else {
691            Error::other(
692                at,
693                tokens,
694                format!("less than {} elements, got {}", min, output.len()),
695            )
696        }
697    }
698}
699
700impl<T: Parse, D: Parse, const MIN: usize, const MAX: usize> RangedRepeats
701    for DelimitedVec<T, D, TrailingDelimiter::Mandatory, MIN, MAX>
702{
703    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self> {
704        const { assert!(MIN <= MAX) };
705        if min < MIN {
706            Error::out_of_range::<MIN, _>(min, tokens.clone().next(), tokens)?;
707        }
708        if max > MAX {
709            Error::out_of_range::<MAX, _>(max, tokens.clone().next(), tokens)?;
710        }
711        let mut output = Vec::with_capacity(min);
712        let mut at = tokens.clone().next();
713        for _ in 0..max {
714            at = tokens.clone().next();
715            if let Ok(delimited) = Delimited::<T, D>::parse(tokens) {
716                if delimited.delimiter.is_none() {
717                    return Error::other(at, tokens, "missing mandatory delimiter".to_string());
718                }
719                output.push(delimited);
720            } else {
721                break;
722            }
723        }
724
725        if output.len() >= min {
726            Ok(Self(output, PhantomData))
727        } else {
728            Error::other(
729                at,
730                tokens,
731                format!("less than {} elements, got {}", min, output.len()),
732            )
733        }
734    }
735}
736
737impl<T: Parse + ToTokens, D: Parse, const MIN: usize, const MAX: usize> RangedRepeats
738    for DelimitedVec<T, D, TrailingDelimiter::Forbidden, MIN, MAX>
739{
740    fn parse_repeats(tokens: &mut TokenIter, min: usize, max: usize) -> Result<Self> {
741        const { assert!(MIN <= MAX) };
742        if min < MIN {
743            Error::out_of_range::<MIN, _>(min, tokens.clone().next(), tokens)?;
744        }
745        if max > MAX {
746            Error::out_of_range::<MAX, _>(max, tokens.clone().next(), tokens)?;
747        }
748        let mut output = Vec::with_capacity(min);
749        let mut at = tokens.clone().next();
750        for _ in 0..max {
751            at = tokens.clone().next();
752            if let Ok(delimited) = Delimited::<T, D>::parse(tokens) {
753                let done = delimited.delimiter.is_none();
754                output.push(delimited);
755                if done {
756                    break;
757                }
758            } else {
759                break;
760            }
761        }
762
763        if output.len() >= min {
764            if let Some(last) = output.last() {
765                if last.delimiter.is_some() {
766                    Error::unexpected_token::<_>(last.value.to_token_iter().next(), tokens)?;
767                }
768            }
769            Ok(Self(output, PhantomData))
770        } else {
771            Error::other(
772                at,
773                tokens,
774                format!("less than {} elements, got {}", min, output.len()),
775            )
776        }
777    }
778}
779
780impl<T, D, const MIN: usize, P, const MAX: usize> IntoIterator for DelimitedVec<T, D, P, MIN, MAX> {
781    type Item = Delimited<T, D>;
782    type IntoIter = std::vec::IntoIter<Self::Item>;
783
784    fn into_iter(self) -> Self::IntoIter {
785        self.0.into_iter()
786    }
787}
788
789impl<T, D, P, const MIN: usize, const MAX: usize> Deref for DelimitedVec<T, D, P, MIN, MAX> {
790    type Target = Vec<Delimited<T, D>>;
791    fn deref(&self) -> &Self::Target {
792        &self.0
793    }
794}
795
796/// Creates a `DelimitedVec` from a iterator over T and default constructed delimiters with mandatory
797/// trailing delimiter.
798///
799/// # Example
800///
801/// ```
802/// # use unsynn::*;
803/// let mut token_iter = "a b c d".into_token_iter();
804/// let chars: Vec<Ident> = token_iter.parse().unwrap();
805/// let comma_delimited: CommaDelimitedVec<Ident, TrailingDelimiter::Mandatory>
806///                      = chars.into_iter().collect();
807/// assert_tokens_eq!(comma_delimited, "a, b, c, d,");
808/// ```
809impl<T, D: Default, const MIN: usize, const MAX: usize> FromIterator<T>
810    for DelimitedVec<T, D, TrailingDelimiter::Mandatory, MIN, MAX>
811{
812    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
813        let iter = iter.into_iter();
814        let mut v: Vec<Delimited<T, D>> = Vec::with_capacity(iter.size_hint().0);
815        for value in iter {
816            v.push(Delimited {
817                value,
818                delimiter: Some(D::default()),
819            });
820        }
821
822        Self(v, PhantomData)
823    }
824}
825
826/// A `DelimitedVec` with mandatory trailing delimiter can be zero-cost converted to one with
827/// optional delimiter.
828impl<T, D, const MIN: usize, const MAX: usize>
829    From<DelimitedVec<T, D, TrailingDelimiter::Mandatory, MIN, MAX>>
830    for DelimitedVec<T, D, TrailingDelimiter::Optional, MIN, MAX>
831{
832    fn from(input: DelimitedVec<T, D, TrailingDelimiter::Mandatory, MIN, MAX>) -> Self {
833        Self(input.0, PhantomData)
834    }
835}
836
837/// Creates a `DelimitedVec` from a iterator over T and default constructed delimiters without
838/// trailing delimiter.
839///
840/// # Example
841///
842/// ```
843/// # use unsynn::*;
844/// let mut token_iter = "a b c d".into_token_iter();
845/// let chars: Vec<Ident> = token_iter.parse().unwrap();
846/// let comma_delimited: CommaDelimitedVec<Ident, TrailingDelimiter::Forbidden>
847///                      = chars.into_iter().collect();
848/// assert_tokens_eq!(comma_delimited, "a, b, c, d");
849/// ```
850impl<T, D: Default, const MIN: usize, const MAX: usize> FromIterator<T>
851    for DelimitedVec<T, D, TrailingDelimiter::Forbidden, MIN, MAX>
852{
853    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
854        let iter = iter.into_iter();
855        let mut v: Vec<Delimited<T, D>> = Vec::with_capacity(iter.size_hint().0);
856        for value in iter {
857            if let Some(last) = v.last_mut() {
858                last.delimiter = Some(D::default());
859            }
860            v.push(Delimited {
861                value,
862                delimiter: None,
863            });
864        }
865
866        Self(v, PhantomData)
867    }
868}
869
870/// A `DelimitedVec` with forbidden trailing delimiter can be zero-cost converted to one with
871/// optional delimiter.
872impl<T, D, const MIN: usize, const MAX: usize>
873    From<DelimitedVec<T, D, TrailingDelimiter::Forbidden, MIN, MAX>>
874    for DelimitedVec<T, D, TrailingDelimiter::Optional, MIN, MAX>
875{
876    fn from(input: DelimitedVec<T, D, TrailingDelimiter::Forbidden, MIN, MAX>) -> Self {
877        Self(input.0, PhantomData)
878    }
879}
880
881#[mutants::skip]
882impl<
883        T: std::fmt::Debug,
884        D: std::fmt::Debug,
885        P: std::fmt::Debug,
886        const MIN: usize,
887        const MAX: usize,
888    > std::fmt::Debug for DelimitedVec<T, D, P, MIN, MAX>
889{
890    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
891        f.debug_tuple(&format!(
892            "DelimitedVec<{}, {}, {}, {MIN}, {MAX}>",
893            std::any::type_name::<T>(),
894            std::any::type_name::<D>(),
895            std::any::type_name::<P>()
896        ))
897        .field(&self.0)
898        .finish()
899    }
900}
901
902/// `DelimitedVec` of `T` delimited by `,` with `P` as policy for the last delimiter.
903pub type CommaDelimitedVec<
904    T,
905    P = TrailingDelimiter::Optional,
906    const MIN: usize = 0,
907    const MAX: usize = { usize::MAX },
908> = DelimitedVec<T, Comma, P, MIN, MAX>;
909
910/// `DelimitedVec` of `T` delimited by `;` with `P` as policy for the last delimiter.
911pub type SemicolonDelimitedVec<
912    T,
913    P = TrailingDelimiter::Mandatory,
914    const MIN: usize = 0,
915    const MAX: usize = { usize::MAX },
916> = DelimitedVec<T, Semicolon, P, MIN, MAX>;
917
918/// `DelimitedVec` of `T` delimited by `.` with `P` as policy for the last delimiter.
919pub type DotDelimitedVec<
920    T,
921    P = TrailingDelimiter::Optional,
922    const MIN: usize = 0,
923    const MAX: usize = { usize::MAX },
924> = DelimitedVec<T, Dot, P, MIN, MAX>;
925
926/// `DelimitedVec` of `T` delimited by `:` with `P` as policy for the last delimiter.
927pub type ColonDelimitedVec<
928    T,
929    P = TrailingDelimiter::Optional,
930    const MIN: usize = 0,
931    const MAX: usize = { usize::MAX },
932> = DelimitedVec<T, Colon, P, MIN, MAX>;
933
934/// `DelimitedVec` of `T` delimited by `::` with `P` as policy for the last delimiter.
935pub type PathSepDelimitedVec<
936    T,
937    P = TrailingDelimiter::Forbidden,
938    const MIN: usize = 0,
939    const MAX: usize = { usize::MAX },
940> = DelimitedVec<T, PathSep, P, MIN, MAX>;
941
942/// `DelimitedVec<T,D>` with a minimum and maximum (inclusive) number of elements at first
943/// without defaults.  Parsing will succeed when at least the minimum number of elements is
944/// reached and stop at the maximum number.  The delimiter `D` defaults to [`Nothing`] to
945/// parse sequences which don't have delimiters.
946pub type Repeats<
947    const MIN: usize,
948    const MAX: usize,
949    T,
950    D = Nothing,
951    P = TrailingDelimiter::Optional,
952> = DelimitedVec<T, D, P, MIN, MAX>;
953
954/// Any number of T delimited by D or [`Nothing`]
955pub type Any<T, D = Nothing, P = TrailingDelimiter::Optional> = Repeats<0, { usize::MAX }, T, D, P>;
956
957/// One or more of T delimited by D or [`Nothing`]
958pub type Many<T, D = Nothing, P = TrailingDelimiter::Optional> =
959    Repeats<1, { usize::MAX }, T, D, P>;
960
961/// Zero or one of T delimited by D or [`Nothing`]
962pub type Optional<T, D = Nothing, P = TrailingDelimiter::Optional> = Repeats<0, 1, T, D, P>;
963
964/// Exactly N of T delimited by D or [`Nothing`]
965pub type Exactly<const N: usize, T, D = Nothing, P = TrailingDelimiter::Optional> =
966    Repeats<N, N, T, D, P>;
967
968/// At most N of T delimited by D or [`Nothing`]
969pub type AtMost<const N: usize, T, D = Nothing, P = TrailingDelimiter::Optional> =
970    Repeats<0, N, T, D, P>;
971
972/// At least N of T delimited by D or [`Nothing`]
973pub type AtLeast<const N: usize, T, D = Nothing, P = TrailingDelimiter::Optional> =
974    Repeats<N, { usize::MAX }, T, D, P>;
975
976// PLANNED: needs https://github.com/rust-lang/rust/issues/96097 impl<const N: usize, T: Parse> Parser for [T;N] {
unsynn/container.rs

unsynn/
container.rs
