{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveLift #-}

module Temporal.Common.TimeoutType where

import Data.Data (Data)
import Language.Haskell.TH.Syntax (Lift)
import Temporal.Duration


{- | An Activity Execution must have either this timeout (Start-To-Close) or the Schedule-To-Close Timeout set.
We recommend always setting this timeout; however, make sure that Start-To-Close Timeout is always set to be
longer than the maximum possible time for the Activity Execution to complete. For long running Activity Executions,
we recommend also using Activity Heartbeats and Heartbeat Timeouts.

Tip: We strongly recommend setting a Start-To-Close Timeout.

The Temporal Server doesn't detect failures when a Worker loses communication with the Server or crashes. Therefore, the Temporal Server relies on the Start-To-Close Timeout to force Activity retries.
-}
newtype StartToClose = StartToClose Duration
  deriving stock (StartToClose -> StartToClose -> Bool
(StartToClose -> StartToClose -> Bool)
-> (StartToClose -> StartToClose -> Bool) -> Eq StartToClose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StartToClose -> StartToClose -> Bool
== :: StartToClose -> StartToClose -> Bool
$c/= :: StartToClose -> StartToClose -> Bool
/= :: StartToClose -> StartToClose -> Bool
Eq, Eq StartToClose
Eq StartToClose =>
(StartToClose -> StartToClose -> Ordering)
-> (StartToClose -> StartToClose -> Bool)
-> (StartToClose -> StartToClose -> Bool)
-> (StartToClose -> StartToClose -> Bool)
-> (StartToClose -> StartToClose -> Bool)
-> (StartToClose -> StartToClose -> StartToClose)
-> (StartToClose -> StartToClose -> StartToClose)
-> Ord StartToClose
StartToClose -> StartToClose -> Bool
StartToClose -> StartToClose -> Ordering
StartToClose -> StartToClose -> StartToClose
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StartToClose -> StartToClose -> Ordering
compare :: StartToClose -> StartToClose -> Ordering
$c< :: StartToClose -> StartToClose -> Bool
< :: StartToClose -> StartToClose -> Bool
$c<= :: StartToClose -> StartToClose -> Bool
<= :: StartToClose -> StartToClose -> Bool
$c> :: StartToClose -> StartToClose -> Bool
> :: StartToClose -> StartToClose -> Bool
$c>= :: StartToClose -> StartToClose -> Bool
>= :: StartToClose -> StartToClose -> Bool
$cmax :: StartToClose -> StartToClose -> StartToClose
max :: StartToClose -> StartToClose -> StartToClose
$cmin :: StartToClose -> StartToClose -> StartToClose
min :: StartToClose -> StartToClose -> StartToClose
Ord, Int -> StartToClose -> ShowS
[StartToClose] -> ShowS
StartToClose -> String
(Int -> StartToClose -> ShowS)
-> (StartToClose -> String)
-> ([StartToClose] -> ShowS)
-> Show StartToClose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StartToClose -> ShowS
showsPrec :: Int -> StartToClose -> ShowS
$cshow :: StartToClose -> String
show :: StartToClose -> String
$cshowList :: [StartToClose] -> ShowS
showList :: [StartToClose] -> ShowS
Show, (forall (m :: * -> *). Quote m => StartToClose -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    StartToClose -> Code m StartToClose)
-> Lift StartToClose
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => StartToClose -> m Exp
forall (m :: * -> *).
Quote m =>
StartToClose -> Code m StartToClose
$clift :: forall (m :: * -> *). Quote m => StartToClose -> m Exp
lift :: forall (m :: * -> *). Quote m => StartToClose -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
StartToClose -> Code m StartToClose
liftTyped :: forall (m :: * -> *).
Quote m =>
StartToClose -> Code m StartToClose
Lift, Typeable StartToClose
Typeable StartToClose =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> StartToClose -> c StartToClose)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StartToClose)
-> (StartToClose -> Constr)
-> (StartToClose -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StartToClose))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StartToClose))
-> ((forall b. Data b => b -> b) -> StartToClose -> StartToClose)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StartToClose -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StartToClose -> r)
-> (forall u. (forall d. Data d => d -> u) -> StartToClose -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StartToClose -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StartToClose -> m StartToClose)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StartToClose -> m StartToClose)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StartToClose -> m StartToClose)
-> Data StartToClose
StartToClose -> Constr
StartToClose -> DataType
(forall b. Data b => b -> b) -> StartToClose -> StartToClose
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> StartToClose -> u
forall u. (forall d. Data d => d -> u) -> StartToClose -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StartToClose -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StartToClose -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StartToClose
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StartToClose -> c StartToClose
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StartToClose)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StartToClose)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StartToClose -> c StartToClose
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StartToClose -> c StartToClose
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StartToClose
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StartToClose
$ctoConstr :: StartToClose -> Constr
toConstr :: StartToClose -> Constr
$cdataTypeOf :: StartToClose -> DataType
dataTypeOf :: StartToClose -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StartToClose)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StartToClose)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StartToClose)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StartToClose)
$cgmapT :: (forall b. Data b => b -> b) -> StartToClose -> StartToClose
gmapT :: (forall b. Data b => b -> b) -> StartToClose -> StartToClose
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StartToClose -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StartToClose -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StartToClose -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StartToClose -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StartToClose -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> StartToClose -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StartToClose -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StartToClose -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StartToClose -> m StartToClose
Data)


