-- |
-- Module      : AOC.Challenge.Day04
-- License     : BSD3
--
-- Stability   : experimental
-- Portability : non-portable
--
-- Day 4.  See "AOC.Solver" for the types used in this module!

module AOC.Challenge.Day04 (
    day04a
  , day04b
  ) where

import           AOC.Common            (hexDigit, decimalDigit)
import           AOC.Solver            ((:~>)(..))
import           Control.Applicative   (Const(..))
import           Control.Lens          (preview)
import           Control.Monad         ((<=<))
import           Data.Char             (isDigit, toUpper)
import           Data.Finite           (Finite)
import           Data.Functor.Identity (Identity(..))
import           Data.List.Split       (splitOn)
import           Data.Maybe            (mapMaybe)
import           Data.Monoid           (First(..))
import           Data.Monoid.OneLiner  (GMonoid(..))
import           GHC.Generics          (Generic)
import           Refined               (Refined, FromTo, SizeEqualTo, refineThrow)
import           Text.Read             (readMaybe)
import qualified Barbies               as B

type a <-> b  = Refined (FromTo a b) Int
type n ** a   = Refined (SizeEqualTo n) [a]
type FirstRaw = Const (First String)
type Raw      = Const String

data Height =
    HCm (150 <-> 193)
  | HIn ( 59 <->  76)
  deriving (Int -> Height -> ShowS
[Height] -> ShowS
Height -> [Char]
(Int -> Height -> ShowS)
-> (Height -> [Char]) -> ([Height] -> ShowS) -> Show Height
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Height] -> ShowS
$cshowList :: [Height] -> ShowS
show :: Height -> [Char]
$cshow :: Height -> [Char]
showsPrec :: Int -> Height -> ShowS
$cshowsPrec :: Int -> Height -> ShowS
Show, ReadPrec [Height]
ReadPrec Height
Int -> ReadS Height
ReadS [Height]
(Int -> ReadS Height)
-> ReadS [Height]
-> ReadPrec Height
-> ReadPrec [Height]
-> Read Height
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Height]
$creadListPrec :: ReadPrec [Height]
readPrec :: ReadPrec Height
$creadPrec :: ReadPrec Height
readList :: ReadS [Height]
$creadList :: ReadS [Height]
readsPrec :: Int -> ReadS Height
$creadsPrec :: Int -> ReadS Height
Read, Height -> Height -> Bool
(Height -> Height -> Bool)
-> (Height -> Height -> Bool) -> Eq Height
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Height -> Height -> Bool
$c/= :: Height -> Height -> Bool
== :: Height -> Height -> Bool
$c== :: Height -> Height -> Bool
Eq, Eq Height
Eq Height
-> (Height -> Height -> Ordering)
-> (Height -> Height -> Bool)
-> (Height -> Height -> Bool)
-> (Height -> Height -> Bool)
-> (Height -> Height -> Bool)
-> (Height -> Height -> Height)
-> (Height -> Height -> Height)
-> Ord Height
Height -> Height -> Bool
Height -> Height -> Ordering
Height -> Height -> Height
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Height -> Height -> Height
$cmin :: Height -> Height -> Height
max :: Height -> Height -> Height
$cmax :: Height -> Height -> Height
>= :: Height -> Height -> Bool
$c>= :: Height -> Height -> Bool
> :: Height -> Height -> Bool
$c> :: Height -> Height -> Bool
<= :: Height -> Height -> Bool
$c<= :: Height -> Height -> Bool
< :: Height -> Height -> Bool
$c< :: Height -> Height -> Bool
compare :: Height -> Height -> Ordering
$ccompare :: Height -> Height -> Ordering
Ord)

