Safe Haskell | None |
---|---|
Language | Haskell2010 |
promoted date time functions
Synopsis
- data FormatTimeP p
- data FormatTimeP' p q
- data ParseTimeP (t :: Type) p
- data ParseTimeP' t p q
- data ParseTimes (t :: Type) p q
- data ParseTimes' t p q
- data MkDay p
- data MkDay' p q r
- data MkDayExtra p
- data MkDayExtra' p q r
- data MkTime p
- data MkTime' p q r
- data PosixToUTCTime p
- data DiffUTCTime p q
- data DiffLocalTime p q
- data UnMkDay p
- data ToWeekDate p
- data ToWeekYear p
- data ToDay
- data ToTime
- data UnMkTime p
- data UTCTimeToPosix p
- data LocalTimeToUTC p
format
data FormatTimeP p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (FormatTimeP p) x Source # eval :: MonadEval m => proxy (FormatTimeP p) -> POpts -> x -> m (TT (PP (FormatTimeP p) x)) Source # | |
Show (FormatTimeP p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> FormatTimeP p -> ShowS # show :: FormatTimeP p -> String # showList :: [FormatTimeP p] -> ShowS # | |
type PP (FormatTimeP p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data FormatTimeP' p q Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (FormatTimeP' p q) x Source # eval :: MonadEval m => proxy (FormatTimeP' p q) -> POpts -> x -> m (TT (PP (FormatTimeP' p q) x)) Source # | |
Show (FormatTimeP' p q) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> FormatTimeP' p q -> ShowS # show :: FormatTimeP' p q -> String # showList :: [FormatTimeP' p q] -> ShowS # | |
type PP (FormatTimeP' p q :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
constructors
data ParseTimeP (t :: Type) p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (ParseTimeP t p) x Source # eval :: MonadEval m => proxy (ParseTimeP t p) -> POpts -> x -> m (TT (PP (ParseTimeP t p) x)) Source # | |
Show (ParseTimeP t p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> ParseTimeP t p -> ShowS # show :: ParseTimeP t p -> String # showList :: [ParseTimeP t p] -> ShowS # | |
type PP (ParseTimeP t p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data ParseTimeP' t p q Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (ParseTimeP' t p q) a Source # eval :: MonadEval m => proxy (ParseTimeP' t p q) -> POpts -> a -> m (TT (PP (ParseTimeP' t p q) a)) Source # | |
Show (ParseTimeP' t p q) Source # | |
Defined in Predicate.Data.DateTime 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 Source # | |
Defined in Predicate.Data.DateTime |
data ParseTimes (t :: Type) p q Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (ParseTimes t p q) x Source # eval :: MonadEval m => proxy (ParseTimes t p q) -> POpts -> x -> m (TT (PP (ParseTimes t p q) x)) Source # | |
Show (ParseTimes t p q) Source # | |
Defined in Predicate.Data.DateTime 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 Source # | |
Defined in Predicate.Data.DateTime |
data ParseTimes' t p q Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (ParseTimes' t p q) a Source # eval :: MonadEval m => proxy (ParseTimes' t p q) -> POpts -> a -> m (TT (PP (ParseTimes' t p q) a)) Source # | |
Show (ParseTimes' t p q) Source # | |
Defined in Predicate.Data.DateTime 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 Source # | |
Defined in Predicate.Data.DateTime |
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)
create a Day
from three int values passed in as year month and day
>>>
pz @(MkDay' Fst Snd Thd) (2019,99,99999)
Val Nothing
data MkDayExtra p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (MkDayExtra p) x Source # eval :: MonadEval m => proxy (MkDayExtra p) -> POpts -> x -> m (TT (PP (MkDayExtra p) x)) Source # | |
Show (MkDayExtra p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> MkDayExtra p -> ShowS # show :: MkDayExtra p -> String # showList :: [MkDayExtra p] -> ShowS # | |
type PP (MkDayExtra p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data MkDayExtra' p q r Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (MkDayExtra' p q r) x Source # eval :: MonadEval m => proxy (MkDayExtra' p q r) -> POpts -> x -> m (TT (PP (MkDayExtra' p q r) x)) Source # | |
Show (MkDayExtra' p q r) Source # | |
Defined in Predicate.Data.DateTime 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 Source # | |
Defined in Predicate.Data.DateTime |
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
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
data PosixToUTCTime p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (PosixToUTCTime p) x Source # eval :: MonadEval m => proxy (PosixToUTCTime p) -> POpts -> x -> m (TT (PP (PosixToUTCTime p) x)) Source # | |
Show (PosixToUTCTime p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> PosixToUTCTime p -> ShowS # show :: PosixToUTCTime p -> String # showList :: [PosixToUTCTime p] -> ShowS # | |
type PP (PosixToUTCTime p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data DiffUTCTime p q Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (DiffUTCTime p q) x Source # eval :: MonadEval m => proxy (DiffUTCTime p q) -> POpts -> x -> m (TT (PP (DiffUTCTime p q) x)) Source # | |
Show (DiffUTCTime p q) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> DiffUTCTime p q -> ShowS # show :: DiffUTCTime p q -> String # showList :: [DiffUTCTime p q] -> ShowS # | |
type PP (DiffUTCTime p q :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data DiffLocalTime p q Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (DiffLocalTime p q) x Source # eval :: MonadEval m => proxy (DiffLocalTime p q) -> POpts -> x -> m (TT (PP (DiffLocalTime p q) x)) Source # | |
Show (DiffLocalTime p q) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> DiffLocalTime p q -> ShowS # show :: DiffLocalTime p q -> String # showList :: [DiffLocalTime p q] -> ShowS # | |
type PP (DiffLocalTime p q :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
destructors
uncreate a Day
returning year month and day
>>>
pz @(UnMkDay Id) (readNote "invalid day" "2019-12-30")
Val (2019,12,30)
data ToWeekDate p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (ToWeekDate p) x Source # eval :: MonadEval m => proxy (ToWeekDate p) -> POpts -> x -> m (TT (PP (ToWeekDate p) x)) Source # | |
Show (ToWeekDate p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> ToWeekDate p -> ShowS # show :: ToWeekDate p -> String # showList :: [ToWeekDate p] -> ShowS # | |
type PP (ToWeekDate p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data ToWeekYear p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (ToWeekYear p) x Source # eval :: MonadEval m => proxy (ToWeekYear p) -> POpts -> x -> m (TT (PP (ToWeekYear p) x)) Source # | |
Show (ToWeekYear p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> ToWeekYear p -> ShowS # show :: ToWeekYear p -> String # showList :: [ToWeekYear p] -> ShowS # | |
type PP (ToWeekYear p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
extract Day
from a DateTime
>>>
pz @(ReadP UTCTime Id >> ToDay) "2020-07-06 12:11:13Z"
Val 2020-07-06
extract TimeOfDay
from DateTime
>>>
pz @(ReadP UTCTime Id >> ToTime) "2020-07-06 12:11:13Z"
Val 12:11:13
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))
data UTCTimeToPosix p Source #
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 Source # | |
Defined in Predicate.Data.DateTime type PP (UTCTimeToPosix p) x Source # eval :: MonadEval m => proxy (UTCTimeToPosix p) -> POpts -> x -> m (TT (PP (UTCTimeToPosix p) x)) Source # | |
Show (UTCTimeToPosix p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> UTCTimeToPosix p -> ShowS # show :: UTCTimeToPosix p -> String # showList :: [UTCTimeToPosix p] -> ShowS # | |
type PP (UTCTimeToPosix p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |
data LocalTimeToUTC p Source #
similar to localTimeToUTC
Instances
(PP p x ~ LocalTime, P p x) => P (LocalTimeToUTC p :: Type) x Source # | |
Defined in Predicate.Data.DateTime type PP (LocalTimeToUTC p) x Source # eval :: MonadEval m => proxy (LocalTimeToUTC p) -> POpts -> x -> m (TT (PP (LocalTimeToUTC p) x)) Source # | |
Show (LocalTimeToUTC p) Source # | |
Defined in Predicate.Data.DateTime showsPrec :: Int -> LocalTimeToUTC p -> ShowS # show :: LocalTimeToUTC p -> String # showList :: [LocalTimeToUTC p] -> ShowS # | |
type PP (LocalTimeToUTC p :: Type) x Source # | |
Defined in Predicate.Data.DateTime |