{- | A Schedule-To-Close Timeout is the maximum amount of time allowed for the overall Activity Execution, from when the first Activity Task is scheduled to when the last Activity
Task, in the chain of Activity Tasks that make up the Activity Execution, reaches a Closed status.

An Activity Execution must have either this timeout (Schedule-To-Close) or Start-To-Close set. By default, an Activity Execution Retry Policy dictates that retries occur for up to 10 years.
This timeout can be used to control the overall duration of an Activity Execution in the face of failures (repeated Activity Task Executions), without altering the Maximum Attempts field of the Retry Policy.
-}
newtype ScheduleToClose = ScheduleToClose Duration
  deriving stock (ScheduleToClose -> ScheduleToClose -> Bool
(ScheduleToClose -> ScheduleToClose -> Bool)
-> (ScheduleToClose -> ScheduleToClose -> Bool)
-> Eq ScheduleToClose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScheduleToClose -> ScheduleToClose -> Bool
== :: ScheduleToClose -> ScheduleToClose -> Bool
$c/= :: ScheduleToClose -> ScheduleToClose -> Bool
/= :: ScheduleToClose -> ScheduleToClose -> Bool
Eq, Eq ScheduleToClose
Eq ScheduleToClose =>
(ScheduleToClose -> ScheduleToClose -> Ordering)
-> (ScheduleToClose -> ScheduleToClose -> Bool)
-> (ScheduleToClose -> ScheduleToClose -> Bool)
-> (ScheduleToClose -> ScheduleToClose -> Bool)
-> (ScheduleToClose -> ScheduleToClose -> Bool)
-> (ScheduleToClose -> ScheduleToClose -> ScheduleToClose)
-> (ScheduleToClose -> ScheduleToClose -> ScheduleToClose)
-> Ord ScheduleToClose
ScheduleToClose -> ScheduleToClose -> Bool
ScheduleToClose -> ScheduleToClose -> Ordering
ScheduleToClose -> ScheduleToClose -> ScheduleToClose
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ScheduleToClose -> ScheduleToClose -> Ordering
compare :: ScheduleToClose -> ScheduleToClose -> Ordering
$c< :: ScheduleToClose -> ScheduleToClose -> Bool
< :: ScheduleToClose -> ScheduleToClose -> Bool
$c<= :: ScheduleToClose -> ScheduleToClose -> Bool
<= :: ScheduleToClose -> ScheduleToClose -> Bool
$c> :: ScheduleToClose -> ScheduleToClose -> Bool
> :: ScheduleToClose -> ScheduleToClose -> Bool
$c>= :: ScheduleToClose -> ScheduleToClose -> Bool
>= :: ScheduleToClose -> ScheduleToClose -> Bool
$cmax :: ScheduleToClose -> ScheduleToClose -> ScheduleToClose
max :: ScheduleToClose -> ScheduleToClose -> ScheduleToClose
$cmin :: ScheduleToClose -> ScheduleToClose -> ScheduleToClose
min :: ScheduleToClose -> ScheduleToClose -> ScheduleToClose
Ord, Int -> ScheduleToClose -> ShowS
[ScheduleToClose] -> ShowS
ScheduleToClose -> String
(Int -> ScheduleToClose -> ShowS)
-> (ScheduleToClose -> String)
-> ([ScheduleToClose] -> ShowS)
-> Show ScheduleToClose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScheduleToClose -> ShowS
showsPrec :: Int -> ScheduleToClose -> ShowS
$cshow :: ScheduleToClose -> String
show :: ScheduleToClose -> String
$cshowList :: [ScheduleToClose] -> ShowS
showList :: [ScheduleToClose] -> ShowS
Show, (forall (m :: * -> *). Quote m => ScheduleToClose -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    ScheduleToClose -> Code m ScheduleToClose)
-> Lift ScheduleToClose
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => ScheduleToClose -> m Exp
forall (m :: * -> *).
Quote m =>
ScheduleToClose -> Code m ScheduleToClose
$clift :: forall (m :: * -> *). Quote m => ScheduleToClose -> m Exp
lift :: forall (m :: * -> *). Quote m => ScheduleToClose -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
ScheduleToClose -> Code m ScheduleToClose
liftTyped :: forall (m :: * -> *).
Quote m =>
ScheduleToClose -> Code m ScheduleToClose
Lift, Typeable ScheduleToClose
Typeable ScheduleToClose =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ScheduleToClose -> c ScheduleToClose)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ScheduleToClose)
-> (ScheduleToClose -> Constr)
-> (ScheduleToClose -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ScheduleToClose))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ScheduleToClose))
-> ((forall b. Data b => b -> b)
    -> ScheduleToClose -> ScheduleToClose)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ScheduleToClose -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ScheduleToClose -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ScheduleToClose -> m ScheduleToClose)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ScheduleToClose -> m ScheduleToClose)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ScheduleToClose -> m ScheduleToClose)
-> Data ScheduleToClose
ScheduleToClose -> Constr
ScheduleToClose -> DataType
(forall b. Data b => b -> b) -> ScheduleToClose -> ScheduleToClose
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ScheduleToClose -> u
forall u. (forall d. Data d => d -> u) -> ScheduleToClose -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScheduleToClose
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScheduleToClose -> c ScheduleToClose
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScheduleToClose)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ScheduleToClose)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScheduleToClose -> c ScheduleToClose
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScheduleToClose -> c ScheduleToClose
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScheduleToClose
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScheduleToClose
$ctoConstr :: ScheduleToClose -> Constr
toConstr :: ScheduleToClose -> Constr
$cdataTypeOf :: ScheduleToClose -> DataType
dataTypeOf :: ScheduleToClose -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScheduleToClose)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScheduleToClose)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ScheduleToClose)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ScheduleToClose)
$cgmapT :: (forall b. Data b => b -> b) -> ScheduleToClose -> ScheduleToClose
gmapT :: (forall b. Data b => b -> b) -> ScheduleToClose -> ScheduleToClose
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ScheduleToClose -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ScheduleToClose -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ScheduleToClose -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ScheduleToClose -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ScheduleToClose -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ScheduleToClose -> m ScheduleToClose
Data)