data Eye = AMB | BLU | BRN | GRY | GRN | HZL | OTH
  deriving (Int -> Eye -> ShowS
[Eye] -> ShowS
Eye -> [Char]
(Int -> Eye -> ShowS)
-> (Eye -> [Char]) -> ([Eye] -> ShowS) -> Show Eye
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Eye] -> ShowS
$cshowList :: [Eye] -> ShowS
show :: Eye -> [Char]
$cshow :: Eye -> [Char]
showsPrec :: Int -> Eye -> ShowS
$cshowsPrec :: Int -> Eye -> ShowS
Show, ReadPrec [Eye]
ReadPrec Eye
Int -> ReadS Eye
ReadS [Eye]
(Int -> ReadS Eye)
-> ReadS [Eye] -> ReadPrec Eye -> ReadPrec [Eye] -> Read Eye
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Eye]
$creadListPrec :: ReadPrec [Eye]
readPrec :: ReadPrec Eye
$creadPrec :: ReadPrec Eye
readList :: ReadS [Eye]
$creadList :: ReadS [Eye]
readsPrec :: Int -> ReadS Eye
$creadsPrec :: Int -> ReadS Eye
Read, Eye -> Eye -> Bool
(Eye -> Eye -> Bool) -> (Eye -> Eye -> Bool) -> Eq Eye
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Eye -> Eye -> Bool
$c/= :: Eye -> Eye -> Bool
== :: Eye -> Eye -> Bool
$c== :: Eye -> Eye -> Bool
Eq, Eq Eye
Eq Eye
-> (Eye -> Eye -> Ordering)
-> (Eye -> Eye -> Bool)
-> (Eye -> Eye -> Bool)
-> (Eye -> Eye -> Bool)
-> (Eye -> Eye -> Bool)
-> (Eye -> Eye -> Eye)
-> (Eye -> Eye -> Eye)
-> Ord Eye
Eye -> Eye -> Bool
Eye -> Eye -> Ordering
Eye -> Eye -> Eye
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Eye -> Eye -> Eye
$cmin :: Eye -> Eye -> Eye
max :: Eye -> Eye -> Eye
$cmax :: Eye -> Eye -> Eye
>= :: Eye -> Eye -> Bool
$c>= :: Eye -> Eye -> Bool
> :: Eye -> Eye -> Bool
$c> :: Eye -> Eye -> Bool
<= :: Eye -> Eye -> Bool
$c<= :: Eye -> Eye -> Bool
< :: Eye -> Eye -> Bool
$c< :: Eye -> Eye -> Bool
compare :: Eye -> Eye -> Ordering
$ccompare :: Eye -> Eye -> Ordering
Ord, Int -> Eye
Eye -> Int
Eye -> [Eye]
Eye -> Eye
Eye -> Eye -> [Eye]
Eye -> Eye -> Eye -> [Eye]
(Eye -> Eye)
-> (Eye -> Eye)
-> (Int -> Eye)
-> (Eye -> Int)
-> (Eye -> [Eye])
-> (Eye -> Eye -> [Eye])
-> (Eye -> Eye -> [Eye])
-> (Eye -> Eye -> Eye -> [Eye])
-> Enum Eye
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Eye -> Eye -> Eye -> [Eye]
$cenumFromThenTo :: Eye -> Eye -> Eye -> [Eye]
enumFromTo :: Eye -> Eye -> [Eye]
$cenumFromTo :: Eye -> Eye -> [Eye]
enumFromThen :: Eye -> Eye -> [Eye]
$cenumFromThen :: Eye -> Eye -> [Eye]
enumFrom :: Eye -> [Eye]
$cenumFrom :: Eye -> [Eye]
fromEnum :: Eye -> Int
$cfromEnum :: Eye -> Int
toEnum :: Int -> Eye
$ctoEnum :: Int -> Eye
pred :: Eye -> Eye
$cpred :: Eye -> Eye
succ :: Eye -> Eye
$csucc :: Eye -> Eye
Enum)

