module Data.Time.RRule.Parse
  ( parseRRule
  )
where

import Prelude hiding (until)
import Control.Monad (msum)
import qualified Control.Monad.Combinators.NonEmpty as NE
import Data.List.NonEmpty (NonEmpty(..))
import Data.Maybe (fromMaybe, catMaybes, isJust)
import Data.Text (Text, intercalate, pack, unpack)
import Data.Time.Clock (UTCTime)
import Data.Time.Format (parseTimeM, defaultTimeLocale)
import Data.Time.RRule.Types (defaultRRule, RRule(..), Day(..), Frequency(..), ToRRule)
import Text.Megaparsec hiding (count)
import Text.Megaparsec.Char.Lexer

type Parser = Parsec () Text

parseRRule :: Parser RRule
parseRRule :: Parser RRule
parseRRule = do
  Maybe Text
prefixText <- ParsecT () Text Identity (Maybe Text)
-> ParsecT () Text Identity (Maybe Text)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ParsecT () Text Identity (Maybe Text)
 -> ParsecT () Text Identity (Maybe Text))
-> (ParsecT () Text Identity Text
    -> ParsecT () Text Identity (Maybe Text))
-> ParsecT () Text Identity Text
-> ParsecT () Text Identity (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParsecT () Text Identity Text
-> ParsecT () Text Identity (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT () Text Identity Text
 -> ParsecT () Text Identity (Maybe Text))
-> ParsecT () Text Identity Text
-> ParsecT () Text Identity (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"RRULE:"
  [RRule]
rules <- Parser RRule
parseVariable Parser RRule
-> ParsecT () Text Identity Char
-> ParsecT () Text Identity [RRule]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepBy` Token Text -> ParsecT () Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
Token Text
';'
  let allRules :: RRule
allRules = (RRule -> RRule -> RRule) -> RRule -> [RRule] -> RRule
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr RRule -> RRule -> RRule
combineRules RRule
defaultRRule [RRule]
rules
  RRule -> Parser RRule
forall (m :: * -> *) a. Monad m => a -> m a
return RRule
allRules { prefix :: Bool
prefix = Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
prefixText }

combineRules :: RRule -> RRule -> RRule
combineRules :: RRule -> RRule -> RRule
combineRules RRule
r RRule
s = RRule :: Bool
-> Maybe Day
-> Maybe Frequency
-> Maybe Int
-> Maybe UTCTime
-> Maybe Int
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty (Int, Day))
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> RRule
RRule
  { prefix :: Bool
prefix     = RRule -> Bool
prefix RRule
r Bool -> Bool -> Bool
|| RRule -> Bool
prefix RRule
s
  , weekStart :: Maybe Day
weekStart  = (RRule -> Maybe Day) -> Maybe Day
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe Day
weekStart
  , frequency :: Maybe Frequency
frequency  = (RRule -> Maybe Frequency) -> Maybe Frequency
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe Frequency
frequency
  , count :: Maybe Int
count      = (RRule -> Maybe Int) -> Maybe Int
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe Int
count
  , until :: Maybe UTCTime
until      = (RRule -> Maybe UTCTime) -> Maybe UTCTime
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe UTCTime
until
  , interval :: Maybe Int
interval   = (RRule -> Maybe Int) -> Maybe Int
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe Int
interval
  , bySecond :: Maybe (NonEmpty Int)
bySecond   = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
bySecond
  , byMinute :: Maybe (NonEmpty Int)
byMinute   = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
byMinute
  , byHour :: Maybe (NonEmpty Int)
byHour     = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
byHour
  , byDay :: Maybe (NonEmpty (Int, Day))
byDay      = (RRule -> Maybe (NonEmpty (Int, Day)))
-> Maybe (NonEmpty (Int, Day))
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty (Int, Day))
byDay
  , byWeekNo :: Maybe (NonEmpty Int)
byWeekNo   = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
byWeekNo
  , byMonth :: Maybe (NonEmpty Int)
byMonth    = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
byMonth
  , byMonthDay :: Maybe (NonEmpty Int)
byMonthDay = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
byMonthDay
  , byYearDay :: Maybe (NonEmpty Int)
byYearDay  = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
byYearDay
  , bySetPos :: Maybe (NonEmpty Int)
bySetPos   = (RRule -> Maybe (NonEmpty Int)) -> Maybe (NonEmpty Int)
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe (NonEmpty Int)
bySetPos
  }
  where combine :: (RRule -> m a) -> m a
combine RRule -> m a
f = [m a] -> m a
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum [RRule -> m a
f RRule
r, RRule -> m a
f RRule
s]

parseVariable :: Parser RRule
parseVariable :: Parser RRule
parseVariable = do
  let prefix :: Bool
prefix = Bool
False
  Maybe Day
weekStart  <- Text -> Parser Day -> Parser (Maybe Day)
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"WKST"       Parser Day
parseDay
  Maybe Frequency
frequency  <- Text -> Parser Frequency -> Parser (Maybe Frequency)
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"FREQ"       Parser Frequency
parseFrequency
  Maybe Int
count      <- Text -> Parser Int -> Parser (Maybe Int)
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"COUNT"      Parser Int
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
decimal
  Maybe UTCTime
until      <- Text -> Parser UTCTime -> Parser (Maybe UTCTime)
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"UNTIL"      Parser UTCTime
parseUtcTime
  Maybe Int
interval   <- Text -> Parser Int -> Parser (Maybe Int)
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"INTERVAL"   Parser Int
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
decimal
  Maybe (NonEmpty Int)
bySecond   <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYSECOND"   Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty Int)
byMinute   <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYMINUTE"   Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty Int)
byHour     <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYHOUR"     Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty (Int, Day))
byDay      <- Text
-> Parser (NonEmpty (Int, Day))
-> Parser (Maybe (NonEmpty (Int, Day)))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYDAY"      Parser (NonEmpty (Int, Day))
parseSomeDay
  Maybe (NonEmpty Int)
byWeekNo   <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYWEEKNO"   Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty Int)
byMonthDay <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYMONTHDAY" Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty Int)
byMonth    <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYMONTH"    Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty Int)
byYearDay  <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYYEARDAY"  Parser (NonEmpty Int)
parseSomeInt
  Maybe (NonEmpty Int)
bySetPos   <- Text -> Parser (NonEmpty Int) -> Parser (Maybe (NonEmpty Int))
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"BYSETPOS"   Parser (NonEmpty Int)
parseSomeInt
  RRule -> Parser RRule
forall (m :: * -> *) a. Monad m => a -> m a
return RRule :: Bool
-> Maybe Day
-> Maybe Frequency
-> Maybe Int
-> Maybe UTCTime
-> Maybe Int
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty (Int, Day))
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> Maybe (NonEmpty Int)
-> RRule
RRule{Bool
Maybe Int
Maybe (NonEmpty Int)
Maybe (NonEmpty (Int, Day))
Maybe UTCTime
Maybe Day
Maybe Frequency
bySetPos :: Maybe (NonEmpty Int)
byYearDay :: Maybe (NonEmpty Int)
byMonth :: Maybe (NonEmpty Int)
byMonthDay :: Maybe (NonEmpty Int)
byWeekNo :: Maybe (NonEmpty Int)
byDay :: Maybe (NonEmpty (Int, Day))
byHour :: Maybe (NonEmpty Int)
byMinute :: Maybe (NonEmpty Int)
bySecond :: Maybe (NonEmpty Int)
interval :: Maybe Int
until :: Maybe UTCTime
count :: Maybe Int
frequency :: Maybe Frequency
weekStart :: Maybe Day
prefix :: Bool
bySetPos :: Maybe (NonEmpty Int)
byYearDay :: Maybe (NonEmpty Int)
byMonthDay :: Maybe (NonEmpty Int)
byMonth :: Maybe (NonEmpty Int)
byWeekNo :: Maybe (NonEmpty Int)
byDay :: Maybe (NonEmpty (Int, Day))
byHour :: Maybe (NonEmpty Int)
byMinute :: Maybe (NonEmpty Int)
bySecond :: Maybe (NonEmpty Int)
interval :: Maybe Int
until :: Maybe UTCTime
count :: Maybe Int
frequency :: Maybe Frequency
weekStart :: Maybe Day
prefix :: Bool
..}

parseVar :: Text -> Parser a -> Parser (Maybe a)
parseVar :: Text -> Parser a -> Parser (Maybe a)
parseVar Text
label Parser a
parse = Parser (Maybe a) -> Parser (Maybe a)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (Maybe a) -> Parser (Maybe a))
-> (Parser a -> Parser (Maybe a)) -> Parser a -> Parser (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser a -> Parser (Maybe a)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser a -> Parser (Maybe a)) -> Parser a -> Parser (Maybe a)
forall a b. (a -> b) -> a -> b
$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Text
Tokens Text
label ParsecT () Text Identity Text
-> ParsecT () Text Identity Char -> ParsecT () Text Identity Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Token Text -> ParsecT () Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
Token Text
'=' ParsecT () Text Identity Char -> Parser a -> Parser a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser a
parse

parseSomeInt :: Parser (NonEmpty Int)
parseSomeInt :: Parser (NonEmpty Int)
parseSomeInt = Parser Int
parseInt Parser Int
-> ParsecT () Text Identity Char -> Parser (NonEmpty Int)
forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
`NE.sepBy1` Token Text -> ParsecT () Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
Token Text
','

parseSomeDay :: Parser (NonEmpty (Int, Day))
parseSomeDay :: Parser (NonEmpty (Int, Day))
parseSomeDay = Parser (Int, Day)
parseIntDay Parser (Int, Day)
-> ParsecT () Text Identity Char -> Parser (NonEmpty (Int, Day))
forall (m :: * -> *) a sep.
MonadPlus m =>
m a -> m sep -> m (NonEmpty a)
`NE.sepBy1` Token Text -> ParsecT () Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
Token Text
','

parseInt :: Parser Int
parseInt :: Parser Int
parseInt = do
  Maybe Char
sign <- ParsecT () Text Identity (Maybe Char)
-> ParsecT () Text Identity (Maybe Char)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ParsecT () Text Identity (Maybe Char)
 -> ParsecT () Text Identity (Maybe Char))
-> (ParsecT () Text Identity Char
    -> ParsecT () Text Identity (Maybe Char))
-> ParsecT () Text Identity Char
-> ParsecT () Text Identity (Maybe Char)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParsecT () Text Identity Char
-> ParsecT () Text Identity (Maybe Char)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT () Text Identity Char
 -> ParsecT () Text Identity (Maybe Char))
-> ParsecT () Text Identity Char
-> ParsecT () Text Identity (Maybe Char)
forall a b. (a -> b) -> a -> b
$ Token Text -> ParsecT () Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
Token Text
'-'
  Int
d <- Parser Int
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
decimal
  Int -> Parser Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Parser Int) -> Int -> Parser Int
forall a b. (a -> b) -> a -> b
$ if Maybe Char -> Bool
forall a. Maybe a -> Bool
isJust Maybe Char
sign then (Int -> Int
forall a. Num a => a -> a
negate Int
d) else Int
d

parseIntDay :: Parser (Int, Day)
parseIntDay :: Parser (Int, Day)
parseIntDay = do
  Maybe Int
n <- Parser (Maybe Int) -> Parser (Maybe Int)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (Maybe Int) -> Parser (Maybe Int))
-> (Parser Int -> Parser (Maybe Int))
-> Parser Int
-> Parser (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser Int -> Parser (Maybe Int))
-> Parser Int -> Parser (Maybe Int)
forall a b. (a -> b) -> a -> b
$ Parser Int
parseInt
  Day
d <- Parser Day
parseDay
  (Int, Day) -> Parser (Int, Day)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 Maybe Int
n, Day
d)

parseUtcTime :: Parser UTCTime
parseUtcTime :: Parser UTCTime
parseUtcTime = do
  [Char]
d <- ParsecT () Text Identity Char
-> ParsecT () Text Identity Char -> ParsecT () Text Identity [Char]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
manyTill ParsecT () Text Identity Char
forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle (Token Text -> ParsecT () Text Identity (Token Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
Token Text
'Z')
  Bool -> TimeLocale -> [Char] -> [Char] -> Parser UTCTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> [Char] -> [Char] -> m t
parseTimeM Bool
False TimeLocale
defaultTimeLocale [Char]
"%Y%m%dT%H%M%S" [Char]
d

parseFrequency :: Parser Frequency
parseFrequency :: Parser Frequency
parseFrequency =
  Frequency
Secondly Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"SECONDLY" Parser Frequency -> Parser Frequency -> Parser Frequency
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Frequency
Minutely Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"MINUTELY" Parser Frequency -> Parser Frequency -> Parser Frequency
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Frequency
Hourly   Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"HOURLY"   Parser Frequency -> Parser Frequency -> Parser Frequency
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Frequency
Daily    Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"DAILY"    Parser Frequency -> Parser Frequency -> Parser Frequency
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Frequency
Weekly   Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"WEEKLY"   Parser Frequency -> Parser Frequency -> Parser Frequency
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Frequency
Monthly  Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"MONTHLY"  Parser Frequency -> Parser Frequency -> Parser Frequency
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Frequency
Yearly   Frequency -> ParsecT () Text Identity Text -> Parser Frequency
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"YEARLY"

parseDay :: Parser Day
parseDay :: Parser Day
parseDay =
  Day
Sunday    Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"SU" Parser Day -> Parser Day -> Parser Day
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Day
Monday    Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"MO" Parser Day -> Parser Day -> Parser Day
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Day
Tuesday   Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"TU" Parser Day -> Parser Day -> Parser Day
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Day
Wednesday Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"WE" Parser Day -> Parser Day -> Parser Day
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Day
Thursday  Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"TH" Parser Day -> Parser Day -> Parser Day
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Day
Friday    Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"FR" Parser Day -> Parser Day -> Parser Day
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  Day
Saturday  Day -> ParsecT () Text Identity Text -> Parser Day
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Tokens Text -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"SA"