hourglass-0.2.12: simple performant time related library
License BSD-style
Maintainer Vincent Hanquez <vincent@snarc.org>
Stability experimental
Portability unknown
Safe Haskell None
Language Haskell2010

Data.Hourglass

Description

Types and methods for time manipulation.

The most basic type for time representation is Elapsed, which represent a number of elapsed seconds since the unix epoch.

Every other defined types can be convert to and from Elapsed type:

timeGetElapsed (Date 1 2 3) :: Elapsed
timeFromElapsed 123         :: DateTime

Local time is represented by any other time types (Elapsed, Date, DateTime, ..), but augmented by a Timezone offset in minutes.

localTime (Date 2014 May 4) 600 -- local time at UTC+10 of May 4th 2014
Synopsis

Generic time classes

class Timeable t => Time t where Source #

Represent time types that can be created from other time types.

Every conversion happens throught ElapsedP or Elapsed types.

Minimal complete definition

timeFromElapsedP

Methods

timeFromElapsedP :: ElapsedP -> t Source #

convert from a number of elapsed seconds and nanoseconds to another time representation

timeFromElapsed :: Elapsed -> t Source #

convert from a number of elapsed seconds and nanoseconds to another time representation

defaults to timeFromElapsedP unless defined explicitely by an instance.

class Timeable t where Source #

Timeable represent every type that can be made to look like time types.

  • can be converted to ElapsedP and Elapsed
  • optionally have a timezone associated
  • have nanoseconds accessor (which can return 0 when the type is not more precise than seconds)

Minimal complete definition

timeGetElapsedP

Methods

timeGetElapsedP :: t -> ElapsedP Source #

convert a time representation to the number of elapsed seconds and nanoseconds to a specific epoch

timeGetElapsed :: t -> Elapsed Source #

convert a time representation to the number of elapsed seconds to a specific epoch.

defaults to timeGetElapsedP unless defined explicitely by an instance

timeGetNanoSeconds :: t -> NanoSeconds Source #

return the number of optional nanoseconds.

If the underlaying type is not precise enough to record nanoseconds (or any variant between seconds and nanoseconds), 0 should be returned

defaults to timeGetElapsedP unless defined explicitely by an instance, for efficiency reason, it's a good idea to override this methods if you know the type is not more precise than Seconds.

Instances

Instances details
Timeable CTime Source #
Instance details

Defined in Data.Hourglass.Time

Timeable DateTime Source #
Instance details

Defined in Data.Hourglass.Time

Timeable Date Source #
Instance details

Defined in Data.Hourglass.Time

Timeable ElapsedP Source #
Instance details

Defined in Data.Hourglass.Time

Timeable Elapsed Source #
Instance details

Defined in Data.Hourglass.Time

Epoch epoch => Timeable ( ElapsedSinceP epoch) Source #
Instance details

Defined in Data.Hourglass.Epoch

Epoch epoch => Timeable ( ElapsedSince epoch) Source #
Instance details

Defined in Data.Hourglass.Epoch

Elapsed time

newtype Elapsed Source #

A number of seconds elapsed since the unix epoch.

Constructors

Elapsed Seconds

Instances

Instances details
Eq Elapsed Source #
Instance details

Defined in Time.Types

Data Elapsed Source #
Instance details

Defined in Time.Types

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Elapsed -> c Elapsed Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Elapsed Source #

toConstr :: Elapsed -> Constr Source #

dataTypeOf :: Elapsed -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Elapsed ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Elapsed ) Source #

gmapT :: ( forall b. Data b => b -> b) -> Elapsed -> Elapsed Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Elapsed -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Elapsed -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> Elapsed -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> Elapsed -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Elapsed -> m Elapsed Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Elapsed -> m Elapsed Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Elapsed -> m Elapsed Source #

Num Elapsed Source #
Instance details

Defined in Time.Types

Ord Elapsed Source #
Instance details

Defined in Time.Types

Read Elapsed Source #
Instance details

Defined in Time.Types

Show Elapsed Source #
Instance details

Defined in Time.Types

NFData Elapsed Source #
Instance details

Defined in Time.Types

Time Elapsed Source #
Instance details

Defined in Data.Hourglass.Time

Timeable Elapsed Source #
Instance details

Defined in Data.Hourglass.Time

data ElapsedP Source #

A number of seconds and nanoseconds elapsed since the unix epoch.

Instances

Instances details
Eq ElapsedP Source #
Instance details

Defined in Time.Types

Data ElapsedP Source #
Instance details

Defined in Time.Types

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> ElapsedP -> c ElapsedP Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ElapsedP Source #

toConstr :: ElapsedP -> Constr Source #

dataTypeOf :: ElapsedP -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ElapsedP ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ElapsedP ) Source #

gmapT :: ( forall b. Data b => b -> b) -> ElapsedP -> ElapsedP Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> ElapsedP -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> ElapsedP -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> ElapsedP -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> ElapsedP -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP Source #

