Building the plain list item context.

trash/old_combinator.rs

@@ -0,0 +1,125 @@
+use super::parser_context::ContextElement;
+use super::parser_context::PreviousElementNode;
+use super::token::Token;
+use super::Context;
+use nom::error::ErrorKind;
+use nom::error::ParseError;
+use nom::IResult;
+use nom::InputLength;
+
+pub fn context_many1<'r, 's, I, O, E, M>(
+    context: Context<'r, 's>,
+    mut many_matcher: M,
+) -> impl FnMut(I) -> IResult<I, Vec<Token<'s>>, E> + 'r
+where
+    I: Clone + InputLength,
+    E: ParseError<I>,
+    M: for<'x> Fn(Context<'x, 's>, I) -> IResult<I, O, E> + 'r,
+    O: Into<Token<'s>>,
+{
+    move |mut i: I| {
+        let mut err = None;
+        // TODO: Can I eliminate the clone? I think this is incrementing the reference count
+        let mut current_context = context.clone();
+        // Despite the clone, the Rc should still point to the same value.
+        assert!(current_context.ptr_eq(context));
+        loop {
+            match many_matcher(&current_context, i.clone()) {
+                Ok((remaining, many_elem)) => {
+                    current_context = current_context.with_additional_node(
+                        ContextElement::PreviousElementNode(PreviousElementNode {
+                            element: many_elem.into(),
+                        }),
+                    );
+                    i = remaining;
+                }
+                the_error @ Err(_) => {
+                    err = Some(the_error);
+                    break;
+                }
+            }
+        }
+        let mut elements: Vec<Token<'s>> = current_context
+            .into_iter_until(context)
+            .filter_map(|context_element| match context_element {
+                ContextElement::PreviousElementNode(elem) => Some(elem.element),
+                _ => None,
+            })
+            .collect();
+        if elements.is_empty() {
+            if let Some(err) = err {
+                err?;
+            }
+        }
+        elements.reverse();
+        Ok((i, elements))
+    }
+}
+
+pub fn context_many_till<'r, 's, I, O, E, F, M, T>(
+    context: Context<'r, 's>,
+    mut many_matcher: M,
+    mut till_matcher: T,
+) -> impl FnMut(I) -> IResult<I, (Vec<Token<'s>>, F), E> + 'r
+where
+    I: Clone + InputLength,
+    E: ParseError<I>,
+    M: for<'x> Fn(Context<'x, 's>, I) -> IResult<I, O, E> + 'r,
+    T: for<'x> Fn(Context<'x, 's>, I) -> IResult<I, F, E> + 'r,
+    O: Into<Token<'s>>,
+{
+    move |mut i: I| {
+        // TODO: Can I eliminate the clone? I think this is incrementing the reference count
+        let mut current_context = context.clone();
+        // Despite the clone, the Rc should still point to the same value, otherwise we'll get stuck in an endless loop.
+        assert!(current_context.ptr_eq(context));
+        loop {
+            let len = i.input_len();
+            match till_matcher(&current_context, i.clone()) {
+                Ok((remaining, finish)) => {
+                    let mut ret = Vec::new();
+                    while !current_context.ptr_eq(context) {
+                        let (context_element, next_context) = current_context.pop_front();
+                        let context_element = context_element.expect("We only pop off context elements created in this function, so they are all Some()");
+                        current_context = next_context;
+                        match context_element {
+                            ContextElement::PreviousElementNode(PreviousElementNode {
+                                element: token,
+                            }) => {
+                                ret.push(token);
+                            }
+                            _ => {}
+                        };
+                    }
+                    ret.reverse();
+                    return Ok((remaining, (ret, finish)));
+                }
+                Err(nom::Err::Error(_)) => {
+                    match many_matcher(&current_context, i.clone()) {
+                        Err(nom::Err::Error(err)) => {
+                            return Err(nom::Err::Error(E::append(i, ErrorKind::ManyTill, err)))
+                        }
+                        Err(e) => return Err(e),
+                        Ok((remaining, many_elem)) => {
+                            // infinite loop check: the parser must always consume
+                            if remaining.input_len() == len {
+                                return Err(nom::Err::Error(E::from_error_kind(
+                                    remaining,
+                                    ErrorKind::ManyTill,
+                                )));
+                            }
+
+                            current_context = current_context.with_additional_node(
+                                ContextElement::PreviousElementNode(PreviousElementNode {
+                                    element: many_elem.into(),
+                                }),
+                            );
+                            i = remaining;
+                        }
+                    }
+                }
+                Err(e) => return Err(e),
+            };
+        }
+    }
+}

trash/old_document.rs

@@ -0,0 +1,29 @@
+//! A single element of text.
+use super::combinator::context_many1;
+use super::error::Res;
+use super::paragraph::paragraph;
+use super::parser_context::ContextElement;
+use super::parser_context::ContextTree;
+use super::token::Paragraph;
+use super::token::Token;
+use super::Context;
+use nom::IResult;
+
+type UnboundMatcher<'r, 's, I, O, E> = dyn Fn(Context<'r, 's>, I) -> IResult<I, O, E>;
+
+// TODO: Implement FromStr for Document
+
+pub fn document(input: &str) -> Res<&str, Vec<Paragraph>> {
+    let initial_context: ContextTree<'_, '_> = ContextTree::new();
+    let document_context =
+        initial_context.with_additional_node(ContextElement::DocumentRoot(input));
+    let (remaining, tokens) = context_many1(&document_context, paragraph)(input)?;
+    let paragraphs = tokens
+        .into_iter()
+        .map(|token| match token {
+            Token::TextElement(_) => unreachable!(),
+            Token::Paragraph(paragraph) => paragraph,
+        })
+        .collect();
+    Ok((remaining, paragraphs))
+}