data Passport f = Passport
    { forall (f :: * -> *).
Passport f -> f (Refined (FromTo 1920 2002) Int)
pByr :: f (1920 <-> 2002)
    , forall (f :: * -> *).
Passport f -> f (Refined (FromTo 2010 2020) Int)
pIyr :: f (2010 <-> 2020)
    , forall (f :: * -> *).
Passport f -> f (Refined (FromTo 2020 2030) Int)
pEyr :: f (2020 <-> 2030)
    , forall (f :: * -> *). Passport f -> f Height
pHgt :: f Height
    , forall (f :: * -> *).
Passport f -> f (Refined (SizeEqualTo 6) [Finite 16])
pHcl :: f (6 ** Finite 16)
    , forall (f :: * -> *). Passport f -> f Eye
pEcl :: f Eye
    , forall (f :: * -> *).
Passport f -> f (Refined (SizeEqualTo 9) [Finite 10])
pPid :: f (9 ** Finite 10)
    }
  deriving ((forall x. Passport f -> Rep (Passport f) x)
-> (forall x. Rep (Passport f) x -> Passport f)
-> Generic (Passport f)
forall x. Rep (Passport f) x -> Passport f
forall x. Passport f -> Rep (Passport f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (Passport f) x -> Passport f
forall (f :: * -> *) x. Passport f -> Rep (Passport f) x
$cto :: forall (f :: * -> *) x. Rep (Passport f) x -> Passport f
$cfrom :: forall (f :: * -> *) x. Passport f -> Rep (Passport f) x
Generic)

instance B.FunctorB Passport
instance B.ApplicativeB Passport
instance B.TraversableB Passport
instance B.ConstraintsB Passport
deriving instance B.AllBF Show f Passport => Show (Passport f)
deriving via GMonoid (Passport f) instance B.AllBF Semigroup f Passport => Semigroup (Passport f)
deriving via GMonoid (Passport f) instance B.AllBF Monoid f Passport => Monoid (Passport f)

newtype Parser a = Parser { forall a. Parser a -> [Char] -> Maybe a
runParser :: String -> Maybe a }

passportParser :: Passport Parser
passportParser :: Passport Parser
passportParser = Passport :: forall (f :: * -> *).
f (Refined (FromTo 1920 2002) Int)
-> f (Refined (FromTo 2010 2020) Int)
-> f (Refined (FromTo 2020 2030) Int)
-> f Height
-> f (Refined (SizeEqualTo 6) [Finite 16])
-> f Eye
-> f (Refined (SizeEqualTo 9) [Finite 10])
-> Passport f
Passport
    { pByr :: Parser (Refined (FromTo 1920 2002) Int)
pByr = ([Char] -> Maybe (Refined (FromTo 1920 2002) Int))
-> Parser (Refined (FromTo 1920 2002) Int)
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe (Refined (FromTo 1920 2002) Int))
 -> Parser (Refined (FromTo 1920 2002) Int))
-> ([Char] -> Maybe (Refined (FromTo 1920 2002) Int))
-> Parser (Refined (FromTo 1920 2002) Int)
forall a b. (a -> b) -> a -> b
$ Int -> Maybe (Refined (FromTo 1920 2002) Int)
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow (Int -> Maybe (Refined (FromTo 1920 2002) Int))
-> ([Char] -> Maybe Int)
-> [Char]
-> Maybe (Refined (FromTo 1920 2002) Int)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe
    , pIyr :: Parser (Refined (FromTo 2010 2020) Int)
pIyr = ([Char] -> Maybe (Refined (FromTo 2010 2020) Int))
-> Parser (Refined (FromTo 2010 2020) Int)
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe (Refined (FromTo 2010 2020) Int))
 -> Parser (Refined (FromTo 2010 2020) Int))
-> ([Char] -> Maybe (Refined (FromTo 2010 2020) Int))
-> Parser (Refined (FromTo 2010 2020) Int)
forall a b. (a -> b) -> a -> b
$ Int -> Maybe (Refined (FromTo 2010 2020) Int)
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow (Int -> Maybe (Refined (FromTo 2010 2020) Int))
-> ([Char] -> Maybe Int)
-> [Char]
-> Maybe (Refined (FromTo 2010 2020) Int)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe
    , pEyr :: Parser (Refined (FromTo 2020 2030) Int)
pEyr = ([Char] -> Maybe (Refined (FromTo 2020 2030) Int))
-> Parser (Refined (FromTo 2020 2030) Int)
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe (Refined (FromTo 2020 2030) Int))
 -> Parser (Refined (FromTo 2020 2030) Int))
-> ([Char] -> Maybe (Refined (FromTo 2020 2030) Int))
-> Parser (Refined (FromTo 2020 2030) Int)
forall a b. (a -> b) -> a -> b
$ Int -> Maybe (Refined (FromTo 2020 2030) Int)
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow (Int -> Maybe (Refined (FromTo 2020 2030) Int))
-> ([Char] -> Maybe Int)
-> [Char]
-> Maybe (Refined (FromTo 2020 2030) Int)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe
    , pHgt :: Parser Height
pHgt = ([Char] -> Maybe Height) -> Parser Height
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe Height) -> Parser Height)
-> ([Char] -> Maybe Height) -> Parser Height
forall a b. (a -> b) -> a -> b
$ \[Char]
str ->
                let ([Char]
x, [Char]
u) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Char -> Bool
isDigit [Char]
str
                in  case [Char]
