-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | date time
--   
--   convenient type, timestamp, timezone, format
@package hora
@version 2.2.0

module Data.Time.Hora.Type

-- | serializeable structure for essential Date, Time parts
--   
--   may also be used to construct <a>UTCTime</a>
--   
--   see <a>Data.Time.Hora.Part</a> for conversion between <a>UTCTime</a>
--   and <a>DatePart</a>
data DatePart a
DatePart :: a -> a -> a -> a -> a -> a -> a -> DatePart a
[year] :: DatePart a -> a
[month] :: DatePart a -> a
[day] :: DatePart a -> a
[hour] :: DatePart a -> a
[minute] :: DatePart a -> a
[second] :: DatePart a -> a

-- | excludes seconds. Just fraction as Integral
[pico] :: DatePart a -> a

-- | <a>DatePartSmall</a> uses fixed-size storage. Storage (as encoded with
--   <a>Data.Binary</a>.encode) varies with the constructor used, is noted
--   as ".. bytes" against each constructor.
--   
--   allows to operate with dates only ..
--   
--   .. or time (minute / millisecond precision) only
--   
--   is convenient for dealing with intervals / timespans
--   
--   day count begins at 1 Jan 0001: 1 Jan 0001 is day 1
--   
--   max date is: 11759222-01-19. That's 19 Jan 11759222
--   
--   see <a>Data.Time.Hora.Part</a> for conversion between <tt>UTCTime</tt>
--   and <a>DatePartSmall</a>
--   
--   only values constructed with <a>DatePartSmall</a> can be converted to
--   <tt>UTCTime</tt>
data DatePartSmall

-- | days after 31 Dec 1 BC: 1 Jan AD 1 is day 1. See
--   <a>https://en.wikipedia.org/wiki/Anno_Domini</a>
--   
--   5 bytes
Day :: Word32 -> DatePartSmall

-- | minutes (includes hours)
--   
--   3 bytes
Min :: Word16 -> DatePartSmall

-- | milliseconds (includes seconds)
--   
--   5 bytes
Ms :: Word32 -> DatePartSmall

-- | minutes, milliseconds
--   
--   7 bytes
Time :: Word16 -> Word32 -> DatePartSmall

-- | date, minutes, milliseconds
--   
--   11 bytes
DatePartSmall :: Word32 -> Word16 -> Word32 -> DatePartSmall

-- | date span in days
--   
--   5 bytes
Day' :: Word32 -> DatePartSmall

-- | time span in minutes
--   
--   3 bytes
Min' :: Word16 -> DatePartSmall

-- | time span in milliseconds
--   
--   5 bytes
Ms' :: Word32 -> DatePartSmall

-- | result of failed operation
Error :: ErrorDetail -> DatePartSmall

-- | substitutes constructor:
--   
--   <a>Day</a> -&gt; <a>Day'</a>
--   
--   <a>Min</a> -&gt; <a>Min'</a>
--   
--   <a>Ms</a> -&gt; <a>Ms'</a>
toSpan :: DatePartSmall -> DatePartSmall

-- | adds hidden Neg constructor to <a>Day'</a>, <a>Min'</a> or <a>Ms'</a>
--   to enable negative spans
negate :: DatePartSmall -> DatePartSmall

-- | checks if <a>DatePartSmall</a> is a negative span
isNegative :: DatePartSmall -> Bool
data ErrorDetail

-- | operation is not possible with these constructors
Invalid :: ErrorDetail

-- | data type maxed out
Overflow :: ErrorDetail

-- | <a>Invalid</a> &lt;&gt; <a>Overflow</a>
Invalid_Overflow :: ErrorDetail

-- | <a>UTCTimeBin</a> closely mimicks <a>UTCTime</a> without loss of
--   precision
--   
--   <a>UTCTimeBin</a> has <a>Binary</a> instance. The only purpose of
--   <a>UTCTimeBin</a> is to offer faster conversion from / to
--   <a>UTCTime</a> and more compact serialization compared with
--   <a>DatePart</a>.
--   
--   see <a>Data.Time.Hora.Part</a> for conversion between <a>UTCTime</a>
--   and <a>UTCTimeBin</a>
data UTCTimeBin
UTCTimeBin :: Integer -> Integer -> UTCTimeBin