Num ElapsedP Source #
Instance details

Defined in Time.Types

Ord ElapsedP Source #
Instance details

Defined in Time.Types

Read ElapsedP Source #
Instance details

Defined in Time.Types

Real ElapsedP Source #
Instance details

Defined in Time.Types

Show ElapsedP Source #
Instance details

Defined in Time.Types

NFData ElapsedP Source #
Instance details

Defined in Time.Types

Time ElapsedP Source #
Instance details

Defined in Data.Hourglass.Time

Timeable ElapsedP Source #
Instance details

Defined in Data.Hourglass.Time

Generic conversion

timeConvert :: ( Timeable t1, Time t2) => t1 -> t2 Source #

Convert one time representation into another one

The return type need to be infer by the context.

If the context cannot be infer through this, some specialized functions are available for built-in types:

Date and Time

timeGetDate :: Timeable t => t -> Date Source #

Get the calendar Date (year-month-day) from a time representation

specialization of timeConvert

timeGetDateTimeOfDay :: Timeable t => t -> DateTime Source #

Get the date and time of day from a time representation

specialization of timeConvert

timeGetTimeOfDay :: Timeable t => t -> TimeOfDay Source #

Get the day time (hours:minutes:seconds) from a time representation

specialization of timeConvert

Arithmetic

data Duration Source #

An amount of time in terms of constant value like hours (3600 seconds), minutes (60 seconds), seconds and nanoseconds.

Constructors

Duration

Fields

Instances

Instances details
Eq Duration Source #
Instance details

Defined in Data.Hourglass.Diff

Data Duration Source #
Instance details

Defined in Data.Hourglass.Diff

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Duration -> c Duration Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Duration Source #

toConstr :: Duration -> Constr Source #

dataTypeOf :: Duration -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Duration ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Duration ) Source #

gmapT :: ( forall b. Data b => b -> b) -> Duration -> Duration Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Duration -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Duration -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> Duration -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> Duration -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Duration -> m Duration Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Duration -> m Duration Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Duration -> m Duration Source #

Ord Duration Source #
Instance details

Defined in Data.Hourglass.Diff

Read Duration Source #
Instance details

Defined in Data.Hourglass.Diff

Show Duration Source #
Instance details

Defined in Data.Hourglass.Diff

Semigroup Duration Source #
Instance details

Defined in Data.Hourglass.Diff

Monoid Duration Source #
Instance details

Defined in Data.Hourglass.Diff

NFData Duration Source #
Instance details

Defined in Data.Hourglass.Diff

TimeInterval Duration Source #
Instance details

Defined in Data.Hourglass.Diff

data Period Source #

An amount of conceptual calendar time in terms of years, months and days.

This allow calendar manipulation, representing things like days and months irrespective on how long those are related to timezone and daylight changes.

See Duration for the time-based equivalent to this class.

Instances

Instances details
Eq Period Source #
Instance details

Defined in Data.Hourglass.Diff

Data Period Source #
Instance details

Defined in Data.Hourglass.Diff

Methods

gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Period -> c Period Source #

gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Period Source #

toConstr :: Period -> Constr Source #

dataTypeOf :: Period -> DataType Source #

dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Period ) Source #

dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Period ) Source #

gmapT :: ( forall b. Data b => b -> b) -> Period -> Period Source #

gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Period -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Period -> r Source #

gmapQ :: ( forall d. Data d => d -> u) -> Period -> [u] Source #

gmapQi :: Int -> ( forall d. Data d => d -> u) -> Period -> u Source #

gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Period -> m Period Source #

gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Period -> m Period Source #

gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Period -> m Period Source #

Ord Period Source #
Instance details

Defined in Data.Hourglass.Diff

Read Period Source #
Instance details

Defined in Data.Hourglass.Diff

Show Period Source #
Instance details

Defined in Data.Hourglass.Diff

Semigroup Period Source #
Instance details

Defined in Data.Hourglass.Diff

Monoid Period Source #
Instance details

Defined in Data.Hourglass.Diff

NFData Period Source #
Instance details

Defined in Data.Hourglass.Diff

timeAdd :: ( Time t, TimeInterval ti) => t -> ti -> t Source #

add some time interval to a time representation and returns this new time representation

example:

t1 `timeAdd` mempty { durationHours = 12 }

timeDiff :: ( Timeable t1, Timeable t2) => t1 -> t2 -> Seconds Source #

Get the difference in seconds between two time representation

effectively:

t2 `timeDiff` t1 = t2 - t1

timeDiffP :: ( Timeable t1, Timeable t2) => t1 -> t2 -> ( Seconds , NanoSeconds ) Source #

Get the difference in seconds and nanoseconds between two time representation

effectively:

@t2 `timeDiffP` t1 = t2 - t1

dateAddPeriod :: Date -> Period -> Date Source #

add a period of time to a date

Parsing and Printing

Format strings

