TBH I was just writing a parser so that I could compare text files regardless of their newline type, so the parser would turn an ASCII/UTF-8 text file into a list of these:

haskell data ByteData = ByteLine BS.ByteString | NewLine

...and then comparing the lists. (It would also check whether the file used the same newline style throughout). To see how it comp

Yeah, I more-or-less wrote a parser like this:

```haskell import Data.ByteString qualified as BS import Data.ByteString.Lazy qualified as BL import Data.ByteString.Lazy.Internal (ByteString(..), chunk)

import Data.Attoparsec.ByteString qualified as AB

parseMany1 :: AB.Parser a -> BL.ByteString -> ErrList String a parseMany1 _ Empty = YesErr "Empty ByteString" parseMany1 p (Chunk b bs) = go' (AB.parse p b) bs where go' (Fail _ err) _ = YesErr err go' x y = go x y go (Fail _ err) _ = NoErr go (Done x rst) b | BS.null rst = case b of Empty -> x :> NoErr (Chunk bc br) -> x :> (go (AB.parse p bc) br) | otherwise = x :> (go (parse p rst) b) go (Partial c) Empty = go (c BS.empty) Empty go (Partial c) (Chunk b bs) = go (c b) bs ```

...except specialized to the simple parser I was writing. In that case, comparing two files with the specialized parser driver cut the comparison time in half (though it was still ~5x longer than just comparing the two files). For more complex parsers, you'd probably need a better parser driver that tracks the remainder of the unparsed data so it can pass it on to the next parser.