-- | The Modified Julian Day is a standard count of days, with zero being
--   the day 1858-11-17
[modifiedJulianDay] :: UTCTimeBin -> Integer

-- | <a>DiffTime</a> expressed as picoseconds
[diffTimeAsPicoseconds] :: UTCTimeBin -> Integer

-- | <a>Tz</a> (<a>DatePart</a> a) parts show local date &amp; time
--   
--   for conversions between timezones see <a>Data.Time.Hora.Zone</a>
data Tz a
Tz :: TimeZone -> a -> Tz a

-- | <a>TimeZone</a> | <a>TimeZoneSeries</a>
class Tz' tz
tz' :: Tz' tz => tz -> UTCTime -> TimeZone

-- | second and fractions
--   
--   see <a>Data.Time.Hora.Span</a> for conversion
data TimeSpan a
Sec :: a -> TimeSpan a
Pico :: a -> TimeSpan a
Milli :: a -> TimeSpan a

-- | constraint
type TwoInt a b = (Integral a, Integral b)
instance GHC.Base.Functor Data.Time.Hora.Type.Tz
instance GHC.Show.Show a => GHC.Show.Show (Data.Time.Hora.Type.Tz a)
instance GHC.Generics.Generic Data.Time.Hora.Type.UTCTimeBin
instance GHC.Show.Show Data.Time.Hora.Type.UTCTimeBin
instance GHC.Classes.Eq Data.Time.Hora.Type.UTCTimeBin
instance GHC.Generics.Generic (Data.Time.Hora.Type.DatePart a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Time.Hora.Type.DatePart a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Time.Hora.Type.DatePart a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Time.Hora.Type.Tz a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Time.Hora.Type.Tz a)
instance Data.Time.Hora.Type.Tz' Data.Time.LocalTime.Internal.TimeZone.TimeZone
instance Data.Time.Hora.Type.Tz' Data.Time.LocalTime.TimeZone.Series.TimeZoneSeries
instance Data.Binary.Class.Binary Data.Time.Hora.Type.UTCTimeBin
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Time.Hora.Type.DatePart a)
instance GHC.Base.Functor Data.Time.Hora.Type.DatePart
instance Data.Binary.Class.Binary (Data.Time.Hora.Type.DatePart GHC.Types.Int)
instance Data.Binary.Class.Binary (Data.Time.Hora.Type.DatePart GHC.Integer.Type.Integer)
instance Data.Binary.Class.Binary (Data.Time.Hora.Type.DatePart GHC.Base.String)
instance GHC.Real.Integral a => GHC.Num.Num (Data.Time.Hora.Internal.Span.TimeSpan a)
instance (GHC.Classes.Eq a, GHC.Real.Integral a) => GHC.Classes.Eq (Data.Time.Hora.Internal.Span.TimeSpan a)
instance (GHC.Classes.Ord a, GHC.Real.Integral a) => GHC.Classes.Ord (Data.Time.Hora.Internal.Span.TimeSpan a)

module Data.Time.Hora.Span

-- | <pre>
--   &gt;&gt;&gt; toPico (Milli 1)
--   1000000000 
--   </pre>
toPico :: TwoInt a b => TimeSpan a -> b

-- | <pre>
--   &gt;&gt;&gt; toMilli $ Sec 5
--   5000   
--   </pre>
toMilli :: TwoInt a b => TimeSpan a -> b

-- | <pre>
--   &gt;&gt;&gt; toSec $ Milli 781200
--   781     
--   </pre>
toSec :: TwoInt a b => TimeSpan a -> b

-- | pico in 1 second
picoSec :: Integral a => a

-- | pico in 1 milli
picoMs :: Integral a => a

-- | milli in 1 sec
msSec :: Integral a => a
picoTimeSpan :: Integral a => Pico -> TimeSpan a
timeSpanPico :: Integral a => TimeSpan a -> Pico
toDiffTime :: Integral a => TimeSpan a -> DiffTime
nominalDiff :: Integral a => TimeSpan a -> NominalDiffTime


-- | convert between <a>UTCTime</a>, <a>UTCTimeBin</a>, <a>DatePart</a>,
--   <a>DatePartSmall</a>
module Data.Time.Hora.Part
class FromUTC a
fromUtc :: FromUTC a => UTCTime -> a

