Use lazy text for test outputs

Simplifies encoding code slightly, and potentially saves a lot of time for failing tests. Plus we've always been using `T.show` in practice anyway, so it's an easy change to make.

haskell/Main.hs

@@ -4,8 +4,8 @@ import Data.Bool
 import Data.ByteString.Lazy qualified as BL
 import Data.Functor
 import Data.List.Extra
-import Data.Text.Encoding (encodeUtf8)
 import Data.Text.IO qualified as T
+import Data.Text.Lazy.Encoding (encodeUtf8)
 import Puzzle
 import Puzzles.Day1 qualified as Day1
 import Puzzles.Day2 qualified as Day2
@@ -40,6 +40,6 @@ main =
                                 testGroup pt $
                                     ( zip (map show [1 :: Int ..]) parts <&> \(n, pp) ->
                                         goldenVsString n ("../outputs/" <> t <> "/" <> pt <> "/" <> n) $
-                                            BL.fromStrict . encodeUtf8 . pp <$> input
+                                            encodeUtf8 . pp <$> input
                                     )
                                         <> [testGroup "extra" $ extraTests isRealData ("../outputs/" <> t <> "/" <> pt <> "/extra/") input]

haskell/Puzzle.hs

@@ -1,6 +1,7 @@
 module Puzzle where
 
 import Data.Text (Text)
+import Data.Text.Lazy qualified as TL
 import Data.Void
 import Test.Tasty
 import Text.Megaparsec
@@ -8,6 +9,6 @@ import Text.Megaparsec
 data Puzzle = forall input. Puzzle
     { number :: Word
     , parser :: Parsec Void Text input
-    , parts :: [input -> Text]
+    , parts :: [input -> TL.Text]
     , extraTests :: Bool -> FilePath -> IO input -> [TestTree]
     }

haskell/Puzzles/Day1.hs

@@ -3,7 +3,7 @@ module Puzzles.Day1 (puzzle) where
 import Control.Monad.State
 import Data.Bifunctor
 import Data.Functor
-import Data.Text qualified as T
+import Data.Text.Lazy qualified as TL
 import Puzzle
 import Text.Megaparsec hiding (Pos)
 import Text.Megaparsec.Char
@@ -15,14 +15,14 @@ puzzle =
         { number = 1
         , parser = flip sepEndBy newline $ (,) <$> ((char 'L' $> L) <|> (char 'R' $> R)) <*> (Inc <$> Lex.decimal)
         , parts =
-            [ T.show
+            [ TL.show
                 . sum
                 . flip evalState 50
                 . traverse \(d, i) -> do
                     modify $ snd . step i d
                     p' <- get
                     pure $ Count if p' == 0 then 1 else 0
-            , T.show
+            , TL.show
                 . sum
                 . flip evalState 50
                 . traverse \(d, i) -> do

haskell/Puzzles/Day2.hs

@@ -5,6 +5,7 @@ import Data.Functor
 import Data.Maybe
 import Data.Text (Text)
 import Data.Text qualified as T
+import Data.Text.Lazy qualified as TL
 import Puzzle
 import Text.Megaparsec
 import Text.Megaparsec.Char
@@ -16,11 +17,11 @@ puzzle =
         { number = 2
         , parser = (<* newline) $ flip sepBy (char ',') $ (,) <$> (Lex.decimal <* char '-') <*> Lex.decimal
         , parts =
-            [ T.show
+            [ TL.show
                 . sum
                 . concatMap
                     (mapMaybe (\n -> guard (isRepetition2 n) $> n) . uncurry enumFromTo)
-            , T.show
+            , TL.show
                 . sum
                 . concatMap
                     (mapMaybe (\n -> guard (isRepetitionN n) $> n) . uncurry enumFromTo)

haskell/Puzzles/Day3.hs

@@ -7,7 +7,7 @@ import Data.List.Extra (dropEnd)
 import Data.List.NonEmpty (NonEmpty ((:|)), nonEmpty, some1)
 import Data.List.NonEmpty qualified as NE
 import Data.Maybe
-import Data.Text qualified as T
+import Data.Text.Lazy qualified as TL
 import Data.Word
 import Puzzle
 import Text.Megaparsec
@@ -19,10 +19,10 @@ puzzle =
         { number = 3
         , parser = flip sepEndBy newline $ Bank . fmap (fromIntegral . digitToInt) <$> some1 digitChar
         , parts =
-            [ T.show
+            [ TL.show
                 . sum
                 . map (digitsToInt . fromMaybe (error "battery list too short") . maxBatteries 2)
-            , T.show
+            , TL.show
                 . sum
                 . map (digitsToInt . fromMaybe (error "battery list too short") . maxBatteries 12)
             ]

haskell/Puzzles/Day4.hs

@@ -7,6 +7,7 @@ import Data.Functor
 import Data.List.Extra
 import Data.Sequence qualified as Seq
 import Data.Text qualified as T
+import Data.Text.Lazy qualified as TL
 import Linear
 import Puzzle
 import Text.Megaparsec hiding (some)
@@ -18,11 +19,11 @@ puzzle =
         { number = 4
         , parser = flip sepEndBy newline $ some $ asum $ enumerate <&> \t -> char (inToChar t) $> t
         , parts =
-            [ T.show
+            [ TL.show
                 . fst
                 . findAccessible
                 . addCoords
-            , T.show
+            , TL.show
                 . sum
                 . unfoldr ((\r -> guard (fst r /= 0) $> r) . (removeAccessibleRolls <<<<$>>>>) . findAccessible)
                 . addCoords