u of
                      [Char]
"cm" -> ((150 <-> 193) -> Height) -> Maybe (150 <-> 193) -> Maybe Height
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (150 <-> 193) -> Height
HCm (Maybe (150 <-> 193) -> Maybe Height)
-> (Int -> Maybe (150 <-> 193)) -> Int -> Maybe Height
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Maybe (150 <-> 193)
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow (Int -> Maybe Height) -> Maybe Int -> Maybe Height
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
x
                      [Char]
"in" -> ((59 <-> 76) -> Height) -> Maybe (59 <-> 76) -> Maybe Height
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (59 <-> 76) -> Height
HIn (Maybe (59 <-> 76) -> Maybe Height)
-> (Int -> Maybe (59 <-> 76)) -> Int -> Maybe Height
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Maybe (59 <-> 76)
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow (Int -> Maybe Height) -> Maybe Int -> Maybe Height
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
x
                      [Char]
_    -> Maybe Height
forall a. Maybe a
Nothing
    , pHcl :: Parser (Refined (SizeEqualTo 6) [Finite 16])
pHcl = ([Char] -> Maybe (Refined (SizeEqualTo 6) [Finite 16]))
-> Parser (Refined (SizeEqualTo 6) [Finite 16])
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe (Refined (SizeEqualTo 6) [Finite 16]))
 -> Parser (Refined (SizeEqualTo 6) [Finite 16]))
-> ([Char] -> Maybe (Refined (SizeEqualTo 6) [Finite 16]))
-> Parser (Refined (SizeEqualTo 6) [Finite 16])
forall a b. (a -> b) -> a -> b
$ \case
                Char
'#':[Char]
n -> [Finite 16] -> Maybe (Refined (SizeEqualTo 6) [Finite 16])
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow ([Finite 16] -> Maybe (Refined (SizeEqualTo 6) [Finite 16]))
-> Maybe [Finite 16] -> Maybe (Refined (SizeEqualTo 6) [Finite 16])
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Char -> Maybe (Finite 16)) -> [Char] -> Maybe [Finite 16]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Getting (First (Finite 16)) Char (Finite 16)
-> Char -> Maybe (Finite 16)
forall s (m :: * -> *) a.
MonadReader s m =>
Getting (First a) s a -> m (Maybe a)
preview Getting (First (Finite 16)) Char (Finite 16)
Prism' Char (Finite 16)
hexDigit) [Char]
n
                [Char]
_     -> Maybe (Refined (SizeEqualTo 6) [Finite 16])
forall a. Maybe a
Nothing
    , pEcl :: Parser Eye
pEcl = ([Char] -> Maybe Eye) -> Parser Eye
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe Eye) -> Parser Eye)
-> ([Char] -> Maybe Eye) -> Parser Eye
forall a b. (a -> b) -> a -> b
$ [Char] -> Maybe Eye
forall a. Read a => [Char] -> Maybe a
readMaybe ([Char] -> Maybe Eye) -> ShowS -> [Char] -> Maybe Eye
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper
    , pPid :: Parser (Refined (SizeEqualTo 9) [Finite 10])
pPid = ([Char] -> Maybe (Refined (SizeEqualTo 9) [Finite 10]))
-> Parser (Refined (SizeEqualTo 9) [Finite 10])
forall a. ([Char] -> Maybe a) -> Parser a
Parser (([Char] -> Maybe (Refined (SizeEqualTo 9) [Finite 10]))
 -> Parser (Refined (SizeEqualTo 9) [Finite 10]))
-> ([Char] -> Maybe (Refined (SizeEqualTo 9) [Finite 10]))
-> Parser (Refined (SizeEqualTo 9) [Finite 10])
forall a b. (a -> b) -> a -> b
$ [Finite 10] -> Maybe (Refined (SizeEqualTo 9) [Finite 10])
forall p x (m :: * -> *).
(Predicate p x, MonadThrow m) =>
x -> m (Refined p x)
refineThrow ([Finite 10] -> Maybe (Refined (SizeEqualTo 9) [Finite 10]))
-> ([Char] -> Maybe [Finite 10])
-> [Char]
-> Maybe (Refined (SizeEqualTo 9) [Finite 10])
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (Char -> Maybe (Finite 10)) -> [Char] -> Maybe [Finite 10]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Getting (First (Finite 10)) Char (Finite 10)
-> Char -> Maybe (Finite 10)
forall s (m :: * -> *) a.
MonadReader s m =>
Getting (First a) s a -> m (Maybe a)
preview Getting (First (Finite 10)) Char (Finite 10)
Prism' Char (Finite 10)
decimalDigit)
    }

