A bit more refactoring in the parser

schala-lang/src/parsing/combinator.rs

@@ -120,11 +120,11 @@ fn block_comment(input: Span) -> ParseResult<()> {
         }
     }
 
-    context("Block-comment", value((), tuple((tag("/*"), inner_parser, tag("*/")))))(input)
+    context("block-comment", value((), tuple((tag("/*"), inner_parser, tag("*/")))))(input)
 }
 
 fn statement_delimiter(input: Span) -> ParseResult<()> {
-    tok(alt((value((), line_ending), value((), char(';')))))(input)
+    context("statement-delimiter", tok(alt((value((), line_ending), value((), char(';'))))))(input)
 }
 
 pub fn program(input: Span) -> ParseResult<AST> {
@@ -329,10 +329,7 @@ fn type_body(input: Span) -> ParseResult<TypeBody> {
     context(
         "type-body",
         alt((
-            map(
+            map(record_variant, move |fields| TypeBody::ImmediateRecord { id, fields }),
-                record_variant,
-                move |fields| TypeBody::ImmediateRecord { id, fields },
-            ),
             map(separated_list0(tok(char('|')), variant_spec), TypeBody::Variants),
         )),
     )(input)
@@ -343,10 +340,7 @@ fn record_variant(input: Span) -> ParseResult<Vec<(Rc<String>, TypeIdentifier)>>
         "record-variant",
         delimited(
             pair(tok(char('{')), many0(statement_delimiter)),
-            terminated(
+            terminated(separated_list1(toknl(char(',')), toknl(record_variant_item)), opt(toknl(char(',')))),
-                separated_list1(toknl(char(',')), toknl(record_variant_item)),
-                opt(toknl(char(','))),
-            ),
             pair(many0(statement_delimiter), tok(char('}'))),
         ),
     )(input)
@@ -471,8 +465,8 @@ fn operator(input: Span) -> ParseResult<BinOp> {
     context(
         "operator",
         tok(map(
-            tuple((cut(not(tag("*/"))), recognize(many1(one_of("+-*/%<>=!$&|?^`"))))),
+            preceded(cut(not(tag("*/"))), recognize(many1(one_of("+-*/%<>=!$&|?^`")))),
-            |(_, sigil_span): ((), Span)| BinOp::from_sigil(sigil_span.fragment()),
+            |sigil_span: Span| BinOp::from_sigil(sigil_span.fragment()),
         )),
     )(input)
 }
@@ -602,10 +596,13 @@ fn primary_expr_no_struct(input: Span) -> ParseResult<ExpressionKind> {
 }
 
 fn named_struct(input: Span) -> ParseResult<ExpressionKind> {
-    map(pair(qualified_identifier, record_block), |(name, fields)| ExpressionKind::NamedStruct {
+    context(
-        name,
+        "named-struct",
-        fields,
+        map(pair(qualified_identifier, record_block), |(name, fields)| ExpressionKind::NamedStruct {
-    })(input)
+            name,
+            fields,
+        }),
+    )(input)
 }
 
 //TODO support anonymous structs and Elm-style update syntax for structs
@@ -617,22 +614,29 @@ fn record_block(input: Span) -> ParseResult<Vec<(Rc<String>, Expression)>> {
 }
 
 fn lambda_expr(input: Span) -> ParseResult<ExpressionKind> {
-    alt((
+    context(
-        map(
+        "lambda-expr",
-            preceded(tok(char('\\')), tuple((formal_params, opt(type_anno), block))),
+        preceded(
-            |(params, type_anno, body)| ExpressionKind::Lambda { params, type_anno, body },
+            tok(char('\\')),
+            alt((
+                map(tuple((formal_params, opt(type_anno), block)), |(params, type_anno, body)| {
+                    ExpressionKind::Lambda { params, type_anno, body }
+                }),
+                map(tuple((formal_param, opt(type_anno), block)), |(param, type_anno, body)| {
+                    ExpressionKind::Lambda { params: vec![param], type_anno, body }
+                }),
+            )),
         ),
-        map(
+    )(input)
-            preceded(tok(char('\\')), tuple((formal_param, opt(type_anno), block))),
-            |(param, type_anno, body)| ExpressionKind::Lambda { params: vec![param], type_anno, body },
-        ),
-    ))(input)
 }
 
 fn while_expr(input: Span) -> ParseResult<ExpressionKind> {
-    map(preceded(kw("while"), pair(opt(expression_no_struct), block)), move |(condition, body)| {
+    context(
-        ExpressionKind::WhileExpression { condition: condition.map(Box::new), body }
+        "while-expr",
-    })(input)
+        map(preceded(kw("while"), pair(opt(expression_no_struct), block)), move |(condition, body)| {
+            ExpressionKind::WhileExpression { condition: condition.map(Box::new), body }
+        }),
+    )(input)
 }
 
 fn if_expr(input: Span) -> ParseResult<ExpressionKind> {
@@ -681,9 +685,12 @@ fn if_expr(input: Span) -> ParseResult<ExpressionKind> {
         alt((cond_block, simple_pattern_match, simple_conditional))(input)
     }
 
-    map(preceded(kw("if"), pair(opt(expression_no_struct), if_expr_body)), |(discriminator, body)| {
+    context(
-        ExpressionKind::IfExpression { discriminator: discriminator.map(Box::new), body: Box::new(body) }
+        "if-expr",
-    })(input)
+        map(preceded(kw("if"), pair(opt(expression_no_struct), if_expr_body)), |(discriminator, body)| {
+            ExpressionKind::IfExpression { discriminator: discriminator.map(Box::new), body: Box::new(body) }
+        }),
+    )(input)
 }
 
 fn pattern(input: Span) -> ParseResult<Pattern> {
@@ -775,9 +782,12 @@ fn for_expr(input: Span) -> ParseResult<ExpressionKind> {
         ))(input)
     }
 
-    map(preceded(kw("for"), pair(for_enumerators, for_body)), |(enumerators, body)| {
+    context(
-        ExpressionKind::ForExpression { enumerators, body }
+        "for-expr",
-    })(input)
+        map(preceded(kw("for"), pair(for_enumerators, for_body)), |(enumerators, body)| {
+            ExpressionKind::ForExpression { enumerators, body }
+        }),
+    )(input)
 }
 
 fn paren_expr(input: Span) -> ParseResult<ExpressionKind> {
@@ -852,17 +862,23 @@ fn bool_literal(input: Span) -> ParseResult<ExpressionKind> {
 }
 
 fn float_literal(input: Span) -> ParseResult<ExpressionKind> {
-    tok(map(
+    context(
-        alt((
+        "float-literal",
-            recognize(tuple((digits(digit_group_dec), char('.'), opt(digits(digit_group_dec))))),
+        tok(map(
-            recognize(tuple((char('.'), digits(digit_group_dec)))),
+            alt((
+                recognize(tuple((digits(digit_group_dec), char('.'), opt(digits(digit_group_dec))))),
+                recognize(tuple((char('.'), digits(digit_group_dec)))),
+            )),
+            |ds| ExpressionKind::FloatLiteral(ds.fragment().parse().unwrap()),
         )),
-        |ds| ExpressionKind::FloatLiteral(ds.fragment().parse().unwrap()),
+    )(input)
-    ))(input)
 }
 
 fn number_literal(input: Span) -> ParseResult<ExpressionKind> {
-    map(alt((tok(hex_literal), tok(bin_literal), tok(dec_literal))), ExpressionKind::NatLiteral)(input)
+    context(
+        "number-literal",
+        map(alt((tok(hex_literal), tok(bin_literal), tok(dec_literal))), ExpressionKind::NatLiteral),
+    )(input)
 }
 
 fn dec_literal(input: Span) -> ParseResult<u64> {