-- | specified time zone
--   
--   Tz (DatePart a) parts show local date &amp; time
--   
--   see also <a>Data.Time.Hora.Zone</a>
fromUtc' :: (Tz' tz, Integral a) => tz -> UTCTime -> Tz (DatePart a)

-- | convert <a>DatePart</a> -&gt; <a>UTCTime</a>
--   
--   Invalid date returns Nothing
class ToUTC a
toUtc :: ToUTC a => a -> Maybe UTCTime

-- | day / date
mkDay :: Integral a => a -> a -> a -> DatePartSmall

-- | minutes including hours
mkMin :: (Num a, Integral a) => a -> a -> DatePartSmall

-- | milliseconds including seconds
mkMs :: (Num a, Integral a) => a -> a -> DatePartSmall

-- | for (<a>Time</a>, <a>DatePartSmall</a>) increase:
--   
--   minutes if seconds &gt; 60
--   
--   days if minutes &gt; 24 * 60
--   
--   ! does not change the constructor. <a>Time</a> remains <a>Time</a>
--   
--   this function is called by <a>toUtc</a> before the conversion
normalize :: DatePartSmall -> DatePartSmall

-- | Julian day offset
--   
--   <a>https://en.wikipedia.org/wiki/Julian_day</a>
--   
--   <pre>
--   &gt;&gt;&gt; mkDay 1 1 1 `shouldBe` (Day 1)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; mkDay 1858 11 17 `shouldBe` (Day julian_day_offset)
--   </pre>
julian_day_offset :: Integral a => a
instance GHC.Real.Integral a => Data.Time.Hora.Part.ToUTC (Data.Time.Hora.Type.DatePart a)
instance GHC.Real.Integral a => Data.Time.Hora.Part.ToUTC (Data.Time.Hora.Type.Tz (Data.Time.Hora.Type.DatePart a))
instance Data.Time.Hora.Part.ToUTC Data.Time.Hora.Type.UTCTimeBin
instance Data.Time.Hora.Part.ToUTC Data.Time.Hora.Internal.DatePartSmall.DatePartSmall
instance GHC.Real.Integral a => Data.Time.Hora.Part.FromUTC (Data.Time.Hora.Type.DatePart a)
instance Data.Time.Hora.Part.FromUTC Data.Time.Hora.Type.UTCTimeBin
instance Data.Time.Hora.Part.FromUTC Data.Time.Hora.Internal.DatePartSmall.DatePartSmall

module Data.Time.Hora.Future

-- | <a>getCurrentTime</a> +/- offset
--   
--   from unit test:
--   
--   <pre>
--   getCurrentTime
--   futureUTCTime $ Milli 100
--   futureUTCTime $ Sec 3
--   
--   2016-12-12 15:34:03.138798524 UTC
--   2016-12-12 15:34:03.23893359 UTC
--   2016-12-12 15:34:06.138978355 UTC
--   </pre>
futureUTCTime :: Integral a => TimeSpan a -> IO UTCTime

-- | Difference between times with pico precision
--   
--   return TimeSpan for ease of conversion with <a>Data.Time.Hora.Span</a>
class PicoDiff a
(-) :: PicoDiff a => a -> a -> TimeSpan Integer
instance Data.Time.Hora.Future.PicoDiff Data.Time.Clock.Internal.UTCTime.UTCTime
instance Data.Time.Hora.Future.PicoDiff Data.Fixed.Pico

module Data.Time.Hora.Format

-- | *0: 0 padded
--   
--   see <a>formatTime</a>
data Format
Raw :: String -> Format
Tab :: Format

-- | new line
Crlf :: Format

-- | time zone
Offset :: Format

-- | time zone name
Zone :: Format

-- | %H:%M
Hm :: Format

-- | %H:%M:%S
Hms :: Format

-- | AM PM
AM :: Format

-- | am pm
Am :: Format

-- | 24-hour *0
H_24 :: Format

-- | 12-hour *0
H_12 :: Format

-- | minute *0
Min :: Format

-- | second *0
S :: Format

-- | pico precision *0
Fraction_fixed :: Format

-- | .12 for 0.12 second. Pico precision, no trailing 0
Fraction :: Format

-- | %Y-%m-%d
Y_m_d :: Format

