Make concat also work on lists of bytes.

Unfortunately this requires manually writing out the mapped function
into the resulting parser, as the `join` method needs to be bound to
the same type as the elements to be joined. Because these elements can
be an empty list, this type needs to be inferred from the type of the
input stream.

Author: jap

src/parsy/__init__.py

@@ -166,10 +166,23 @@ def combine_dict(self, combine_fn: Callable) -> Parser:
 
     def concat(self) -> Parser:
         """
-        Returns a parser that concatenates together (as a string) the previously
-        produced values.
+        Returns a parser that concatenates together the previously produced values.
+
+        This parser will join the values using the type of the input stream, so
+        when feeding bytes to the parser, the items to be joined must also be bytes.
         """
-        return self.map("".join)
+
+        @Parser
+        def parser(stream: bytes | str, index: int) -> Result:
+            joiner = type(stream)()
+            result = self(stream, index)
+            if result.status:
+                next_parser: Parser = success(joiner.join(result.value))
+                return next_parser(stream, result.index).aggregate(result)
+            else:
+                return result
+
+        return parser
 
     def then(self, other: Parser) -> Parser:
         """

tests/test_parsy.py

@@ -157,11 +157,16 @@ def test_combine_dict_skip_underscores(self):
         ).combine_dict(Pair)
         self.assertEqual(parser.parse("ABC   123"), Pair(word="ABC", number=123))
 
-    def test_concat(self):
+    def test_concat_str(self):
         parser = letter.many().concat()
         self.assertEqual(parser.parse(""), "")
         self.assertEqual(parser.parse("abc"), "abc")
 
+    def test_concat_bytes(self):
+        parser = any_char.many().concat()
+        self.assertEqual(parser.parse(b""), b"")
+        self.assertEqual(parser.parse(b"abc"), b"abc")
+
     def test_generate(self):
         x = y = None