From 808c25bfa608b06b815a86c9a5bd2f75bec701c7 Mon Sep 17 00:00:00 2001
From: Rasmus Kaj <rasmus@krats.se>
Date: Mon, 3 Feb 2025 23:57:41 +0100
Subject: [PATCH] Cleaner way to ignore return value.

---
 src/expression.rs |  2 +-
 src/spacelike.rs  |  4 ++--
 src/template.rs   | 26 ++++++++++++--------------
 3 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/expression.rs b/src/expression.rs
index eb250ec..73bd32e 100644
--- a/src/expression.rs
+++ b/src/expression.rs
@@ -14,7 +14,7 @@ pub fn expression(input: &[u8]) -> PResult<&str> {
         recognize(context(
             "Expected rust expression",
             (
-                map_res(alt((tag("&"), tag("*"), tag(""))), input_to_str),
+                alt((tag("&"), tag("*"), tag(""))),
                 alt((
                     rust_name,
                     map_res(digit1, input_to_str),
diff --git a/src/spacelike.rs b/src/spacelike.rs
index 72f5ceb..e0adab5 100644
--- a/src/spacelike.rs
+++ b/src/spacelike.rs
@@ -2,13 +2,13 @@ use crate::parseresult::PResult;
 use nom::branch::alt;
 use nom::bytes::complete::{is_not, tag};
 use nom::character::complete::{multispace1, none_of};
-use nom::combinator::{map, value};
+use nom::combinator::value;
 use nom::multi::many0;
 use nom::sequence::preceded;
 use nom::Parser as _;
 
 pub fn spacelike(input: &[u8]) -> PResult<()> {
-    map(many0(alt((comment, map(multispace1, |_| ())))), |_| ()).parse(input)
+    value((), many0(alt((comment, value((), multispace1))))).parse(input)
 }
 
 pub fn comment(input: &[u8]) -> PResult<()> {
diff --git a/src/template.rs b/src/template.rs
index 0c22a77..3063a86 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -7,7 +7,7 @@ use nom::branch::alt;
 use nom::bytes::complete::is_not;
 use nom::bytes::complete::tag;
 use nom::character::complete::{char, multispace0};
-use nom::combinator::{map, map_res, opt, recognize};
+use nom::combinator::{map, map_res, opt, recognize, value};
 use nom::error::context;
 use nom::multi::{many0, many_till, separated_list0, separated_list1};
 use nom::sequence::{delimited, preceded, terminated};
@@ -152,7 +152,8 @@ fn formal_argument(input: &[u8]) -> PResult<&str> {
 }
 
 fn type_expression(input: &[u8]) -> PResult<()> {
-    map(
+    value(
+        (),
         (
             alt((tag("&"), tag(""))),
             opt(lifetime),
@@ -164,26 +165,24 @@ fn type_expression(input: &[u8]) -> PResult<()> {
             context(
                 "Expected rust type expression",
                 alt((
-                    map(rust_name, |_| ()),
-                    map(
-                        delimited(tag("["), type_expression, tag("]")),
-                        |_| (),
-                    ),
-                    map(
-                        delimited(tag("("), comma_type_expressions, tag(")")),
-                        |_| (),
+                    value((), rust_name),
+                    delimited(tag("["), value((), type_expression), tag("]")),
+                    delimited(
+                        tag("("),
+                        value((), comma_type_expressions),
+                        tag(")"),
                     ),
                 )),
             ),
             opt(delimited(tag("<"), comma_type_expressions, tag(">"))),
         ),
-        |_| (),
     )
     .parse(input)
 }
 
 pub fn comma_type_expressions(input: &[u8]) -> PResult<()> {
-    map(
+    value(
+        (),
         terminated(
             separated_list0(
                 preceded(tag(","), multispace0),
@@ -191,13 +190,12 @@ pub fn comma_type_expressions(input: &[u8]) -> PResult<()> {
             ),
             opt(preceded(tag(","), multispace0)),
         ),
-        |_| (),
     )
     .parse(input)
 }
 
 fn lifetime(input: &[u8]) -> PResult<()> {
-    map(delimited(spacelike, tag("'"), rust_name), |_| ()).parse(input)
+    delimited(spacelike, value((), tag("'")), rust_name).parse(input)
 }
 
 #[cfg(test)]