-- | year
Y :: Format

-- | month name long
Month :: Format

-- | month name short
Mth :: Format

-- | month *0
Mth_1_12 :: Format

-- | day *0
D :: Format

-- | day of week for Week Date format, 1 - 7
D_wk_1_7 :: Format

-- | day of week number, 0 (= Sunday) - 6 (= Saturday)
D_wk_0_6 :: Format

-- | day of week short
D_wk :: Format

-- | day of week long
D_week :: Format

-- | week of year start Sunday
Wk_year_Sun :: Format

-- | week of year start Monday
Wk_year_Mon :: Format

-- | format as UTC
format :: [Format] -> UTCTime -> String

-- | format as local time in specified timezone
format' :: Tz' tz => [Format] -> tz -> UTCTime -> Tz String

-- | pretty print <a>DatePartSmall</a>
--   
--   incremental values are prefixed with + or -
--   
--   <pre>
--   &gt;&gt;&gt; show' $ mkDay 2018 08 17
--       2018-08-17
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ mkMin 4 3
--       04:03
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ mkMs 7 318
--       07.318
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let (Day d1) = mkDay 2018 08 17
--           (Min m1) = mkMin 15 17
--           (Ms ms1) = mkMs 7 358
--       show' $ DatePartSmall d1 m1 ms1
--       2018-08-17 15:17:07.358
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ Day' 3
--        +3
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ toSpan $ mkMin 0 53
--       +00:53
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ toSpan $ mkMs 7 0
--       +07.000
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ T.negate $ Day' 3
--       -3
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; show' $ T.negate $ toSpan $ mkMin 14 53
--       -14:53
--   </pre>
show' :: DatePartSmall -> String
instance Data.Time.Hora.Format.Build [Data.Time.Hora.Format.Format]
instance Data.Time.Hora.Format.Build Data.Time.Hora.Format.Format
instance Data.String.IsString Data.Time.Hora.Format.Format

module Data.Time.Hora.Stamp

-- | numeric
class Now a
now :: Now a => IO a

-- | timestamp in specified format
--   
--   see <a>Data.Time.Hora.Some</a> for common [<a>Format</a>]s
class Timestamp out
ts :: Timestamp out => [Format] -> IO out

-- | timestamp in specified format, <a>TimeZone</a> |
--   <tt>TimeZoneSeries</tt>
ts' :: Tz' tz => [Format] -> tz -> IO (Tz String)
instance Data.Time.Hora.Stamp.Timestamp GHC.Base.String
instance Data.Time.Hora.Stamp.Timestamp (Data.Time.Hora.Type.Tz GHC.Base.String)
instance GHC.Real.Integral a => Data.Time.Hora.Stamp.Now (Data.Time.Hora.Type.DatePart a)
instance Data.Time.Hora.Stamp.Now Data.Time.Clock.Internal.UTCTime.UTCTime
instance GHC.Real.Integral a => Data.Time.Hora.Stamp.Now (Data.Time.Hora.Type.Tz (Data.Time.Hora.Type.DatePart a))


-- | common format shortcuts
module Data.Time.Hora.Some

-- | yyyy-mm-dd
iso :: [Format]

-- | yyyymmdd
ymd :: [Format]

-- | time.fraction no trailing 0 - varying length
--   
--   09:10:58.030311306
tf :: [Format]

-- | time
--   
--   09:11:18
t :: [Format]

-- | date, time
--   
--   2016-12-14 09:16:23
dt :: [Format]


-- | to get timezone-series data, see <a>timezone-olson</a>
--   
--   see also <a>timezone-series</a>
--   
--   for complete example with olson, see Test.TestZone in this package
--   
--   <pre>
--   import Data.Time.LocalTime.TimeZone.Olson
--   
--   -- see man tzfile for common olson file locations
--   getTimeZoneSeriesFromOlsonFile "/usr/share/zoneinfo/Chile/Continental" &gt;&gt;=
--       \(chile1::TimeZoneSeries) -&gt; ...            
--   </pre>
module Data.Time.Hora.Zone

-- | convert <a>DatePart</a> from one <tt>TimeZone</tt> to another
toTimeZone :: (TwoInt a b, Tz' tz) => tz -> (Tz (DatePart a)) -> (Maybe (Tz (DatePart b)))