More trial and mostly error for a basic parser

src/main.rs

@@ -1,12 +1,14 @@
 use nom::{
     IResult, Parser,
-    branch::permutation,
+    branch::alt,
-    bytes::take_until,
+    bytes::complete::{tag, take_until},
-    character::{char, complete::multispace1},
+    character::complete::{line_ending, not_line_ending},
-    error::{FromExternalError, ParseError},
+    combinator::{map, success},
-    multi::{fold, many_m_n},
+    error::Error,
+    multi::fold,
     sequence::{delimited, preceded},
 };
+use std::vec::Vec;
 
 enum Fragment<'a> {
     Literal(&'a str),
@@ -15,42 +17,54 @@ enum Fragment<'a> {
 
 fn main() {
     let input = concat!(
-        "Hallo daar!\n",
+        // "Hallo daar!\n",
-        "Hoe gaat het?\n",
+        // "Hoe gaat het?\n",
         "# Met mij gaat het goed\n",
         "Met jou\n",
         "## Ja ook goed\n",
-        "Echt?\n",
+        // "Echt?\n",
-        "### Wow (not matched because we only accept 1 or 2 '#')\n",
+        // "### Wow (not matched because we only accept 1 or 2 '#')\n",
-        "#StartOfFileHeaderNoSpace <-- not matched because we require a space after '#'\n",
+        // "#StartOfFileHeaderNoSpace <-- not matched because we require a space after '#'\n",
-        "  ## Indented header\n"
+        // "  ## Indented header\n"
     );
 
-    let x = parse_string::<()>(input).unwrap();
+    let vec = Vec::<u8>::new();
-    println!("{:?}", x);
+    use nom::bytes::complete::tag;
+    use nom::sequence::preceded;
+
+    println!("{:?}", parse_fragment(input))
 }
 
-fn parse_string<'a, E>(input: &'a str) -> IResult<&'a str, String, E>
+fn parse_header<'a>(input: &'a str) -> IResult<&'a str, &str, ()> {
-where
+    delimited(tag::<&str, &str, ()>("# "), not_line_ending, line_ending).parse(input)
-    E: ParseError<&'a str> + FromExternalError<&'a str, std::num::ParseIntError>,
+}
-{
+fn parse_fragment<'a>(input: &'a str) -> IResult<&str, Fragment, ()> {
-    fold(0.., parse_header, String::new, |mut string, newstr| {
+    alt((
-        string.push_str(newstr);
+        map(parse_header, Fragment::Header),
-        string
+        map(not_line_ending, Fragment::Literal),
-    })
+    ))
     .parse(input)
 }
-fn parse_fragment<'a, E>(input: &'a str) -> IResult<&'a str, StringFragment<'a>, E>
+fn parse_string<'a>(input: &'a str) -> IResult<&'a str, Vec<Fragment<'a>>, ()> {
-where
+    fold(
-    E: ParseError<&'a str> + FromExternalError<&'a str, std::num::ParseIntError>,
+        0..,
-{
+        parse_fragment,
-    alt((map(parse_header, Fragment::Header)))
+        Vec::<u8>::new(),
-}
+        |mut vector, fragment| vector,
-
-fn parse_header<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, &'a str, E> {
-    preceded(
-        permutation((char('\n'), many_m_n(1, 2, char('#')))),
-        take_until("\n"),
     )
-    .parse(input)
 }
+
+// fn parse_fragment<'a, E>(input: &'a str) -> IResult<&'a str, StringFragment<'a>, E>
+// where
+//     E: ParseError<&'a str> + FromExternalError<&'a str, std::num::ParseIntError>,
+// {
+//     alt((map(parse_header, Fragment::Header)))
+// }
+//
+// fn parse_header<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, &'a str, E> {
+//     preceded(
+//         permutation((char('\n'), many_m_n(1, 2, char('#')))),
+//         take_until("\n"),
+//     )
+//     .parse(input)
+// }