loadPassportField :: String -> Passport FirstRaw
loadPassportField :: [Char] -> Passport (Const (First [Char]))
loadPassportField [Char]
str = case [Char] -> [Char] -> [[Char]]
forall a. Eq a => [a] -> [a] -> [[a]]
splitOn [Char]
":" [Char]
str of
    [[Char]
k,[Char]
v] -> case [Char]
k of
      [Char]
"byr" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pByr :: Const (First [Char]) (Refined (FromTo 1920 2002) Int)
pByr = First [Char]
-> Const (First [Char]) (Refined (FromTo 1920 2002) Int)
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
"iyr" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pIyr :: Const (First [Char]) (Refined (FromTo 2010 2020) Int)
pIyr = First [Char]
-> Const (First [Char]) (Refined (FromTo 2010 2020) Int)
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
"eyr" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pEyr :: Const (First [Char]) (Refined (FromTo 2020 2030) Int)
pEyr = First [Char]
-> Const (First [Char]) (Refined (FromTo 2020 2030) Int)
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
"hgt" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pHgt :: Const (First [Char]) Height
pHgt = First [Char] -> Const (First [Char]) Height
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
"hcl" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pHcl :: Const (First [Char]) (Refined (SizeEqualTo 6) [Finite 16])
pHcl = First [Char]
-> Const (First [Char]) (Refined (SizeEqualTo 6) [Finite 16])
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
"ecl" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pEcl :: Const (First [Char]) Eye
pEcl = First [Char] -> Const (First [Char]) Eye
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
"pid" -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty { pPid :: Const (First [Char]) (Refined (SizeEqualTo 9) [Finite 10])
pPid = First [Char]
-> Const (First [Char]) (Refined (SizeEqualTo 9) [Finite 10])
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> First [Char]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
v) }
      [Char]
_     -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty
    [[Char]]
_     -> Passport (Const (First [Char]))
forall a. Monoid a => a
mempty

loadPassport :: String -> Maybe (Passport Raw)
loadPassport :: [Char] -> Maybe (Passport Raw)
loadPassport = (forall a. FirstRaw a -> Maybe (Raw a))
-> Passport (Const (First [Char])) -> Maybe (Passport Raw)
forall k (b :: (k -> *) -> *) (e :: * -> *) (f :: k -> *)
       (g :: k -> *).
(TraversableB b, Applicative e) =>
(forall (a :: k). f a -> e (g a)) -> b f -> e (b g)
B.btraverse (\(Const (First Maybe [Char]
x)) -> [Char] -> Raw a
forall {k} a (b :: k). a -> Const a b
Const ([Char] -> Raw a) -> Maybe [Char] -> Maybe (Raw a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Char]
x)
             (Passport (Const (First [Char])) -> Maybe (Passport Raw))
-> ([Char] -> Passport (Const (First [Char])))
-> [Char]
-> Maybe (Passport Raw)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Passport (Const (First [Char])))
-> [[Char]] -> Passport (Const (First [Char]))
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap [Char] -> Passport (Const (First [Char]))
loadPassportField
             ([[Char]] -> Passport (Const (First [Char])))