data TimeFormatElem Source #

All the various formatter that can be part of a time format string

Constructors

Format_Year2

2 digit years (70 is 1970, 69 is 2069)

Format_Year4

4 digits years

Format_Year

any digits years

Format_Month

months (1 to 12)

Format_Month2

months padded to 2 chars (01 to 12)

Format_MonthName_Short

name of the month short ( Jan , Feb ..)

Format_DayYear

day of the year (1 to 365, 366 for leap years)

Format_Day

day of the month (1 to 31)

Format_Day2

day of the month (01 to 31)

Format_Hour

hours (0 to 23)

Format_Minute

minutes (0 to 59)

Format_Second

seconds (0 to 59, 60 for leap seconds)

Format_UnixSecond

number of seconds since 1 jan 1970. unix epoch.

Format_MilliSecond

Milliseconds (000 to 999)

Format_MicroSecond

MicroSeconds (000000 to 999999)

Format_NanoSecond

NanoSeconds (000000000 to 999999999)

Format_Precision Int

sub seconds display with a precision of N digits. with N between 1 and 9

Format_TimezoneName

timezone name (e.g. GMT, PST). not implemented yet | Format_TimezoneOffset -- ^ timeoffset offset (+02:00)

Format_TzHM_Colon_Z

zero UTC offset (Z) or timeoffset with colon (+02:00)

Format_TzHM_Colon

timeoffset offset with colon (+02:00)

Format_TzHM

timeoffset offset (+0200)

Format_Tz_Offset

timeoffset in minutes

Format_Spaces

one or many space-like chars

Format_Text Char

a verbatim char

Format_Fct TimeFormatFct

Common built-in formats

Format methods

timePrint Source #

Arguments

:: ( TimeFormat format, Timeable t)
=> format

the format to use for printing

-> t

the global time to print

-> String

the resulting string

Pretty print time to a string

The actual output is determined by the format used

timeParse :: TimeFormat format => format -> String -> Maybe DateTime Source #

Just like localTimeParse but the time is automatically converted to global time.

timeParseE :: TimeFormat format => format -> String -> Either ( TimeFormatElem , String ) ( DateTime , String ) Source #

like localTimeParseE but the time value is automatically converted to global time.

localTimePrint Source #

Arguments

:: ( TimeFormat format, Timeable t)
=> format

the format to use for printing

-> LocalTime t

the local time to print

-> String

the resulting local time string

Pretty print local time to a string.

The actual output is determined by the format used.

localTimeParse Source #

Arguments

:: TimeFormat format
=> format

the format to use for parsing

-> String

the string to parse

-> Maybe ( LocalTime DateTime )

Try parsing a string as time using the format explicitely specified

Unparsed characters are ignored and the error handling is simplified

for more elaborate need use localTimeParseE .

localTimeParseE Source #

Arguments

:: TimeFormat format
=> format

the format to use for parsing

-> String

the string to parse

-> Either ( TimeFormatElem , String ) ( LocalTime DateTime , String )

Try parsing a string as time using the format explicitely specified

On failure, the parsing function returns the reason of the failure. If parsing is successful, return the date parsed with the remaining unparsed string

Local time

Local time type

Local time creation and manipulation

localTime :: Time t => TimezoneOffset -> t -> LocalTime t Source #

Create a local time type from a timezone and a time type.

The time value is assumed to be local to the timezone offset set, so no transformation is done.

localTimeUnwrap :: LocalTime t -> t Source #

unwrap the LocalTime value. the time value is local.

localTimeToGlobal :: Time t => LocalTime t -> t Source #

Get back a global time value

localTimeFromGlobal :: Time t => t -> LocalTime t Source #

create a local time value from a global one

localTimeGetTimezone :: LocalTime t -> TimezoneOffset Source #

get the timezone associated with LocalTime

localTimeSetTimezone :: Time t => TimezoneOffset -> LocalTime t -> LocalTime t Source #

Change the timezone, and adjust the local value to represent the new local value.

localTimeConvert :: ( Time t1, Time t2) => LocalTime t1 -> LocalTime t2 Source #

convert the local time representation to another time representation determined by context.

class Timezone tz where Source #

standard representation for timezone

Minimal complete definition

timezoneOffset

Methods

timezoneOffset :: tz -> Int Source #

offset in minutes from UTC. valid values should be between -12*60 to +14*60

timezoneName :: tz -> String Source #

the name of the timezone. by default will be +-HH:MM encoding.

Calendar misc functions

isLeapYear :: Int -> Bool Source #

Return if this year is a leap year (366 days) or not (365 days in a year)

getWeekDay :: Date -> WeekDay Source #

Return the day of the week a specific date fall in

getDayOfTheYear :: Date -> Int Source #

return the day of the year where Jan 1 is 0

between 0 and 364. 365 for leap years

daysInMonth :: Int -> Month -> Int Source #

Return the number of days in a month.