Predicate.Data.DateTime

promoted date time functions

format

data FormatTimeP p

type level expression representing a formatted time

>>> pz @(FormatTimeP "%F %T") (readNote @LocalTime "invalid localtime" "2019-05-24 05:19:59")
Val "2019-05-24 05:19:59"

>>> pl @(FormatTimeP "%Y-%m-%d") (readNote @Day "invalid day" "2019-08-17")
Present "2019-08-17" (FormatTimeP (%Y-%m-%d) 2019-08-17 | 2019-08-17)
Val "2019-08-17"

Instances

P (FormatTimePT p) x => P (FormatTimeP p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (FormatTimeP p) x

Methods

eval :: MonadEval m => proxy (FormatTimeP p) -> POpts -> x -> m (TT (PP (FormatTimeP p) x))

Show (FormatTimeP p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> FormatTimeP p -> ShowS

show :: FormatTimeP p -> String

showList :: [FormatTimeP p] -> ShowS

type PP (FormatTimeP p :: Type) x

Defined in Predicate.Data.DateTime

type PP (FormatTimeP p :: Type) x

data FormatTimeP' p q

type level expression representing a formatted time similar to formatTime using a type level Symbol to get the formatting string

>>> pz @(FormatTimeP' Fst Snd) ("the date is %d/%m/%Y", readNote @Day "invalid day" "2019-05-24")
Val "the date is 24/05/2019"

Instances

(PP p x ~ String, FormatTime (PP q x), P p x, Show (PP q x), P q x) => P (FormatTimeP' p q :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (FormatTimeP' p q) x

Methods

eval :: MonadEval m => proxy (FormatTimeP' p q) -> POpts -> x -> m (TT (PP (FormatTimeP' p q) x))

Show (FormatTimeP' p q)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> FormatTimeP' p q -> ShowS

show :: FormatTimeP' p q -> String

showList :: [FormatTimeP' p q] -> ShowS

type PP (FormatTimeP' p q :: Type) x

Defined in Predicate.Data.DateTime

type PP (FormatTimeP' p q :: Type) x = String

constructors

data ParseTimeP (t :: Type) p

similar to parseTimeM

>>> pz @(ParseTimeP LocalTime "%F %T") "2019-05-24 05:19:59"
Val 2019-05-24 05:19:59

>>> pz @("2019-05-24 05:19:59" >> ParseTimeP LocalTime "%F %T") (Right "never used")
Val 2019-05-24 05:19:59

>>> pl @(ParseTimeP TimeOfDay "%H:%M%S") "14:04:61"
Error ParseTimeP TimeOfDay (%H:%M%S) failed to parse
Fail "ParseTimeP TimeOfDay (%H:%M%S) failed to parse"

>>> pl @(ParseTimeP UTCTime "%F %T") "1999-01-01 12:12:12"
Present 1999-01-01 12:12:12 UTC (ParseTimeP UTCTime (%F %T) 1999-01-01 12:12:12 UTC | fmt=%F %T | "1999-01-01 12:12:12")
Val 1999-01-01 12:12:12 UTC

>>> pz @(ParseTimeP ZonedTime "%s%Q%z")  "153014400.000+0530"
Val 1974-11-07 05:30:00 +0530

Instances

P (ParseTimePT t p) x => P (ParseTimeP t p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (ParseTimeP t p) x

Methods

eval :: MonadEval m => proxy (ParseTimeP t p) -> POpts -> x -> m (TT (PP (ParseTimeP t p) x))

Show (ParseTimeP t p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ParseTimeP t p -> ShowS

show :: ParseTimeP t p -> String

showList :: [ParseTimeP t p] -> ShowS

type PP (ParseTimeP t p :: Type) x

Defined in Predicate.Data.DateTime

type PP (ParseTimeP t p :: Type) x

data ParseTimeP' t p q

similar to parseTimeM where t is the ParseTime type, p is the datetime format and q points to the content to parse keeping q as we might want to extract from a tuple

Instances

(ParseTime (PP t a), Typeable (PP t a), Show (PP t a), P p a, P q a, PP p a ~ String, PP q a ~ String) => P (ParseTimeP' t p q :: Type) a

Defined in Predicate.Data.DateTime

Associated Types

type PP (ParseTimeP' t p q) a

Methods

eval :: MonadEval m => proxy (ParseTimeP' t p q) -> POpts -> a -> m (TT (PP (ParseTimeP' t p q) a))

Show (ParseTimeP' t p q)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ParseTimeP' t p q -> ShowS

show :: ParseTimeP' t p q -> String

showList :: [ParseTimeP' t p q] -> ShowS

type PP (ParseTimeP' t p q :: Type) a

Defined in Predicate.Data.DateTime

type PP (ParseTimeP' t p q :: Type) a = PP t a

data ParseTimes (t :: Type) p q

A convenience method to match against many different datetime formats to find the first match

>>> pz @(ParseTimes LocalTime '["%Y-%m-%d %H:%M:%S", "%m/%d/%y %H:%M:%S", "%B %d %Y %H:%M:%S", "%Y-%m-%dT%H:%M:%S"] "03/11/19 01:22:33") ()
Val 2019-03-11 01:22:33

>>> pz @(ParseTimes LocalTime Fst Snd) (["%Y-%m-%d %H:%M:%S", "%m/%d/%y %H:%M:%S", "%B %d %Y %H:%M:%S", "%Y-%m-%dT%H:%M:%S"], "03/11/19 01:22:33")
Val 2019-03-11 01:22:33

>>> pl @(Map (ParseTimes Day '["%Y-%m-%d", "%m/%d/%y", "%b %d %Y"] Id)) ["2001-01-01", "Jan 24 2009", "03/29/0x7"]
Error no match on (03/29/0x7) (Map(i=2, a="03/29/0x7") excnt=1)
Fail "no match on (03/29/0x7)"

>>> pl @(Map (ParseTimes Day '["%Y-%m-%d", "%m/%d/%y", "%b %d %Y"] Id)) ["2001-01-01", "Jan 24 2009", "03/29/07"]
Present [2001-01-01,2009-01-24,2007-03-29] (Map [2001-01-01,2009-01-24,2007-03-29] | ["2001-01-01","Jan 24 2009","03/29/07"])
Val [2001-01-01,2009-01-24,2007-03-29]

Instances

P (ParseTimesT t p q) x => P (ParseTimes t p q :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (ParseTimes t p q) x

Methods

eval :: MonadEval m => proxy (ParseTimes t p q) -> POpts -> x -> m (TT (PP (ParseTimes t p q) x))

Show (ParseTimes t p q)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ParseTimes t p q -> ShowS

show :: ParseTimes t p q -> String

showList :: [ParseTimes t p q] -> ShowS

type PP (ParseTimes t p q :: Type) x

Defined in Predicate.Data.DateTime

type PP (ParseTimes t p q :: Type) x

data ParseTimes' t p q

A convenience method to match against many different datetime formats to find the first match

Instances

(ParseTime (PP t a), Typeable (PP t a), Show (PP t a), P p a, P q a, PP p a ~ [String], PP q a ~ String) => P (ParseTimes' t p q :: Type) a

Defined in Predicate.Data.DateTime

Associated Types

type PP (ParseTimes' t p q) a

Methods

eval :: MonadEval m => proxy (ParseTimes' t p q) -> POpts -> a -> m (TT (PP (ParseTimes' t p q) a))

Show (ParseTimes' t p q)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ParseTimes' t p q -> ShowS

show :: ParseTimes' t p q -> String

showList :: [ParseTimes' t p q] -> ShowS

type PP (ParseTimes' t p q :: Type) a

Defined in Predicate.Data.DateTime

type PP (ParseTimes' t p q :: Type) a = PP t a

data MkDay p

create a Day from three int values passed in as year month and day

>>> pz @(MkDay '(1,2,3) >> 'Just Id) ()
Val 0001-02-03

>>> pz @('Just (MkDay '(1,2,3))) 1
Val 0001-02-03

>>> pz @(MkDay Id) (2019,12,30)
Val (Just 2019-12-30)

>>> pz @(MkDay Id) (1999,3,13)
Val (Just 1999-03-13)

Instances

P (MkDayT p) x => P (MkDay p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (MkDay p) x

Methods

eval :: MonadEval m => proxy (MkDay p) -> POpts -> x -> m (TT (PP (MkDay p) x))

Show (MkDay p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> MkDay p -> ShowS

show :: MkDay p -> String

showList :: [MkDay p] -> ShowS

type PP (MkDay p :: Type) x

Defined in Predicate.Data.DateTime

type PP (MkDay p :: Type) x

data MkDay' p q r

create a Day from three int values passed in as year month and day

>>> pz @(MkDay' Fst Snd Thd) (2019,99,99999)
Val Nothing

Instances

(P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Int) => P (MkDay' p q r :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (MkDay' p q r) x

Methods

eval :: MonadEval m => proxy (MkDay' p q r) -> POpts -> x -> m (TT (PP (MkDay' p q r) x))

Show (MkDay' p q r)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> MkDay' p q r -> ShowS

show :: MkDay' p q r -> String

showList :: [MkDay' p q r] -> ShowS

type PP (MkDay' p q r :: Type) x

Defined in Predicate.Data.DateTime

type PP (MkDay' p q r :: Type) x = Maybe Day

data MkDayExtra p

create a Day, week number, and the day of the week from three numbers passed in as year month and day

>>> pz @(MkDayExtra '(1,2,3) >> 'Just Id >> Fst) ()
Val 0001-02-03

>>> pz @(L1 (Just (MkDayExtra '(1,2,3)))) 1
Val 0001-02-03

>>> pz @(MkDayExtra Id) (2019,12,30)
Val (Just (2019-12-30,1,1))

>>> pz @(MkDayExtra Id) (1999,3,13)
Val (Just (1999-03-13,10,6))

Instances

P (MkDayExtraT p) x => P (MkDayExtra p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (MkDayExtra p) x

Methods

eval :: MonadEval m => proxy (MkDayExtra p) -> POpts -> x -> m (TT (PP (MkDayExtra p) x))

Show (MkDayExtra p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> MkDayExtra p -> ShowS

show :: MkDayExtra p -> String

showList :: [MkDayExtra p] -> ShowS

type PP (MkDayExtra p :: Type) x

Defined in Predicate.Data.DateTime

type PP (MkDayExtra p :: Type) x

data MkDayExtra' p q r

create a Day, week number, and the day of the week from three numbers passed in as year month and day

>>> pz @(MkDayExtra' Fst Snd Thd) (2019,99,99999)
Val Nothing

Instances

(P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Int) => P (MkDayExtra' p q r :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (MkDayExtra' p q r) x

Methods

eval :: MonadEval m => proxy (MkDayExtra' p q r) -> POpts -> x -> m (TT (PP (MkDayExtra' p q r) x))

Show (MkDayExtra' p q r)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> MkDayExtra' p q r -> ShowS

show :: MkDayExtra' p q r -> String

showList :: [MkDayExtra' p q r] -> ShowS

type PP (MkDayExtra' p q r :: Type) x

Defined in Predicate.Data.DateTime

type PP (MkDayExtra' p q r :: Type) x = Maybe (Day, Int, Int)

data MkTime p

create a TimeOfDay from a three-tuple of year month and day

>>> pz @(MkTime '(1,2,3 % 12345)) ()
Val 01:02:00.000243013365

>>> pz @(MkTime Id) (12,13,65)
Val 12:13:65

>>> pz @(MkTime Id) (17,3,13)
Val 17:03:13

Instances

P (MkTimeT p) x => P (MkTime p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (MkTime p) x

Methods

eval :: MonadEval m => proxy (MkTime p) -> POpts -> x -> m (TT (PP (MkTime p) x))

Show (MkTime p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> MkTime p -> ShowS

show :: MkTime p -> String

showList :: [MkTime p] -> ShowS

type PP (MkTime p :: Type) x

Defined in Predicate.Data.DateTime

type PP (MkTime p :: Type) x

data MkTime' p q r

create a TimeOfDay from three int values passed in as year month and day

>>> pz @(MkTime' Fst Snd Thd) (13,99,99999)
Val 13:99:99999

Instances

(P p x, P q x, P r x, PP p x ~ Int, PP q x ~ Int, PP r x ~ Rational) => P (MkTime' p q r :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (MkTime' p q r) x

Methods

eval :: MonadEval m => proxy (MkTime' p q r) -> POpts -> x -> m (TT (PP (MkTime' p q r) x))

Show (MkTime' p q r)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> MkTime' p q r -> ShowS

show :: MkTime' p q r -> String

showList :: [MkTime' p q r] -> ShowS

type PP (MkTime' p q r :: Type) x

Defined in Predicate.Data.DateTime

type PP (MkTime' p q r :: Type) x = TimeOfDay

data PosixToUTCTime p

convert posix time (seconds since 01-01-1970) to UTCTime

>>> pl @(PosixToUTCTime Id) 1593384312
Present 2020-06-28 22:45:12 UTC (PosixToUTCTime 2020-06-28 22:45:12 UTC | 1593384312 % 1)
Val 2020-06-28 22:45:12 UTC

>>> pl @(PosixToUTCTime Id >> UTCTimeToPosix Id) 1593384312
Present 1593384312 % 1 ((>>) 1593384312 % 1 | {UTCTimeToPosix 1593384312 % 1 | 2020-06-28 22:45:12 UTC})
Val (1593384312 % 1)

>>> pl @(PosixToUTCTime (Id % 1000)) 1593384312000
Present 2020-06-28 22:45:12 UTC (PosixToUTCTime 2020-06-28 22:45:12 UTC | 1593384312 % 1)
Val 2020-06-28 22:45:12 UTC

>>> pl @(PosixToUTCTime Id) (3600*4+60*7+12)
Present 1970-01-01 04:07:12 UTC (PosixToUTCTime 1970-01-01 04:07:12 UTC | 14832 % 1)
Val 1970-01-01 04:07:12 UTC

>>> pz @(Rescan "^Date\\((\\d+)([^\\)]+)\\)" >> Head >> Snd >> ReadP Integer (Id !! 0) >> PosixToUTCTime (Id % 1000)) "Date(1530144000000+0530)"
Val 2018-06-28 00:00:00 UTC

Instances

(PP p x ~ Rational, P p x) => P (PosixToUTCTime p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (PosixToUTCTime p) x

Methods

eval :: MonadEval m => proxy (PosixToUTCTime p) -> POpts -> x -> m (TT (PP (PosixToUTCTime p) x))

Show (PosixToUTCTime p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> PosixToUTCTime p -> ShowS

show :: PosixToUTCTime p -> String

showList :: [PosixToUTCTime p] -> ShowS

type PP (PosixToUTCTime p :: Type) x

Defined in Predicate.Data.DateTime

type PP (PosixToUTCTime p :: Type) x = UTCTime

data DiffUTCTime p q

similar to diffUTCTime

>>> pz @(DiffUTCTime Fst Snd) (read "2020-11-08 12:12:03Z", read "2020-11-08 11:12:00Z")
Val 3603s

Instances

(PP p x ~ UTCTime, PP q x ~ UTCTime, P p x, P q x) => P (DiffUTCTime p q :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (DiffUTCTime p q) x

Methods

eval :: MonadEval m => proxy (DiffUTCTime p q) -> POpts -> x -> m (TT (PP (DiffUTCTime p q) x))

Show (DiffUTCTime p q)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> DiffUTCTime p q -> ShowS

show :: DiffUTCTime p q -> String

showList :: [DiffUTCTime p q] -> ShowS

type PP (DiffUTCTime p q :: Type) x

Defined in Predicate.Data.DateTime

type PP (DiffUTCTime p q :: Type) x = NominalDiffTime

data DiffLocalTime p q

similar to diffLocalTime

>>> pz @(DiffLocalTime Fst Snd) (read "2020-11-08 12:12:03", read "2020-11-05 15:12:00")
Val 248403s

Instances

P (DiffLocalTimeT p q) x => P (DiffLocalTime p q :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (DiffLocalTime p q) x

Methods

eval :: MonadEval m => proxy (DiffLocalTime p q) -> POpts -> x -> m (TT (PP (DiffLocalTime p q) x))

Show (DiffLocalTime p q)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> DiffLocalTime p q -> ShowS

show :: DiffLocalTime p q -> String

showList :: [DiffLocalTime p q] -> ShowS

type PP (DiffLocalTime p q :: Type) x

Defined in Predicate.Data.DateTime

type PP (DiffLocalTime p q :: Type) x

destructors

data UnMkDay p

uncreate a Day returning year month and day

>>> pz @(UnMkDay Id) (readNote "invalid day" "2019-12-30")
Val (2019,12,30)

Instances

(PP p x ~ Day, P p x) => P (UnMkDay p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (UnMkDay p) x

Methods

eval :: MonadEval m => proxy (UnMkDay p) -> POpts -> x -> m (TT (PP (UnMkDay p) x))

Show (UnMkDay p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> UnMkDay p -> ShowS

show :: UnMkDay p -> String

showList :: [UnMkDay p] -> ShowS

type PP (UnMkDay p :: Type) x

Defined in Predicate.Data.DateTime

type PP (UnMkDay p :: Type) x = (Int, Int, Int)

data ToWeekDate p

get the day of the week

>>> pz @('Just (MkDay '(2020,7,11)) >> '(UnMkDay Id, ToWeekYear Id,ToWeekDate Id)) ()
Val ((2020,7,11),28,(6,"Saturday"))

Instances

(P p x, PP p x ~ Day) => P (ToWeekDate p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (ToWeekDate p) x

Methods

eval :: MonadEval m => proxy (ToWeekDate p) -> POpts -> x -> m (TT (PP (ToWeekDate p) x))

Show (ToWeekDate p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ToWeekDate p -> ShowS

show :: ToWeekDate p -> String

showList :: [ToWeekDate p] -> ShowS

type PP (ToWeekDate p :: Type) x

Defined in Predicate.Data.DateTime

type PP (ToWeekDate p :: Type) x = (Int, String)

data ToWeekYear p

get week number of the year

>>> pz @('Just (MkDay '(2020,7,11)) >> ToWeekYear Id) ()
Val 28

Instances

(P p x, PP p x ~ Day) => P (ToWeekYear p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (ToWeekYear p) x

Methods

eval :: MonadEval m => proxy (ToWeekYear p) -> POpts -> x -> m (TT (PP (ToWeekYear p) x))

Show (ToWeekYear p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ToWeekYear p -> ShowS

show :: ToWeekYear p -> String

showList :: [ToWeekYear p] -> ShowS

type PP (ToWeekYear p :: Type) x

Defined in Predicate.Data.DateTime

type PP (ToWeekYear p :: Type) x = Int

data ToDay

extract Day from a DateTime

>>> pz @(ReadP UTCTime Id >> ToDay) "2020-07-06 12:11:13Z"
Val 2020-07-06

Instances

Show ToDay

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ToDay -> ShowS

show :: ToDay -> String

showList :: [ToDay] -> ShowS

(ToDayC x, Show x) => P ToDay x

Defined in Predicate.Data.DateTime

Associated Types

type PP ToDay x

Methods

eval :: MonadEval m => proxy ToDay -> POpts -> x -> m (TT (PP ToDay x))

type PP ToDay x

Defined in Predicate.Data.DateTime

type PP ToDay x = Day

data ToTime

extract TimeOfDay from DateTime

>>> pz @(ReadP UTCTime Id >> ToTime) "2020-07-06 12:11:13Z"
Val 12:11:13

Instances

Show ToTime

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> ToTime -> ShowS

show :: ToTime -> String

showList :: [ToTime] -> ShowS

(ToTimeC x, Show x) => P ToTime x

Defined in Predicate.Data.DateTime

Associated Types

type PP ToTime x

Methods

eval :: MonadEval m => proxy ToTime -> POpts -> x -> m (TT (PP ToTime x))

type PP ToTime x

Defined in Predicate.Data.DateTime

type PP ToTime x = TimeOfDay

data UnMkTime p

uncreate a TimeOfDay returning hour minute seconds picoseconds

>>> pz @(ReadP UTCTime "2019-01-01 12:13:14.1234Z" >> ToTime >> UnMkTime Id) ()
Val (12,13,70617 % 5000)

>>> pz @(ReadP UTCTime Id >> ToTime >> UnMkTime Id) "2020-07-22 08:01:14.127Z"
Val (8,1,14127 % 1000)

>>> pz @(ReadP ZonedTime Id >> '(UnMkDay ToDay, UnMkTime ToTime)) "2020-07-11 11:41:12.333+0400"
Val ((2020,7,11),(11,41,12333 % 1000))

Instances

(PP p x ~ TimeOfDay, P p x) => P (UnMkTime p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (UnMkTime p) x

Methods

eval :: MonadEval m => proxy (UnMkTime p) -> POpts -> x -> m (TT (PP (UnMkTime p) x))

Show (UnMkTime p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> UnMkTime p -> ShowS

show :: UnMkTime p -> String

showList :: [UnMkTime p] -> ShowS

type PP (UnMkTime p :: Type) x

Defined in Predicate.Data.DateTime

type PP (UnMkTime p :: Type) x = (Int, Int, Rational)

data UTCTimeToPosix p

convert UTCTime to posix time (seconds since 01-01-1970)

>>> pl @(ReadP UTCTime Id >> UTCTimeToPosix Id) "2020-06-28 22:45:12 UTC"
Present 1593384312 % 1 ((>>) 1593384312 % 1 | {UTCTimeToPosix 1593384312 % 1 | 2020-06-28 22:45:12 UTC})
Val (1593384312 % 1)

>>> pz @(Rescan "^Date\\((\\d+)([^\\)]+)\\)" >> Head >> Snd >> ((ReadP Integer (Id !! 0) >> PosixToUTCTime (Id % 1000)) &&& ReadP TimeZone (Id !! 1))) "Date(1530144000000+0530)"
Val (2018-06-28 00:00:00 UTC,+0530)

Instances

(PP p x ~ UTCTime, P p x) => P (UTCTimeToPosix p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (UTCTimeToPosix p) x

Methods

eval :: MonadEval m => proxy (UTCTimeToPosix p) -> POpts -> x -> m (TT (PP (UTCTimeToPosix p) x))

Show (UTCTimeToPosix p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> UTCTimeToPosix p -> ShowS

show :: UTCTimeToPosix p -> String

showList :: [UTCTimeToPosix p] -> ShowS

type PP (UTCTimeToPosix p :: Type) x

Defined in Predicate.Data.DateTime

type PP (UTCTimeToPosix p :: Type) x = Rational

data LocalTimeToUTC p

similar to localTimeToUTC

Instances

(PP p x ~ LocalTime, P p x) => P (LocalTimeToUTC p :: Type) x

Defined in Predicate.Data.DateTime

Associated Types

type PP (LocalTimeToUTC p) x

Methods

eval :: MonadEval m => proxy (LocalTimeToUTC p) -> POpts -> x -> m (TT (PP (LocalTimeToUTC p) x))

Show (LocalTimeToUTC p)

Defined in Predicate.Data.DateTime

Methods

showsPrec :: Int -> LocalTimeToUTC p -> ShowS

show :: LocalTimeToUTC p -> String

showList :: [LocalTimeToUTC p] -> ShowS

type PP (LocalTimeToUTC p :: Type) x

Defined in Predicate.Data.DateTime

type PP (LocalTimeToUTC p :: Type) x = UTCTime