-> ([Char] -> [[Char]])
-> [Char]
-> Passport (Const (First [Char]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words

parsePassportField :: String -> Passport First
parsePassportField :: [Char] -> Passport First
parsePassportField = (forall a. Parser a -> FirstRaw a -> First a)
-> Passport Parser
-> Passport (Const (First [Char]))
-> Passport First
forall {k} (b :: (k -> *) -> *) (f :: k -> *) (g :: k -> *)
       (h :: k -> *).
ApplicativeB b =>
(forall (a :: k). f a -> g a -> h a) -> b f -> b g -> b h
B.bzipWith forall a. Parser a -> FirstRaw a -> First a
forall {k} {a} {b :: k}.
Parser a -> Const (First [Char]) b -> First a
go Passport Parser
passportParser (Passport (Const (First [Char])) -> Passport First)
-> ([Char] -> Passport (Const (First [Char])))
-> [Char]
-> Passport First
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Passport (Const (First [Char]))
loadPassportField
  where
    go :: Parser a -> Const (First [Char]) b -> First a
go Parser a
p (Const (First Maybe [Char]
x)) = Maybe a -> First a
forall a. Maybe a -> First a
First (Maybe a -> First a) -> Maybe a -> First a
forall a b. (a -> b) -> a -> b
$ Parser a -> [Char] -> Maybe a
forall a. Parser a -> [Char] -> Maybe a
runParser Parser a
p ([Char] -> Maybe a) -> Maybe [Char] -> Maybe a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe [Char]
x

parsePassport :: String -> Maybe (Passport Identity)
parsePassport :: [Char] -> Maybe (Passport Identity)
parsePassport = (forall a. First a -> Maybe (Identity a))
-> Passport First -> Maybe (Passport Identity)
forall k (b :: (k -> *) -> *) (e :: * -> *) (f :: k -> *)
       (g :: k -> *).
(TraversableB b, Applicative e) =>
(forall (a :: k). f a -> e (g a)) -> b f -> e (b g)
B.btraverse ((a -> Identity a) -> Maybe a -> Maybe (Identity a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Identity a
forall a. a -> Identity a
Identity (Maybe a -> Maybe (Identity a))
-> (First a -> Maybe a) -> First a -> Maybe (Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. First a -> Maybe a
forall a. First a -> Maybe a
getFirst)
              (Passport First -> Maybe (Passport Identity))
-> ([Char] -> Passport First)
-> [Char]
-> Maybe (Passport Identity)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Passport First) -> [[Char]] -> Passport First
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap [Char] -> Passport First
parsePassportField
              ([[Char]] -> Passport First)
-> ([Char] -> [[Char]]) -> [Char] -> Passport First
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words

day04a :: [String] :~> Int
day04a :: [[Char]] :~> Int
day04a = MkSol :: forall a b.
([Char] -> Maybe a)
-> ((?dyno::DynoMap) => a -> Maybe b) -> (b -> [Char]) -> a :~> b
MkSol
    { sParse :: [Char] -> Maybe [[Char]]
sParse = [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just ([[Char]] -> Maybe [[Char]])
-> ([Char] -> [[Char]]) -> [Char] -> Maybe [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [[Char]]
forall a. Eq a => [a] -> [a] -> [[a]]
splitOn [Char]
"\n\n"
    , sShow :: Int -> [Char]
sShow  = Int -> [Char]
forall a. Show a => a -> [Char]
show
    , sSolve :: (?dyno::DynoMap) => [[Char]] -> Maybe Int
sSolve = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> ([[Char]] -> Int) -> [[Char]] -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Passport Raw] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Passport Raw] -> Int)
-> ([[Char]] -> [Passport Raw]) -> [[Char]] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Maybe (Passport Raw)) -> [[Char]] -> [Passport Raw]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe [Char] -> Maybe (Passport Raw)
loadPassport
    }

day04b :: [String] :~> Int
day04b :: [[Char]] :~> Int
day04b = MkSol :: forall a b.
([Char] -> Maybe a)
-> ((?dyno::DynoMap) => a -> Maybe b) -> (b -> [Char]) -> a :~> b
MkSol
    { sParse :: [Char] -> Maybe [[Char]]
sParse = [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just ([[Char]] -> Maybe [[Char]])
-> ([Char] -> [[Char]]) -> [Char] -> Maybe [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [[Char]]
forall a. Eq a => [a] -> [a] -> [[a]]
splitOn [Char]
"\n\n"
    , sShow :: Int -> [Char]
sShow  = Int -> [Char]
forall a. Show a => a -> [Char]
show
    , sSolve :: (?dyno::DynoMap) => [[Char]] -> Maybe Int
sSolve = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> ([[Char]] -> Int) -> [[Char]] -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Passport Identity] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Passport Identity] -> Int)
-> ([[Char]] -> [Passport Identity]) -> [[Char]] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Maybe (Passport Identity))
-> [[Char]] -> [Passport Identity]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe [Char] -> Maybe (Passport Identity)
parsePassport
    }