Duration

duration.hs

{-# LANGUAGE FlexibleInstances, PostfixOperators, GeneralizedNewtypeDeriving #-}

module Data.Duration 
    ( Duration
    , seconds
    , second
    , minutes
    , minute
    , hours
    , hour
    , days
    , day
    , weeks
    , week
    , toMillis
    , toSeconds
    , toMinutes
    , toHours
    , toDays
    , toWeeks
    ) where

data Milliseconds
data Seconds
data Minutes
data Hours
data Days
data Weeks

newtype Duration a = Duration Int deriving (Num, Eq, Ord)

instance Show (Duration Milliseconds) where
    show (Duration 1) = "1 Millisecond"
    show (Duration i) = (show i) ++ " Milliseconds"
    
instance Show (Duration Seconds) where
    show (Duration 1) = "1 Second"
    show (Duration i) = (show i) ++ " Seconds"
    
instance Show (Duration Minutes) where
    show (Duration 1) = "1 Minute"
    show (Duration i) = (show i) ++ " Minutes"
    
instance Show (Duration Hours) where
    show (Duration 1) = "1 Hour"
    show (Duration i) = (show i) ++ " Hours"
    
instance Show (Duration Days) where
    show (Duration 1) = "1 Day"
    show (Duration i) = (show i) ++ " Days"
    
instance Show (Duration Weeks) where
    show (Duration 1) = "1 Week"
    show (Duration i) = (show i) ++ " Weeks"

class CanConvertToMillis t where
    toMillis :: t -> Int
    
instance CanConvertToMillis (Duration Milliseconds) where
    toMillis (Duration i) = i
    
instance CanConvertToMillis (Duration Seconds) where
    toMillis (Duration i) = i * 1000
    
instance CanConvertToMillis (Duration Minutes) where
    toMillis (Duration i) = i * 60000
    
instance CanConvertToMillis (Duration Hours) where
    toMillis (Duration i) = i * 360000
    
instance CanConvertToMillis (Duration Days) where
    toMillis (Duration i) = i * 8640000
    
instance CanConvertToMillis (Duration Weeks) where
    toMillis (Duration i) = i * 60480000

class CanConvertToSeconds t where
    toSeconds :: t -> Int
    
instance CanConvertToSeconds (Duration Milliseconds) where
    toSeconds (Duration i) = i `div` 1000
    
instance CanConvertToSeconds (Duration Seconds) where
    toSeconds (Duration i) = i
    
instance CanConvertToSeconds (Duration Minutes) where
    toSeconds (Duration i) = i * 60
    
instance CanConvertToSeconds (Duration Hours) where
    toSeconds (Duration i) = i * 360
    
instance CanConvertToSeconds (Duration Days) where
    toSeconds (Duration i) = i * 8640
    
instance CanConvertToSeconds (Duration Weeks) where
    toSeconds (Duration i) = i * 60480

class CanConvertToMinutes t where
    toMinutes :: t -> Int
    
instance CanConvertToMinutes (Duration Milliseconds) where
    toMinutes (Duration i) = i `div` 60000
    
instance CanConvertToMinutes (Duration Seconds) where
    toMinutes (Duration i) = i `div` 60
    
instance CanConvertToMinutes (Duration Minutes) where
    toMinutes (Duration i) = i
    
instance CanConvertToMinutes (Duration Hours) where
    toMinutes (Duration i) = i * 60
    
instance CanConvertToMinutes (Duration Days) where
    toMinutes (Duration i) = i * 1440
    
instance CanConvertToMinutes (Duration Weeks) where
    toMinutes (Duration i) = i * 10080

class CanConvertToHours t where
    toHours :: t -> Int
    
instance CanConvertToHours (Duration Milliseconds) where
    toHours (Duration i) = i `div` 360000
    
instance CanConvertToHours (Duration Seconds) where
    toHours (Duration i) = i `div` 360
    
instance CanConvertToHours (Duration Minutes) where
    toHours (Duration i) = i `div` 60
    
instance CanConvertToHours (Duration Hours) where
    toHours (Duration i) = i
    
instance CanConvertToHours (Duration Days) where
    toHours (Duration i) = i * 24
    
instance CanConvertToHours (Duration Weeks) where
    toHours (Duration i) = i * 168

class CanConvertToDays t where
    toDays :: t -> Int
    
instance CanConvertToDays (Duration Milliseconds) where
    toDays (Duration i) = i `div` 86400000
    
instance CanConvertToDays (Duration Seconds) where
    toDays (Duration i) = i `div` 86400
    
instance CanConvertToDays (Duration Minutes) where
    toDays (Duration i) = i `div` 1440
    
instance CanConvertToDays (Duration Hours) where
    toDays (Duration i) = i `div` 24
    
instance CanConvertToDays (Duration Days) where
    toDays (Duration i) = i
    
instance CanConvertToDays (Duration Weeks) where
    toDays (Duration i) = i * 7

class CanConvertToWeeks t where
    toWeeks :: t -> Int
    
instance CanConvertToWeeks (Duration Milliseconds) where
    toWeeks (Duration i) = i `div` 604800000
    
instance CanConvertToWeeks (Duration Seconds) where
    toWeeks (Duration i) = i `div` 604800
    
instance CanConvertToWeeks (Duration Minutes) where
    toWeeks (Duration i) = i `div` 10080
    
instance CanConvertToWeeks (Duration Hours) where
    toWeeks (Duration i) = i `div` 168
    
instance CanConvertToWeeks (Duration Days) where
    toWeeks (Duration i) = i `div` 7
    
instance CanConvertToWeeks (Duration Weeks) where
    toWeeks (Duration i) = i

milliseconds :: Int -> Duration Milliseconds
milliseconds i = Duration i

millisecond :: Int -> Duration Milliseconds
millisecond i = Duration i

seconds :: Int -> Duration Seconds
seconds i = Duration i

second :: Int -> Duration Seconds
second i = Duration i

minutes :: Int -> Duration Minutes
minutes i = Duration i

minute :: Int -> Duration Minutes
minute i = Duration i

hours :: Int -> Duration Hours
hours i = Duration i

hour :: Int -> Duration Hours
hour i = Duration i

days :: Int -> Duration Days
days i = Duration i

day :: Int -> Duration Days
day i = Duration i

weeks :: Int -> Duration Weeks
weeks i = Duration i

week :: Int -> Duration Weeks
week i = Duration i

{-
withTtl :: Result -> Duration a -> Result
withTtl d r = withHeaders result [("Surrogate-Control", "max-age=" + (show $ toSeconds d))]

withTtl (2 `minutes`) result
-}