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, TimeOrDate(..))
import Text.Megaparsec hiding (count)
import Text.Megaparsec.Char.Lexer
import qualified Data.Time.Calendar as Cal (Day, toGregorian)

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 TimeOrDate
-> 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 TimeOrDate
until      = (RRule -> Maybe TimeOrDate) -> Maybe TimeOrDate
forall (m :: * -> *) a. MonadPlus m => (RRule -> m a) -> m a
combine RRule -> Maybe TimeOrDate
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 TimeOrDate
until      <- Text -> Parser TimeOrDate -> Parser (Maybe TimeOrDate)
forall a. Text -> Parser a -> Parser (Maybe a)
parseVar Text
"UNTIL"      Parser TimeOrDate
parseTimeOrDate
  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 TimeOrDate
-> 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 Day
Maybe Frequency
Maybe TimeOrDate
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 TimeOrDate
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 TimeOrDate
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)

parseTimeOrDate :: Parser TimeOrDate
parseTimeOrDate :: Parser TimeOrDate
parseTimeOrDate = (UTCTime -> TimeOrDate)
-> ParsecT () Text Identity UTCTime -> Parser TimeOrDate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UTCTime -> TimeOrDate
Time (ParsecT () Text Identity UTCTime
-> ParsecT () Text Identity UTCTime
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT () Text Identity UTCTime
parseUtcTime) Parser TimeOrDate -> Parser TimeOrDate -> Parser TimeOrDate
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Day -> TimeOrDate)
-> ParsecT () Text Identity Day -> Parser TimeOrDate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Day -> TimeOrDate
Date ParsecT () Text Identity Day
parseDate

parseDate :: Parser Cal.Day
parseDate :: ParsecT () Text Identity Day
parseDate = do
  Text
d <- Maybe String -> Int -> ParsecT () Text Identity (Tokens Text)
forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> Int -> m (Tokens s)
takeP Maybe String
forall a. Maybe a
Nothing Int
8
  Bool
-> TimeLocale -> String -> String -> ParsecT () Text Identity Day
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
False TimeLocale
defaultTimeLocale String
"%Y%m%d" (Text -> String
unpack Text
d)

parseUtcTime :: Parser UTCTime
parseUtcTime :: ParsecT () Text Identity UTCTime
parseUtcTime = do
  String
d <- ParsecT () Text Identity Char
-> ParsecT () Text Identity Char -> ParsecT () Text Identity String
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
-> String
-> String
-> ParsecT () Text Identity UTCTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
False TimeLocale
defaultTimeLocale String
"%Y%m%dT%H%M%S" String
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"