    {-# LANGUAGE DeriveDataTypeable, PatternGuards #-}

    -- | Types exposed to the user
    module Development.Shake.Internal.Options(
        Progress(..), Verbosity(..), Rebuild(..), Lint(..), Change(..),
        ShakeOptions(..), shakeOptions,
        -- Internal stuff
        shakeRebuildApply, shakeAbbreviationsApply, shakeOptionsFields
        ) where

    import Data.Data
    import Data.List.Extra
    import Data.Tuple.Extra
    import Data.Maybe
    import Data.Dynamic
    import Control.Monad
    import General.Extra
    import System.Time.Extra
    import qualified Data.HashMap.Strict as Map
    import Development.Shake.Internal.FilePattern
    import Development.Shake.Internal.Errors
    import qualified Data.ByteString.Char8 as BS
    import qualified Data.ByteString.UTF8 as UTF8
    import Development.Shake.Internal.CmdOption
    import Data.Semigroup
    import Prelude

    -- | The current assumptions made by the build system, used by 'shakeRebuild'. These options
    --   allow the end user to specify that any rules run are either to be treated as clean, or as
    --   dirty, regardless of what the build system thinks.
    --
    --   These assumptions only operate on files reached by the current 'Development.Shake.action' commands. Any
    --   other files in the database are left unchanged.
    data Rebuild
        = RebuildNow
            -- ^ Assume these files are dirty and require rebuilding.
            --   for benchmarking rebuild speed and for rebuilding if untracked dependencies have changed.
            --   This flag is safe, but may cause more rebuilding than necessary.
        | RebuildNormal
            -- ^ Useful to reset the rebuild status to how it was before, equivalent to passing no 'Rebuild' flags.
        | RebuildLater
            -- ^ /This assumption is unsafe, and may lead to incorrect build results in this run/.
            --   Assume these files are clean in this run, but test them normally in future runs.
    {-
        | RebuildNever
            -- Add to RebuildNow: Useful to undo the results of 'RebuildNever',
            -- ^ /This assumption is unsafe, and may lead to incorrect build results in this run, and in future runs/.
            --   Assume and record that these files are clean and do not require rebuilding, provided the file
            --   has been built before. Useful if you have modified a file in some
            --   inconsequential way, such as only the comments or whitespace, and wish to avoid a rebuild.
    -}
          deriving (Rebuild -> Rebuild -> Bool
    (Rebuild -> Rebuild -> Bool)
    -> (Rebuild -> Rebuild -> Bool) -> Eq Rebuild
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Rebuild -> Rebuild -> Bool
    == :: Rebuild -> Rebuild -> Bool
    $c/= :: Rebuild -> Rebuild -> Bool
    /= :: Rebuild -> Rebuild -> Bool
    Eq,Eq Rebuild
    Eq Rebuild
    -> (Rebuild -> Rebuild -> Ordering)
    -> (Rebuild -> Rebuild -> Bool)
    -> (Rebuild -> Rebuild -> Bool)
    -> (Rebuild -> Rebuild -> Bool)
    -> (Rebuild -> Rebuild -> Bool)
    -> (Rebuild -> Rebuild -> Rebuild)
    -> (Rebuild -> Rebuild -> Rebuild)
    -> Ord Rebuild
    Rebuild -> Rebuild -> Bool
    Rebuild -> Rebuild -> Ordering
    Rebuild -> Rebuild -> Rebuild
    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 :: Rebuild -> Rebuild -> Ordering
    compare :: Rebuild -> Rebuild -> Ordering
    $c< :: Rebuild -> Rebuild -> Bool
    < :: Rebuild -> Rebuild -> Bool
    $c<= :: Rebuild -> Rebuild -> Bool
    <= :: Rebuild -> Rebuild -> Bool
    $c> :: Rebuild -> Rebuild -> Bool
    > :: Rebuild -> Rebuild -> Bool
    $c>= :: Rebuild -> Rebuild -> Bool
    >= :: Rebuild -> Rebuild -> Bool
    $cmax :: Rebuild -> Rebuild -> Rebuild
    max :: Rebuild -> Rebuild -> Rebuild
    $cmin :: Rebuild -> Rebuild -> Rebuild
    min :: Rebuild -> Rebuild -> Rebuild
    Ord,Int -> Rebuild -> ShowS
    [Rebuild] -> ShowS
    Rebuild -> String
    (Int -> Rebuild -> ShowS)
    -> (Rebuild -> String) -> ([Rebuild] -> ShowS) -> Show Rebuild
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Rebuild -> ShowS
    showsPrec :: Int -> Rebuild -> ShowS
    $cshow :: Rebuild -> String
    show :: Rebuild -> String
    $cshowList :: [Rebuild] -> ShowS
    showList :: [Rebuild] -> ShowS
    Show,ReadPrec [Rebuild]
    ReadPrec Rebuild
    Int -> ReadS Rebuild
    ReadS [Rebuild]
    (Int -> ReadS Rebuild)
    -> ReadS [Rebuild]
    -> ReadPrec Rebuild
    -> ReadPrec [Rebuild]
    -> Read Rebuild
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Rebuild
    readsPrec :: Int -> ReadS Rebuild
    $creadList :: ReadS [Rebuild]
    readList :: ReadS [Rebuild]
    $creadPrec :: ReadPrec Rebuild
    readPrec :: ReadPrec Rebuild
    $creadListPrec :: ReadPrec [Rebuild]
    readListPrec :: ReadPrec [Rebuild]
    Read,Typeable,Typeable Rebuild
    Typeable Rebuild
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Rebuild -> c Rebuild)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Rebuild)
    -> (Rebuild -> Constr)
    -> (Rebuild -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Rebuild))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rebuild))
    -> ((forall b. Data b => b -> b) -> Rebuild -> Rebuild)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Rebuild -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Rebuild -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Rebuild -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Rebuild -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild)
    -> Data Rebuild
    Rebuild -> Constr
    Rebuild -> DataType
    (forall b. Data b => b -> b) -> Rebuild -> Rebuild
    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) -> Rebuild -> u
    forall u. (forall d. Data d => d -> u) -> Rebuild -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Rebuild -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Rebuild -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Rebuild
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rebuild -> c Rebuild
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Rebuild)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rebuild)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rebuild -> c Rebuild
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rebuild -> c Rebuild
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Rebuild
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Rebuild
    $ctoConstr :: Rebuild -> Constr
    toConstr :: Rebuild -> Constr
    $cdataTypeOf :: Rebuild -> DataType
    dataTypeOf :: Rebuild -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Rebuild)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Rebuild)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rebuild)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rebuild)
    $cgmapT :: (forall b. Data b => b -> b) -> Rebuild -> Rebuild
    gmapT :: (forall b. Data b => b -> b) -> Rebuild -> Rebuild
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Rebuild -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Rebuild -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Rebuild -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Rebuild -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Rebuild -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Rebuild -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rebuild -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rebuild -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rebuild -> m Rebuild
    Data,Int -> Rebuild
    Rebuild -> Int
    Rebuild -> [Rebuild]
    Rebuild -> Rebuild
    Rebuild -> Rebuild -> [Rebuild]
    Rebuild -> Rebuild -> Rebuild -> [Rebuild]
    (Rebuild -> Rebuild)
    -> (Rebuild -> Rebuild)
    -> (Int -> Rebuild)
    -> (Rebuild -> Int)
    -> (Rebuild -> [Rebuild])
    -> (Rebuild -> Rebuild -> [Rebuild])
    -> (Rebuild -> Rebuild -> [Rebuild])
    -> (Rebuild -> Rebuild -> Rebuild -> [Rebuild])
    -> Enum Rebuild
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Rebuild -> Rebuild
    succ :: Rebuild -> Rebuild
    $cpred :: Rebuild -> Rebuild
    pred :: Rebuild -> Rebuild
    $ctoEnum :: Int -> Rebuild
    toEnum :: Int -> Rebuild
    $cfromEnum :: Rebuild -> Int
    fromEnum :: Rebuild -> Int
    $cenumFrom :: Rebuild -> [Rebuild]
    enumFrom :: Rebuild -> [Rebuild]
    $cenumFromThen :: Rebuild -> Rebuild -> [Rebuild]
    enumFromThen :: Rebuild -> Rebuild -> [Rebuild]
    $cenumFromTo :: Rebuild -> Rebuild -> [Rebuild]
    enumFromTo :: Rebuild -> Rebuild -> [Rebuild]
    $cenumFromThenTo :: Rebuild -> Rebuild -> Rebuild -> [Rebuild]
    enumFromThenTo :: Rebuild -> Rebuild -> Rebuild -> [Rebuild]
    Enum,Rebuild
    Rebuild -> Rebuild -> Bounded Rebuild
    forall a. a -> a -> Bounded a
    $cminBound :: Rebuild
    minBound :: Rebuild
    $cmaxBound :: Rebuild
    maxBound :: Rebuild
    Bounded)

    -- | Which lint checks to perform, used by 'shakeLint'.
    data Lint
        = LintBasic
            -- ^ The most basic form of linting. Checks that the current directory does not change and that results do not change after they
            --   are first written. Any calls to 'needed' will assert that they do not cause a rule to be rebuilt.
        | LintFSATrace
            -- ^ Track which files are accessed by command line programs
            -- using <https://github.com/jacereda/fsatrace fsatrace>.
          deriving (Lint -> Lint -> Bool
    (Lint -> Lint -> Bool) -> (Lint -> Lint -> Bool) -> Eq Lint
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Lint -> Lint -> Bool
    == :: Lint -> Lint -> Bool
    $c/= :: Lint -> Lint -> Bool
    /= :: Lint -> Lint -> Bool
    Eq,Eq Lint
    Eq Lint
    -> (Lint -> Lint -> Ordering)
    -> (Lint -> Lint -> Bool)
    -> (Lint -> Lint -> Bool)
    -> (Lint -> Lint -> Bool)
    -> (Lint -> Lint -> Bool)
    -> (Lint -> Lint -> Lint)
    -> (Lint -> Lint -> Lint)
    -> Ord Lint
    Lint -> Lint -> Bool
    Lint -> Lint -> Ordering
    Lint -> Lint -> Lint
    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 :: Lint -> Lint -> Ordering
    compare :: Lint -> Lint -> Ordering
    $c< :: Lint -> Lint -> Bool
    < :: Lint -> Lint -> Bool
    $c<= :: Lint -> Lint -> Bool
    <= :: Lint -> Lint -> Bool
    $c> :: Lint -> Lint -> Bool
    > :: Lint -> Lint -> Bool
    $c>= :: Lint -> Lint -> Bool
    >= :: Lint -> Lint -> Bool
    $cmax :: Lint -> Lint -> Lint
    max :: Lint -> Lint -> Lint
    $cmin :: Lint -> Lint -> Lint
    min :: Lint -> Lint -> Lint
    Ord,Int -> Lint -> ShowS
    [Lint] -> ShowS
    Lint -> String
    (Int -> Lint -> ShowS)
    -> (Lint -> String) -> ([Lint] -> ShowS) -> Show Lint
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Lint -> ShowS
    showsPrec :: Int -> Lint -> ShowS
    $cshow :: Lint -> String
    show :: Lint -> String
    $cshowList :: [Lint] -> ShowS
    showList :: [Lint] -> ShowS
    Show,ReadPrec [Lint]
    ReadPrec Lint
    Int -> ReadS Lint
    ReadS [Lint]
    (Int -> ReadS Lint)
    -> ReadS [Lint] -> ReadPrec Lint -> ReadPrec [Lint] -> Read Lint
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Lint
    readsPrec :: Int -> ReadS Lint
    $creadList :: ReadS [Lint]
    readList :: ReadS [Lint]
    $creadPrec :: ReadPrec Lint
    readPrec :: ReadPrec Lint
    $creadListPrec :: ReadPrec [Lint]
    readListPrec :: ReadPrec [Lint]
    Read,Typeable,Typeable Lint
    Typeable Lint
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Lint -> c Lint)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Lint)
    -> (Lint -> Constr)
    -> (Lint -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Lint))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lint))
    -> ((forall b. Data b => b -> b) -> Lint -> Lint)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Lint -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Lint -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Lint -> m Lint)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Lint -> m Lint)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Lint -> m Lint)
    -> Data Lint
    Lint -> Constr
    Lint -> DataType
    (forall b. Data b => b -> b) -> Lint -> Lint
    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) -> Lint -> u
    forall u. (forall d. Data d => d -> u) -> Lint -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lint
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lint -> c Lint
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lint)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lint)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lint -> c Lint
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lint -> c Lint
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lint
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lint
    $ctoConstr :: Lint -> Constr
    toConstr :: Lint -> Constr
    $cdataTypeOf :: Lint -> DataType
    dataTypeOf :: Lint -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lint)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lint)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lint)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lint)
    $cgmapT :: (forall b. Data b => b -> b) -> Lint -> Lint
    gmapT :: (forall b. Data b => b -> b) -> Lint -> Lint
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lint -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Lint -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Lint -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lint -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lint -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lint -> m Lint
    Data,Int -> Lint
    Lint -> Int
    Lint -> [Lint]
    Lint -> Lint
    Lint -> Lint -> [Lint]
    Lint -> Lint -> Lint -> [Lint]
    (Lint -> Lint)
    -> (Lint -> Lint)
    -> (Int -> Lint)
    -> (Lint -> Int)
    -> (Lint -> [Lint])
    -> (Lint -> Lint -> [Lint])
    -> (Lint -> Lint -> [Lint])
    -> (Lint -> Lint -> Lint -> [Lint])
    -> Enum Lint
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Lint -> Lint
    succ :: Lint -> Lint
    $cpred :: Lint -> Lint
    pred :: Lint -> Lint
    $ctoEnum :: Int -> Lint
    toEnum :: Int -> Lint
    $cfromEnum :: Lint -> Int
    fromEnum :: Lint -> Int
    $cenumFrom :: Lint -> [Lint]
    enumFrom :: Lint -> [Lint]
    $cenumFromThen :: Lint -> Lint -> [Lint]
    enumFromThen :: Lint -> Lint -> [Lint]
    $cenumFromTo :: Lint -> Lint -> [Lint]
    enumFromTo :: Lint -> Lint -> [Lint]
    $cenumFromThenTo :: Lint -> Lint -> Lint -> [Lint]
    enumFromThenTo :: Lint -> Lint -> Lint -> [Lint]
    Enum,Lint
    Lint -> Lint -> Bounded Lint
    forall a. a -> a -> Bounded a
    $cminBound :: Lint
    minBound :: Lint
    $cmaxBound :: Lint
    maxBound :: Lint
    Bounded)

    -- | How should you determine if a file has changed, used by 'shakeChange'. The most common values are
    --   'ChangeModtime' (the default, very fast, @touch@ causes files to rebuild) and 'ChangeModtimeAndDigestInput'
    --   (slightly slower, @touch@ and switching @git@ branches does not cause input files to rebuild).
    data Change
        = ChangeModtime
            -- ^ Compare equality of modification timestamps, a file has changed if its last modified time changes.
            --   A @touch@ will force a rebuild. This mode is fast and usually sufficiently accurate, so is the default.
        | ChangeDigest
            -- ^ Compare equality of file contents digests, a file has changed if its digest changes.
            --   A @touch@ will not force a rebuild. Use this mode if modification times on your file system are unreliable.
        | ChangeModtimeAndDigest
            -- ^ A file is rebuilt if both its modification time and digest have changed. For efficiency reasons, the modification
            --   time is checked first, and if that has changed, the digest is checked.
        | ChangeModtimeAndDigestInput
            -- ^ Use 'ChangeModtimeAndDigest' for input\/source files and 'ChangeModtime' for output files.
            --   An input file is one which is a dependency but is not built by Shake as it has no
            --   matching rule and already exists on the file system.
        | ChangeModtimeOrDigest
            -- ^ A file is rebuilt if either its modification time or its digest has changed. A @touch@ will force a rebuild,
            --   but even if a files modification time is reset afterwards, changes will also cause a rebuild.
          deriving (Change -> Change -> Bool
    (Change -> Change -> Bool)
    -> (Change -> Change -> Bool) -> Eq Change
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Change -> Change -> Bool
    == :: Change -> Change -> Bool
    $c/= :: Change -> Change -> Bool
    /= :: Change -> Change -> Bool
    Eq,Eq Change
    Eq Change
    -> (Change -> Change -> Ordering)
    -> (Change -> Change -> Bool)
    -> (Change -> Change -> Bool)
    -> (Change -> Change -> Bool)
    -> (Change -> Change -> Bool)
    -> (Change -> Change -> Change)
    -> (Change -> Change -> Change)
    -> Ord Change
    Change -> Change -> Bool
    Change -> Change -> Ordering
    Change -> Change -> Change
    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 :: Change -> Change -> Ordering
    compare :: Change -> Change -> Ordering
    $c< :: Change -> Change -> Bool
    < :: Change -> Change -> Bool
    $c<= :: Change -> Change -> Bool
    <= :: Change -> Change -> Bool
    $c> :: Change -> Change -> Bool
    > :: Change -> Change -> Bool
    $c>= :: Change -> Change -> Bool
    >= :: Change -> Change -> Bool
    $cmax :: Change -> Change -> Change
    max :: Change -> Change -> Change
    $cmin :: Change -> Change -> Change
    min :: Change -> Change -> Change
    Ord,Int -> Change -> ShowS
    [Change] -> ShowS
    Change -> String
    (Int -> Change -> ShowS)
    -> (Change -> String) -> ([Change] -> ShowS) -> Show Change
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Change -> ShowS
    showsPrec :: Int -> Change -> ShowS
    $cshow :: Change -> String
    show :: Change -> String
    $cshowList :: [Change] -> ShowS
    showList :: [Change] -> ShowS
    Show,ReadPrec [Change]
    ReadPrec Change
    Int -> ReadS Change
    ReadS [Change]
    (Int -> ReadS Change)
    -> ReadS [Change]
    -> ReadPrec Change
    -> ReadPrec [Change]
    -> Read Change
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Change
    readsPrec :: Int -> ReadS Change
    $creadList :: ReadS [Change]
    readList :: ReadS [Change]
    $creadPrec :: ReadPrec Change
    readPrec :: ReadPrec Change
    $creadListPrec :: ReadPrec [Change]
    readListPrec :: ReadPrec [Change]
    Read,Typeable,Typeable Change
    Typeable Change
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Change -> c Change)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Change)
    -> (Change -> Constr)
    -> (Change -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Change))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Change))
    -> ((forall b. Data b => b -> b) -> Change -> Change)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Change -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Change -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Change -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Change -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Change -> m Change)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Change -> m Change)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Change -> m Change)
    -> Data Change
    Change -> Constr
    Change -> DataType
    (forall b. Data b => b -> b) -> Change -> Change
    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) -> Change -> u
    forall u. (forall d. Data d => d -> u) -> Change -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Change
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Change -> c Change
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Change)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Change)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Change -> c Change
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Change -> c Change
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Change
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Change
    $ctoConstr :: Change -> Constr
    toConstr :: Change -> Constr
    $cdataTypeOf :: Change -> DataType
    dataTypeOf :: Change -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Change)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Change)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Change)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Change)
    $cgmapT :: (forall b. Data b => b -> b) -> Change -> Change
    gmapT :: (forall b. Data b => b -> b) -> Change -> Change
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Change -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Change -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Change -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Change -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Change -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Change -> m Change
    Data,Int -> Change
    Change -> Int
    Change -> [Change]
    Change -> Change
    Change -> Change -> [Change]
    Change -> Change -> Change -> [Change]
    (Change -> Change)
    -> (Change -> Change)
    -> (Int -> Change)
    -> (Change -> Int)
    -> (Change -> [Change])
    -> (Change -> Change -> [Change])
    -> (Change -> Change -> [Change])
    -> (Change -> Change -> Change -> [Change])
    -> Enum Change
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Change -> Change
    succ :: Change -> Change
    $cpred :: Change -> Change
    pred :: Change -> Change
    $ctoEnum :: Int -> Change
    toEnum :: Int -> Change
    $cfromEnum :: Change -> Int
    fromEnum :: Change -> Int
    $cenumFrom :: Change -> [Change]
    enumFrom :: Change -> [Change]
    $cenumFromThen :: Change -> Change -> [Change]
    enumFromThen :: Change -> Change -> [Change]
    $cenumFromTo :: Change -> Change -> [Change]
    enumFromTo :: Change -> Change -> [Change]
    $cenumFromThenTo :: Change -> Change -> Change -> [Change]
    enumFromThenTo :: Change -> Change -> Change -> [Change]
    Enum,Change
    Change -> Change -> Bounded Change
    forall a. a -> a -> Bounded a
    $cminBound :: Change
    minBound :: Change
    $cmaxBound :: Change
    maxBound :: Change
    Bounded)

    -- | Information about the current state of the build, obtained by either passing a callback function
    --   to 'Development.Shake.shakeProgress' (asynchronous output) or 'Development.Shake.getProgress'
    --   (synchronous output). Typically a build system will pass 'progressDisplay' to 'Development.Shake.shakeProgress',
    --   which will poll this value and produce status messages.
    data Progress = Progress
    -- In retrospect shakeProgress should have been done differently, as a feature you turn on in Rules
    -- but easiest way around that for now is put the Progress type in Options

        {Progress -> Maybe String
    isFailure :: !(Maybe String) -- ^ Starts out 'Nothing', becomes 'Just' a target name if a rule fails.
        ,Progress -> Int
    countSkipped :: {-# UNPACK #-} !Int -- ^ Number of rules which were required, but were already in a valid state.
        ,Progress -> Int
    countBuilt :: {-# UNPACK #-} !Int -- ^ Number of rules which were have been built in this run.
        ,Progress -> Int
    countUnknown :: {-# UNPACK #-} !Int -- ^ Number of rules which have been built previously, but are not yet known to be required.
        ,Progress -> Int
    countTodo :: {-# UNPACK #-} !Int -- ^ Number of rules which are currently required (ignoring dependencies that do not change), but not built.
        ,Progress -> Seconds
    timeSkipped :: {-# UNPACK #-} !Double -- ^ Time spent building 'countSkipped' rules in previous runs.
        ,Progress -> Seconds
    timeBuilt :: {-# UNPACK #-} !Double -- ^ Time spent building 'countBuilt' rules.
        ,Progress -> Seconds
    timeUnknown :: {-# UNPACK #-} !Double -- ^ Time spent building 'countUnknown' rules in previous runs.
        ,Progress -> (Seconds, Int)
    timeTodo :: {-# UNPACK #-} !(Double,Int) -- ^ Time spent building 'countTodo' rules in previous runs, plus the number which have no known time (have never been built before).
        }
        deriving (Progress -> Progress -> Bool
    (Progress -> Progress -> Bool)
    -> (Progress -> Progress -> Bool) -> Eq Progress
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Progress -> Progress -> Bool
    == :: Progress -> Progress -> Bool
    $c/= :: Progress -> Progress -> Bool
    /= :: Progress -> Progress -> Bool
    Eq,Eq Progress
    Eq Progress
    -> (Progress -> Progress -> Ordering)
    -> (Progress -> Progress -> Bool)
    -> (Progress -> Progress -> Bool)
    -> (Progress -> Progress -> Bool)
    -> (Progress -> Progress -> Bool)
    -> (Progress -> Progress -> Progress)
    -> (Progress -> Progress -> Progress)
    -> Ord Progress
    Progress -> Progress -> Bool
    Progress -> Progress -> Ordering
    Progress -> Progress -> Progress
    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 :: Progress -> Progress -> Ordering
    compare :: Progress -> Progress -> Ordering
    $c< :: Progress -> Progress -> Bool
    < :: Progress -> Progress -> Bool
    $c<= :: Progress -> Progress -> Bool
    <= :: Progress -> Progress -> Bool
    $c> :: Progress -> Progress -> Bool
    > :: Progress -> Progress -> Bool
    $c>= :: Progress -> Progress -> Bool
    >= :: Progress -> Progress -> Bool
    $cmax :: Progress -> Progress -> Progress
    max :: Progress -> Progress -> Progress
    $cmin :: Progress -> Progress -> Progress
    min :: Progress -> Progress -> Progress
    Ord,Int -> Progress -> ShowS
    [Progress] -> ShowS
    Progress -> String
    (Int -> Progress -> ShowS)
    -> (Progress -> String) -> ([Progress] -> ShowS) -> Show Progress
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Progress -> ShowS
    showsPrec :: Int -> Progress -> ShowS
    $cshow :: Progress -> String
    show :: Progress -> String
    $cshowList :: [Progress] -> ShowS
    showList :: [Progress] -> ShowS
    Show,ReadPrec [Progress]
    ReadPrec Progress
    Int -> ReadS Progress
    ReadS [Progress]
    (Int -> ReadS Progress)
    -> ReadS [Progress]
    -> ReadPrec Progress
    -> ReadPrec [Progress]
    -> Read Progress
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Progress
    readsPrec :: Int -> ReadS Progress
    $creadList :: ReadS [Progress]
    readList :: ReadS [Progress]
    $creadPrec :: ReadPrec Progress
    readPrec :: ReadPrec Progress
    $creadListPrec :: ReadPrec [Progress]
    readListPrec :: ReadPrec [Progress]
    Read,Typeable Progress
    Typeable Progress
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Progress -> c Progress)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Progress)
    -> (Progress -> Constr)
    -> (Progress -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Progress))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Progress))
    -> ((forall b. Data b => b -> b) -> Progress -> Progress)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Progress -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Progress -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Progress -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Progress -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Progress -> m Progress)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Progress -> m Progress)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Progress -> m Progress)
    -> Data Progress
    Progress -> Constr
    Progress -> DataType
    (forall b. Data b => b -> b) -> Progress -> Progress
    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) -> Progress -> u
    forall u. (forall d. Data d => d -> u) -> Progress -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Progress -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Progress -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Progress
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Progress -> c Progress
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Progress)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Progress)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Progress -> c Progress
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Progress -> c Progress
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Progress
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Progress
    $ctoConstr :: Progress -> Constr
    toConstr :: Progress -> Constr
    $cdataTypeOf :: Progress -> DataType
    dataTypeOf :: Progress -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Progress)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Progress)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Progress)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Progress)
    $cgmapT :: (forall b. Data b => b -> b) -> Progress -> Progress
    gmapT :: (forall b. Data b => b -> b) -> Progress -> Progress
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Progress -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Progress -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Progress -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Progress -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Progress -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Progress -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Progress -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Progress -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Progress -> m Progress
    Data,Typeable)

    instance Semigroup Progress where
        Progress
    a <> :: Progress -> Progress -> Progress
    <> Progress
    b = Progress
            {isFailure :: Maybe String
    isFailure = Progress -> Maybe String
    isFailure Progress
    a Maybe String -> Maybe String -> Maybe String
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    `mplus` Progress -> Maybe String
    isFailure Progress
    b
            ,countSkipped :: Int
    countSkipped = Progress -> Int
    countSkipped Progress
    a Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Progress -> Int
    countSkipped Progress
    b
            ,countBuilt :: Int
    countBuilt = Progress -> Int
    countBuilt Progress
    a Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Progress -> Int
    countBuilt Progress
    b
            ,countUnknown :: Int
    countUnknown = Progress -> Int
    countUnknown Progress
    a Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Progress -> Int
    countUnknown Progress
    b
            ,countTodo :: Int
    countTodo = Progress -> Int
    countTodo Progress
    a Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Progress -> Int
    countTodo Progress
    b
            ,timeSkipped :: Seconds
    timeSkipped = Progress -> Seconds
    timeSkipped Progress
    a Seconds -> Seconds -> Seconds
    forall a. Num a => a -> a -> a
    + Progress -> Seconds
    timeSkipped Progress
    b
            ,timeBuilt :: Seconds
    timeBuilt = Progress -> Seconds
    timeBuilt Progress
    a Seconds -> Seconds -> Seconds
    forall a. Num a => a -> a -> a
    + Progress -> Seconds
    timeBuilt Progress
    b
            ,timeUnknown :: Seconds
    timeUnknown = Progress -> Seconds
    timeUnknown Progress
    a Seconds -> Seconds -> Seconds
    forall a. Num a => a -> a -> a
    + Progress -> Seconds
    timeUnknown Progress
    b
            ,timeTodo :: (Seconds, Int)
    timeTodo = let (Seconds
    a1,Int
    a2) = Progress -> (Seconds, Int)
    timeTodo Progress
    a; (Seconds
    b1,Int
    b2) = Progress -> (Seconds, Int)
    timeTodo Progress
    b
                            x1 :: Seconds
    x1 = Seconds
    a1 Seconds -> Seconds -> Seconds
    forall a. Num a => a -> a -> a
    + Seconds
    b1; x2 :: Int
    x2 = Int
    a2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    b2
                        in Seconds
    x1 Seconds -> (Seconds, Int) -> (Seconds, Int)
    forall a b. a -> b -> b
    `seq` Int
    x2 Int -> (Seconds, Int) -> (Seconds, Int)
    forall a b. a -> b -> b
    `seq` (Seconds
    x1,Int
    x2)
            }

    instance Monoid Progress where
        mempty :: Progress
    mempty = Maybe String
    -> Int
    -> Int
    -> Int
    -> Int
    -> Seconds
    -> Seconds
    -> Seconds
    -> (Seconds, Int)
    -> Progress
    Progress Maybe String
    forall a. Maybe a
    Nothing Int
    0 Int
    0 Int
    0 Int
    0 Seconds
    0 Seconds
    0 Seconds
    0 (Seconds
    0,Int
    0)
        mappend :: Progress -> Progress -> Progress
    mappend = Progress -> Progress -> Progress
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | Options to control the execution of Shake, usually specified by overriding fields in
    --   'shakeOptions':
    --
    --   @ 'shakeOptions'{'shakeThreads'=4, 'shakeReport'=[\"report.html\"]} @
    --
    --   The 'Data' instance for this type reports the 'shakeProgress' and 'shakeOutput' fields as having the abstract type 'Hidden',
    --   because 'Data' cannot be defined for functions or 'TypeRep's.
    data ShakeOptions = ShakeOptions
        {ShakeOptions -> String
    shakeFiles :: FilePath
            -- ^ Defaults to @.shake@. The directory used for storing Shake metadata files.
            --   All metadata files will be named @'shakeFiles'\/.shake./file-name/@, for some @/file-name/@.
            --   If the 'shakeFiles' directory does not exist it will be created.
            --   If set to @\"\/dev\/null\"@ then no shakeFiles are read or written (even on Windows).
        ,ShakeOptions -> Int
    shakeThreads :: Int
            -- ^ Defaults to @1@. Maximum number of rules to run in parallel, similar to @make --jobs=/N/@.
            --   For many build systems, a number equal to or slightly less than the number of physical processors
            --   works well. Use @0@ to match the detected number of processors (when @0@, 'getShakeOptions' will
            --   return the number of threads used).
        ,ShakeOptions -> String
    shakeVersion :: String
            -- ^ Defaults to @"1"@. The version number of your build rules.
            --   Change the version number to force a complete rebuild, such as when making
            --   significant changes to the rules that require a wipe. The version number should be
            --   set in the source code, and not passed on the command line.
        ,ShakeOptions -> Verbosity
    shakeVerbosity :: Verbosity
            -- ^ Defaults to 'Info'. What level of messages should be printed out.
        ,ShakeOptions -> Bool
    shakeStaunch :: Bool
            -- ^ Defaults to 'False'. Operate in staunch mode, where building continues even after errors,
            --   similar to @make --keep-going@.
        ,ShakeOptions -> [String]
    shakeReport :: [FilePath]
            -- ^ Defaults to @[]@. Write a profiling report to a file, showing which rules rebuilt,
            --   why, and how much time they took. Useful for improving the speed of your build systems.
            --   If the file extension is @.json@ it will write JSON data; if @.js@ it will write Javascript;
            --   if @.trace@ it will write trace events (load into @about:\/\/tracing@ in Chrome);
            --   otherwise it will write HTML.
        ,ShakeOptions -> Maybe Lint
    shakeLint :: Maybe Lint
            -- ^ Defaults to 'Nothing'. Perform sanity checks during building, see 'Lint' for details.
        ,ShakeOptions -> [String]
    shakeLintInside :: [FilePath]
            -- ^ Directories in which the files will be tracked by the linter.
        ,ShakeOptions -> [String]
    shakeLintIgnore :: [FilePattern]
            -- ^ File patterns which are ignored from linter tracking, a bit like calling 'Development.Shake.trackAllow' in every rule.
        ,ShakeOptions -> [String]
    shakeLintWatch :: [FilePattern]
            -- ^ File patterns whose modification causes an error. Raises an error even if 'shakeLint' is 'Nothing'.
        ,ShakeOptions -> [CmdOption]
    shakeCommandOptions :: [CmdOption]
            -- ^ Defaults to @[]@. Additional options to be passed to all command invocations.
        ,ShakeOptions -> Maybe Seconds
    shakeFlush :: Maybe Seconds
            -- ^ Defaults to @'Just' 10@. How often to flush Shake metadata files in seconds, or 'Nothing' to never flush explicitly.
            --   It is possible that on abnormal termination (not Haskell exceptions) any rules that completed in the last
            --   'shakeFlush' seconds will be lost.
        ,ShakeOptions -> [(Rebuild, String)]
    shakeRebuild :: [(Rebuild, FilePattern)]
            -- ^ What to rebuild
        ,ShakeOptions -> [(String, String)]
    shakeAbbreviations :: [(String,String)]
            -- ^ Defaults to @[]@. A list of substrings that should be abbreviated in status messages, and their corresponding abbreviation.
            --   Commonly used to replace the long paths (e.g. @.make\/i586-linux-gcc\/output@) with an abbreviation (e.g. @$OUT@).
        ,ShakeOptions -> Bool
    shakeStorageLog :: Bool
            -- ^ Defaults to 'False'. Write a message to @'shakeFiles'\/.shake.storage.log@ whenever a storage event happens which may impact
            --   on the current stored progress. Examples include database version number changes, database compaction or corrupt files.
        ,ShakeOptions -> Bool
    shakeLineBuffering :: Bool
            -- ^ Defaults to 'True'. Change 'stdout' and 'stderr' to line buffering while running Shake.
        ,ShakeOptions -> Bool
    shakeTimings :: Bool
            -- ^ Defaults to 'False'. Print timing information for each stage at the end.
        ,ShakeOptions -> Bool
    shakeRunCommands :: Bool
            -- ^ Default to 'True'. Should you run command line actions, set to 'False' to skip actions whose output streams and exit code
            --   are not used. Useful for profiling the non-command portion of the build system.
        ,ShakeOptions -> Change
    shakeChange :: Change
            -- ^ Default to 'ChangeModtime'. How to check if a file has changed, see 'Change' for details.
        ,ShakeOptions -> Bool
    shakeCreationCheck :: Bool
            -- ^ Default to 'True'. After running a rule to create a file, is it an error if the file does not exist.
            --   Provided for compatibility with @make@ and @ninja@ (which have ugly file creation semantics).
        ,ShakeOptions -> [String]
    shakeLiveFiles :: [FilePath]
            -- ^ Default to @[]@. After the build system completes, write a list of all files which were /live/ in that run,
            --   i.e. those which Shake checked were valid or rebuilt. Produces best answers if nothing rebuilds.
        ,ShakeOptions -> Bool
    shakeVersionIgnore :: Bool
            -- ^ Defaults to 'False'. Ignore any differences in 'shakeVersion'.
        ,ShakeOptions -> Bool
    shakeColor :: Bool
            -- ^ Defaults to 'False'. Whether to colorize the output.
        ,ShakeOptions -> Maybe String
    shakeShare :: Maybe FilePath
            -- ^ Defaults to 'Nothing'. Whether to use and store outputs in a shared directory.
        ,ShakeOptions -> [String]
    shakeCloud :: [String]
            -- ^ Defaults to @[]@. Cloud servers to talk to forming a shared cache.
        ,ShakeOptions -> Bool
    shakeSymlink :: Bool
            -- ^ Defaults to @False@. Use symlinks for 'shakeShare' if they are available.
            --   If this setting is @True@ (even if symlinks are not available) then files will be
            --   made read-only to avoid inadvertantly poisoning the shared cache.
            --   Note the links are actually hard links, not symlinks.
        ,ShakeOptions -> Bool
    shakeNeedDirectory :: Bool
            -- ^ Defaults to @False@. Is depending on a directory an error (default), or it is permitted with
            --   undefined results. Provided for compatibility with @ninja@.
        ,ShakeOptions -> Bool
    shakeAllowRedefineRules :: Bool
            -- ^ Whether to allow calling addBuiltinRule for the same key more than once
        ,ShakeOptions -> IO Progress -> IO ()
    shakeProgress :: IO Progress -> IO ()
            -- ^ Defaults to no action. A function called when the build starts, allowing progress to be reported.
            --   The function is called on a separate thread, and that thread is killed when the build completes.
            --   For applications that want to display progress messages, 'progressSimple' is often sufficient, but more advanced
            --   users should look at the 'Progress' data type.
        ,ShakeOptions -> Verbosity -> String -> IO ()
    shakeOutput :: Verbosity -> String -> IO ()
            -- ^ Defaults to writing using 'putStrLn'. A function called to output messages from Shake, along with the 'Verbosity' at
            --   which that message should be printed. This function will be called atomically from all other 'shakeOutput' functions.
            --   The 'Verbosity' will always be greater than or higher than 'shakeVerbosity'.
        ,ShakeOptions -> String -> String -> Bool -> IO ()
    shakeTrace :: String -> String -> Bool -> IO ()
            -- ^ Defaults to doing nothing.
            --   Called for each call of 'Development.Shake.traced', with the key, the command and 'True' for starting, 'False' for stopping.
        ,ShakeOptions -> HashMap TypeRep Dynamic
    shakeExtra :: Map.HashMap TypeRep Dynamic
            -- ^ This a map which can be used to store arbitrary extra information that a user may need when writing rules.
            --   The key of each entry must be the 'dynTypeRep' of the value.
            --   Insert values using 'addShakeExtra' and retrieve them using 'getShakeExtra'.
            --   The correct way to use this field is to define a hidden newtype for the key, so that conflicts cannot occur.
        }
        deriving Typeable

    -- | The default set of 'ShakeOptions'.
    shakeOptions :: ShakeOptions
    shakeOptions :: ShakeOptions
    shakeOptions = String
    -> Int
    -> String
    -> Verbosity
    -> Bool
    -> [String]
    -> Maybe Lint
    -> [String]
    -> [String]
    -> [String]
    -> [CmdOption]
    -> Maybe Seconds
    -> [(Rebuild, String)]
    -> [(String, String)]
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Change
    -> Bool
    -> [String]
    -> Bool
    -> Bool
    -> Maybe String
    -> [String]
    -> Bool
    -> Bool
    -> Bool
    -> (IO Progress -> IO ())
    -> (Verbosity -> String -> IO ())
    -> (String -> String -> Bool -> IO ())
    -> HashMap TypeRep Dynamic
    -> ShakeOptions
    ShakeOptions
        String
    ".shake" Int
    1 String
    "1" Verbosity
    Info Bool
    False [] Maybe Lint
    forall a. Maybe a
    Nothing [] [] [] [] (Seconds -> Maybe Seconds
    forall a. a -> Maybe a
    Just Seconds
    10) [] [] Bool
    False Bool
    True Bool
    False
        Bool
    True Change
    ChangeModtime Bool
    True [] Bool
    False Bool
    False Maybe String
    forall a. Maybe a
    Nothing [] Bool
    False Bool
    False Bool
    False
        (IO () -> IO Progress -> IO ()
    forall a b. a -> b -> a
    const (IO () -> IO Progress -> IO ()) -> IO () -> IO Progress -> IO ()
    forall a b. (a -> b) -> a -> b
    $ () -> IO ()
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ())
        ((String -> IO ()) -> Verbosity -> String -> IO ()
    forall a b. a -> b -> a
    const ((String -> IO ()) -> Verbosity -> String -> IO ())
    -> (String -> IO ()) -> Verbosity -> String -> IO ()
    forall a b. (a -> b) -> a -> b
    $ ByteString -> IO ()
    BS.putStrLn (ByteString -> IO ()) -> (String -> ByteString) -> String -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ByteString
    UTF8.fromString) -- try and output atomically using BS
        (\String
    _ String
    _ Bool
    _ -> () -> IO ()
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ())
        HashMap TypeRep Dynamic
    forall k v. HashMap k v
    Map.empty

    fieldsShakeOptions :: [String]
    fieldsShakeOptions =
        [String
    "shakeFiles", String
    "shakeThreads", String
    "shakeVersion", String
    "shakeVerbosity", String
    "shakeStaunch", String
    "shakeReport"
        ,String
    "shakeLint", String
    "shakeLintInside", String
    "shakeLintIgnore", String
    "shakeLintWatch", String
    "shakeCommandOptions"
        ,String
    "shakeFlush", String
    "shakeRebuild", String
    "shakeAbbreviations", String
    "shakeStorageLog"
        ,String
    "shakeLineBuffering", String
    "shakeTimings", String
    "shakeRunCommands", String
    "shakeChange", String
    "shakeCreationCheck"
        ,String
    "shakeLiveFiles", String
    "shakeVersionIgnore", String
    "shakeColor", String
    "shakeShare", String
    "shakeCloud", String
    "shakeSymlink"
        ,String
    "shakeNeedDirectory", String
    "shakeCanRedefineRules"
        ,String
    "shakeProgress", String
    "shakeOutput", String
    "shakeTrace", String
    "shakeExtra"]
    tyShakeOptions :: DataType
    tyShakeOptions = String -> [Constr] -> DataType
    mkDataType String
    "Development.Shake.Types.ShakeOptions" [Constr
    conShakeOptions]
    conShakeOptions :: Constr
    conShakeOptions = DataType -> String -> [String] -> Fixity -> Constr
    mkConstr DataType
    tyShakeOptions String
    "ShakeOptions" [String]
    fieldsShakeOptions Fixity
    Prefix
    unhide :: String
    -> Int
    -> String
    -> Verbosity
    -> Bool
    -> [String]
    -> Maybe Lint
    -> [String]
    -> [String]
    -> [String]
    -> [CmdOption]
    -> Maybe Seconds
    -> [(Rebuild, String)]
    -> [(String, String)]
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Change
    -> Bool
    -> [String]
    -> Bool
    -> Bool
    -> Maybe String
    -> [String]
    -> Bool
    -> Bool
    -> Bool
    -> Hidden (IO Progress -> IO ())
    -> Hidden (Verbosity -> String -> IO ())
    -> Hidden (String -> String -> Bool -> IO ())
    -> Hidden (HashMap TypeRep Dynamic)
    -> ShakeOptions
    unhide String
    x1 Int
    x2 String
    x3 Verbosity
    x4 Bool
    x5 [String]
    x6 Maybe Lint
    x7 [String]
    x8 [String]
    x9 [String]
    x10 [CmdOption]
    x11 Maybe Seconds
    x12 [(Rebuild, String)]
    x13 [(String, String)]
    x14 Bool
    x15 Bool
    x16 Bool
    x17 Bool
    x18 Change
    x19 Bool
    x20 [String]
    x21 Bool
    x22 Bool
    x23 Maybe String
    x24 [String]
    x25 Bool
    x26 Bool
    x27 Bool
    x28 Hidden (IO Progress -> IO ())
    y1 Hidden (Verbosity -> String -> IO ())
    y2 Hidden (String -> String -> Bool -> IO ())
    y3 Hidden (HashMap TypeRep Dynamic)
    y4 =
      String
    -> Int
    -> String
    -> Verbosity
    -> Bool
    -> [String]
    -> Maybe Lint
    -> [String]
    -> [String]
    -> [String]
    -> [CmdOption]
    -> Maybe Seconds
    -> [(Rebuild, String)]
    -> [(String, String)]
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Change
    -> Bool
    -> [String]
    -> Bool
    -> Bool
    -> Maybe String
    -> [String]
    -> Bool
    -> Bool
    -> Bool
    -> (IO Progress -> IO ())
    -> (Verbosity -> String -> IO ())
    -> (String -> String -> Bool -> IO ())
    -> HashMap TypeRep Dynamic
    -> ShakeOptions
    ShakeOptions String
    x1 Int
    x2 String
    x3 Verbosity
    x4 Bool
    x5 [String]
    x6 Maybe Lint
    x7 [String]
    x8 [String]
    x9 [String]
    x10 [CmdOption]
    x11 Maybe Seconds
    x12 [(Rebuild, String)]
    x13 [(String, String)]
    x14 Bool
    x15 Bool
    x16 Bool
    x17 Bool
    x18 Change
    x19 Bool
    x20 [String]
    x21 Bool
    x22 Bool
    x23 Maybe String
    x24 [String]
    x25 Bool
    x26 Bool
    x27 Bool
    x28
            (Hidden (IO Progress -> IO ()) -> IO Progress -> IO ()
    forall a. Hidden a -> a
    fromHidden Hidden (IO Progress -> IO ())
    y1) (Hidden (Verbosity -> String -> IO ())
    -> Verbosity -> String -> IO ()
    forall a. Hidden a -> a
    fromHidden Hidden (Verbosity -> String -> IO ())
    y2) (Hidden (String -> String -> Bool -> IO ())
    -> String -> String -> Bool -> IO ()
    forall a. Hidden a -> a
    fromHidden Hidden (String -> String -> Bool -> IO ())
    y3) (Hidden (HashMap TypeRep Dynamic) -> HashMap TypeRep Dynamic
    forall a. Hidden a -> a
    fromHidden Hidden (HashMap TypeRep Dynamic)
    y4)

    instance Data ShakeOptions where
        gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ShakeOptions -> c ShakeOptions
    gfoldl forall d b. Data d => c (d -> b) -> d -> c b
    k forall g. g -> c g
    z (ShakeOptions String
    x1 Int
    x2 String
    x3 Verbosity
    x4 Bool
    x5 [String]
    x6 Maybe Lint
    x7 [String]
    x8 [String]
    x9 [String]
    x10 [CmdOption]
    x11 Maybe Seconds
    x12 [(Rebuild, String)]
    x13 [(String, String)]
    x14 Bool
    x15 Bool
    x16 Bool
    x17 Bool
    x18 Change
    x19 Bool
    x20 [String]
    x21 Bool
    x22 Bool
    x23 Maybe String
    x24 [String]
    x25 Bool
    x26 Bool
    x27 Bool
    x28 IO Progress -> IO ()
    y1 Verbosity -> String -> IO ()
    y2 String -> String -> Bool -> IO ()
    y3 HashMap TypeRep Dynamic
    y4) =
            (String
     -> Int
     -> String
     -> Verbosity
     -> Bool
     -> [String]
     -> Maybe Lint
     -> [String]
     -> [String]
     -> [String]
     -> [CmdOption]
     -> Maybe Seconds
     -> [(Rebuild, String)]
     -> [(String, String)]
     -> Bool
     -> Bool
     -> Bool
     -> Bool
     -> Change
     -> Bool
     -> [String]
     -> Bool
     -> Bool
     -> Maybe String
     -> [String]
     -> Bool
     -> Bool
     -> Bool
     -> Hidden (IO Progress -> IO ())
     -> Hidden (Verbosity -> String -> IO ())
     -> Hidden (String -> String -> Bool -> IO ())
     -> Hidden (HashMap TypeRep Dynamic)
     -> ShakeOptions)
    -> c (String
          -> Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall g. g -> c g
    z String
    -> Int
    -> String
    -> Verbosity
    -> Bool
    -> [String]
    -> Maybe Lint
    -> [String]
    -> [String]
    -> [String]
    -> [CmdOption]
    -> Maybe Seconds
    -> [(Rebuild, String)]
    -> [(String, String)]
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Change
    -> Bool
    -> [String]
    -> Bool
    -> Bool
    -> Maybe String
    -> [String]
    -> Bool
    -> Bool
    -> Bool
    -> Hidden (IO Progress -> IO ())
    -> Hidden (Verbosity -> String -> IO ())
    -> Hidden (String -> String -> Bool -> IO ())
    -> Hidden (HashMap TypeRep Dynamic)
    -> ShakeOptions
    unhide c (String
       -> Int
       -> String
       -> Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> String
    -> c (Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` String
    x1 c (Int
       -> String
       -> Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Int
    -> c (String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Int
    x2 c (String
       -> Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> String
    -> c (Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` String
    x3 c (Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Verbosity
    -> c (Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Verbosity
    x4 c (Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c ([String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x5 c ([String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [String]
    -> c (Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [String]
    x6 c (Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Maybe Lint
    -> c ([String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Maybe Lint
    x7 c ([String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [String]
    -> c ([String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [String]
    x8 c ([String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [String]
    -> c ([String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [String]
    x9 c ([String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [String]
    -> c ([CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [String]
    x10 c ([CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [CmdOption]
    -> c (Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [CmdOption]
    x11 c (Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Maybe Seconds
    -> c ([(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k`
            Maybe Seconds
    x12 c ([(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [(Rebuild, String)]
    -> c ([(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [(Rebuild, String)]
    x13 c ([(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [(String, String)]
    -> c (Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [(String, String)]
    x14 c (Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x15 c (Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x16 c (Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x17 c (Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x18 c (Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Change
    -> c (Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Change
    x19 c (Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c ([String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x20 c ([String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [String]
    -> c (Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [String]
    x21 c (Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x22 c (Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x23 c (Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Maybe String
    -> c ([String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Maybe String
    x24 c ([String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> [String]
    -> c (Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` [String]
    x25 c (Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x26 c (Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x27 c (Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Bool
    -> c (Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` Bool
    x28 c (Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Hidden (IO Progress -> IO ())
    -> c (Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k`
            (IO Progress -> IO ()) -> Hidden (IO Progress -> IO ())
    forall a. a -> Hidden a
    Hidden IO Progress -> IO ()
    y1 c (Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> Hidden (Verbosity -> String -> IO ())
    -> c (Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` (Verbosity -> String -> IO ())
    -> Hidden (Verbosity -> String -> IO ())
    forall a. a -> Hidden a
    Hidden Verbosity -> String -> IO ()
    y2 c (Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    -> Hidden (String -> String -> Bool -> IO ())
    -> c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` (String -> String -> Bool -> IO ())
    -> Hidden (String -> String -> Bool -> IO ())
    forall a. a -> Hidden a
    Hidden String -> String -> Bool -> IO ()
    y3 c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    -> Hidden (HashMap TypeRep Dynamic) -> c ShakeOptions
    forall d b. Data d => c (d -> b) -> d -> c b
    `k` HashMap TypeRep Dynamic -> Hidden (HashMap TypeRep Dynamic)
    forall a. a -> Hidden a
    Hidden HashMap TypeRep Dynamic
    y4
        gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ShakeOptions
    gunfold forall b r. Data b => c (b -> r) -> c r
    k forall r. r -> c r
    z Constr
    _ = c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    -> c ShakeOptions
    forall b r. Data b => c (b -> r) -> c r
    k (c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
     -> c ShakeOptions)
    -> c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    -> c ShakeOptions
    forall a b. (a -> b) -> a -> b
    $ c (Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    -> c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
     -> c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions))
    -> c (Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    -> c (Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions))
    -> c (Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic) -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c ([String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c ([String]
        -> Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Maybe Lint
           -> [String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c ([String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c ([String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Bool
        -> [String]
        -> Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c ([String]
           -> Maybe Lint
           -> [String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c ([String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Verbosity
        -> Bool
        -> [String]
        -> Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Bool
           -> [String]
           -> Maybe Lint
           -> [String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (String
       -> Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (String
        -> Verbosity
        -> Bool
        -> [String]
        -> Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Verbosity
           -> Bool
           -> [String]
           -> Maybe Lint
           -> [String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (Int
       -> String
       -> Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (Int
        -> String
        -> Verbosity
        -> Bool
        -> [String]
        -> Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (String
           -> Verbosity
           -> Bool
           -> [String]
           -> Maybe Lint
           -> [String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ c (String
       -> Int
       -> String
       -> Verbosity
       -> Bool
       -> [String]
       -> Maybe Lint
       -> [String]
       -> [String]
       -> [String]
       -> [CmdOption]
       -> Maybe Seconds
       -> [(Rebuild, String)]
       -> [(String, String)]
       -> Bool
       -> Bool
       -> Bool
       -> Bool
       -> Change
       -> Bool
       -> [String]
       -> Bool
       -> Bool
       -> Maybe String
       -> [String]
       -> Bool
       -> Bool
       -> Bool
       -> Hidden (IO Progress -> IO ())
       -> Hidden (Verbosity -> String -> IO ())
       -> Hidden (String -> String -> Bool -> IO ())
       -> Hidden (HashMap TypeRep Dynamic)
       -> ShakeOptions)
    -> c (Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall b r. Data b => c (b -> r) -> c r
    k (c (String
        -> Int
        -> String
        -> Verbosity
        -> Bool
        -> [String]
        -> Maybe Lint
        -> [String]
        -> [String]
        -> [String]
        -> [CmdOption]
        -> Maybe Seconds
        -> [(Rebuild, String)]
        -> [(String, String)]
        -> Bool
        -> Bool
        -> Bool
        -> Bool
        -> Change
        -> Bool
        -> [String]
        -> Bool
        -> Bool
        -> Maybe String
        -> [String]
        -> Bool
        -> Bool
        -> Bool
        -> Hidden (IO Progress -> IO ())
        -> Hidden (Verbosity -> String -> IO ())
        -> Hidden (String -> String -> Bool -> IO ())
        -> Hidden (HashMap TypeRep Dynamic)
        -> ShakeOptions)
     -> c (Int
           -> String
           -> Verbosity
           -> Bool
           -> [String]
           -> Maybe Lint
           -> [String]
           -> [String]
           -> [String]
           -> [CmdOption]
           -> Maybe Seconds
           -> [(Rebuild, String)]
           -> [(String, String)]
           -> Bool
           -> Bool
           -> Bool
           -> Bool
           -> Change
           -> Bool
           -> [String]
           -> Bool
           -> Bool
           -> Maybe String
           -> [String]
           -> Bool
           -> Bool
           -> Bool
           -> Hidden (IO Progress -> IO ())
           -> Hidden (Verbosity -> String -> IO ())
           -> Hidden (String -> String -> Bool -> IO ())
           -> Hidden (HashMap TypeRep Dynamic)
           -> ShakeOptions))
    -> c (String
          -> Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    -> c (Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall a b. (a -> b) -> a -> b
    $ (String
     -> Int
     -> String
     -> Verbosity
     -> Bool
     -> [String]
     -> Maybe Lint
     -> [String]
     -> [String]
     -> [String]
     -> [CmdOption]
     -> Maybe Seconds
     -> [(Rebuild, String)]
     -> [(String, String)]
     -> Bool
     -> Bool
     -> Bool
     -> Bool
     -> Change
     -> Bool
     -> [String]
     -> Bool
     -> Bool
     -> Maybe String
     -> [String]
     -> Bool
     -> Bool
     -> Bool
     -> Hidden (IO Progress -> IO ())
     -> Hidden (Verbosity -> String -> IO ())
     -> Hidden (String -> String -> Bool -> IO ())
     -> Hidden (HashMap TypeRep Dynamic)
     -> ShakeOptions)
    -> c (String
          -> Int
          -> String
          -> Verbosity
          -> Bool
          -> [String]
          -> Maybe Lint
          -> [String]
          -> [String]
          -> [String]
          -> [CmdOption]
          -> Maybe Seconds
          -> [(Rebuild, String)]
          -> [(String, String)]
          -> Bool
          -> Bool
          -> Bool
          -> Bool
          -> Change
          -> Bool
          -> [String]
          -> Bool
          -> Bool
          -> Maybe String
          -> [String]
          -> Bool
          -> Bool
          -> Bool
          -> Hidden (IO Progress -> IO ())
          -> Hidden (Verbosity -> String -> IO ())
          -> Hidden (String -> String -> Bool -> IO ())
          -> Hidden (HashMap TypeRep Dynamic)
          -> ShakeOptions)
    forall r. r -> c r
    z String
    -> Int
    -> String
    -> Verbosity
    -> Bool
    -> [String]
    -> Maybe Lint
    -> [String]
    -> [String]
    -> [String]
    -> [CmdOption]
    -> Maybe Seconds
    -> [(Rebuild, String)]
    -> [(String, String)]
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Change
    -> Bool
    -> [String]
    -> Bool
    -> Bool
    -> Maybe String
    -> [String]
    -> Bool
    -> Bool
    -> Bool
    -> Hidden (IO Progress -> IO ())
    -> Hidden (Verbosity -> String -> IO ())
    -> Hidden (String -> String -> Bool -> IO ())
    -> Hidden (HashMap TypeRep Dynamic)
    -> ShakeOptions
    unhide
        toConstr :: ShakeOptions -> Constr
    toConstr ShakeOptions{} = Constr
    conShakeOptions
        dataTypeOf :: ShakeOptions -> DataType
    dataTypeOf ShakeOptions
    _ = DataType
    tyShakeOptions

    shakeOptionsFields :: ShakeOptions -> [(String, String)]
    shakeOptionsFields :: ShakeOptions -> [(String, String)]
    shakeOptionsFields = [String] -> [String] -> [(String, String)]
    forall a b. Partial => [a] -> [b] -> [(a, b)]
    zipExact [String]
    fieldsShakeOptions ([String] -> [(String, String)])
    -> (ShakeOptions -> [String]) -> ShakeOptions -> [(String, String)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall d. Data d => d -> String) -> ShakeOptions -> [String]
    forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
    forall u. (forall d. Data d => d -> u) -> ShakeOptions -> [u]
    gmapQ d -> String
    forall d. Data d => d -> String
    forall {a}. Typeable a => a -> String
    f
        where
            f :: a -> String
    f a
    x | Just Int
    x <- a -> Maybe Int
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Int -> String
    forall a. Show a => a -> String
    show (Int
    x :: Int)
                | Just String
    x <- a -> Maybe String
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = ShowS
    forall a. Show a => a -> String
    show (String
    x :: FilePath)
                | Just Verbosity
    x <- a -> Maybe Verbosity
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Verbosity -> String
    forall a. Show a => a -> String
    show (Verbosity
    x :: Verbosity)
                | Just Change
    x <- a -> Maybe Change
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Change -> String
    forall a. Show a => a -> String
    show (Change
    x :: Change)
                | Just Bool
    x <- a -> Maybe Bool
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Bool -> String
    forall a. Show a => a -> String
    show (Bool
    x :: Bool)
                | Just [String]
    x <- a -> Maybe [String]
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = [String] -> String
    forall a. Show a => a -> String
    show ([String]
    x :: [FilePath])
                | Just [(Rebuild, String)]
    x <- a -> Maybe [(Rebuild, String)]
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = [(Rebuild, String)] -> String
    forall a. Show a => a -> String
    show ([(Rebuild, String)]
    x :: [(Rebuild, FilePattern)])
                | Just Maybe Lint
    x <- a -> Maybe (Maybe Lint)
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Maybe Lint -> String
    forall a. Show a => a -> String
    show (Maybe Lint
    x :: Maybe Lint)
                | Just Maybe Seconds
    x <- a -> Maybe (Maybe Seconds)
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Maybe Seconds -> String
    forall a. Show a => a -> String
    show (Maybe Seconds
    x :: Maybe Double)
                | Just Maybe String
    x <- a -> Maybe (Maybe String)
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Maybe String -> String
    forall a. Show a => a -> String
    show (Maybe String
    x :: Maybe String)
                | Just [(String, String)]
    x <- a -> Maybe [(String, String)]
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = [(String, String)] -> String
    forall a. Show a => a -> String
    show ([(String, String)]
    x :: [(String,String)])
                | Just Hidden (IO Progress -> IO ())
    x <- a -> Maybe (Hidden (IO Progress -> IO ()))
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Hidden (IO Progress -> IO ()) -> String
    forall a. Show a => a -> String
    show (Hidden (IO Progress -> IO ())
    x :: Hidden (IO Progress -> IO ()))
                | Just Hidden (Verbosity -> String -> IO ())
    x <- a -> Maybe (Hidden (Verbosity -> String -> IO ()))
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Hidden (Verbosity -> String -> IO ()) -> String
    forall a. Show a => a -> String
    show (Hidden (Verbosity -> String -> IO ())
    x :: Hidden (Verbosity -> String -> IO ()))
                | Just Hidden (HashMap TypeRep Dynamic)
    x <- a -> Maybe (Hidden (HashMap TypeRep Dynamic))
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Hidden (HashMap TypeRep Dynamic) -> String
    forall a. Show a => a -> String
    show (Hidden (HashMap TypeRep Dynamic)
    x :: Hidden (Map.HashMap TypeRep Dynamic))
                | Just Hidden (String -> String -> Bool -> IO ())
    x <- a -> Maybe (Hidden (String -> String -> Bool -> IO ()))
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = Hidden (String -> String -> Bool -> IO ()) -> String
    forall a. Show a => a -> String
    show (Hidden (String -> String -> Bool -> IO ())
    x :: Hidden (String -> String -> Bool -> IO ()))
                | Just [CmdOption]
    x <- a -> Maybe [CmdOption]
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    x = [CmdOption] -> String
    forall a. Show a => a -> String
    show ([CmdOption]
    x :: [CmdOption])
                | Bool
    otherwise = SomeException -> String
    forall a. SomeException -> a
    throwImpure (SomeException -> String) -> SomeException -> String
    forall a b. (a -> b) -> a -> b
    $ Partial => String -> SomeException
    String -> SomeException
    errorInternal (String -> SomeException) -> String -> SomeException
    forall a b. (a -> b) -> a -> b
    $ String
    "Error while showing ShakeOptions, missing alternative for " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ TypeRep -> String
    forall a. Show a => a -> String
    show (a -> TypeRep
    forall a. Typeable a => a -> TypeRep
    typeOf a
    x)

    instance Show ShakeOptions where
        show :: ShakeOptions -> String
    show ShakeOptions
    x = String
    "ShakeOptions {" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    ", " (((String, String) -> String) -> [(String, String)] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (\(String
    a,String
    b) -> String
    a String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " = " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    b) ([(String, String)] -> [String]) -> [(String, String)] -> [String]
    forall a b. (a -> b) -> a -> b
    $ ShakeOptions -> [(String, String)]
    shakeOptionsFields ShakeOptions
    x) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    "}"

    -- | Internal type, copied from Hide in Uniplate
    newtype Hidden a = Hidden {forall a. Hidden a -> a
    fromHidden :: a}
        deriving Typeable

    instance Show (Hidden a) where show :: Hidden a -> String
    show Hidden a
    _ = String
    "<hidden>"

    instance Typeable a => Data (Hidden a) where
        gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Hidden a -> c (Hidden a)
    gfoldl forall d b. Data d => c (d -> b) -> d -> c b
    _ forall g. g -> c g
    z = Hidden a -> c (Hidden a)
    forall g. g -> c g
    z
        gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Hidden a)
    gunfold forall b r. Data b => c (b -> r) -> c r
    _ forall r. r -> c r
    _ Constr
    _ = String -> c (Hidden a)
    forall a. Partial => String -> a
    error String
    "Development.Shake.Types.ShakeProgress: gunfold not implemented - data type has no constructors"
        toConstr :: Hidden a -> Constr
    toConstr Hidden a
    _ = String -> Constr
    forall a. Partial => String -> a
    error String
    "Development.Shake.Types.ShakeProgress: toConstr not implemented - data type has no constructors"
        dataTypeOf :: Hidden a -> DataType
    dataTypeOf Hidden a
    _ = DataType
    tyHidden

    tyHidden :: DataType
    tyHidden = String -> [Constr] -> DataType
    mkDataType String
    "Development.Shake.Types.Hidden" []

    -- | The verbosity data type, used by 'shakeVerbosity'.
    data Verbosity
        = Silent  -- ^ Don't print any messages.
        | Error     -- ^ Only print error messages.
        | Warn    -- ^ Print errors and warnings.
        | Info    -- ^ Print errors, warnings and @# /command-name/ (for /file-name/)@ when running a 'Development.Shake.traced' command.
        | Verbose -- ^ Print errors, warnings, full command lines when running a 'Development.Shake.command' or
                  --   'Development.Shake.cmd' command and status messages when starting a rule.
        | Diagnostic -- ^ Print messages for virtually everything (mostly for debugging).
          deriving (Verbosity -> Verbosity -> Bool
    (Verbosity -> Verbosity -> Bool)
    -> (Verbosity -> Verbosity -> Bool) -> Eq Verbosity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Verbosity -> Verbosity -> Bool
    == :: Verbosity -> Verbosity -> Bool
    $c/= :: Verbosity -> Verbosity -> Bool
    /= :: Verbosity -> Verbosity -> Bool
    Eq,Eq Verbosity
    Eq Verbosity
    -> (Verbosity -> Verbosity -> Ordering)
    -> (Verbosity -> Verbosity -> Bool)
    -> (Verbosity -> Verbosity -> Bool)
    -> (Verbosity -> Verbosity -> Bool)
    -> (Verbosity -> Verbosity -> Bool)
    -> (Verbosity -> Verbosity -> Verbosity)
    -> (Verbosity -> Verbosity -> Verbosity)
    -> Ord Verbosity
    Verbosity -> Verbosity -> Bool
    Verbosity -> Verbosity -> Ordering
    Verbosity -> Verbosity -> Verbosity
    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 :: Verbosity -> Verbosity -> Ordering
    compare :: Verbosity -> Verbosity -> Ordering
    $c< :: Verbosity -> Verbosity -> Bool
    < :: Verbosity -> Verbosity -> Bool
    $c<= :: Verbosity -> Verbosity -> Bool
    <= :: Verbosity -> Verbosity -> Bool
    $c> :: Verbosity -> Verbosity -> Bool
    > :: Verbosity -> Verbosity -> Bool
    $c>= :: Verbosity -> Verbosity -> Bool
    >= :: Verbosity -> Verbosity -> Bool
    $cmax :: Verbosity -> Verbosity -> Verbosity
    max :: Verbosity -> Verbosity -> Verbosity
    $cmin :: Verbosity -> Verbosity -> Verbosity
    min :: Verbosity -> Verbosity -> Verbosity
    Ord,Int -> Verbosity -> ShowS
    [Verbosity] -> ShowS
    Verbosity -> String
    (Int -> Verbosity -> ShowS)
    -> (Verbosity -> String)
    -> ([Verbosity] -> ShowS)
    -> Show Verbosity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Verbosity -> ShowS
    showsPrec :: Int -> Verbosity -> ShowS
    $cshow :: Verbosity -> String
    show :: Verbosity -> String
    $cshowList :: [Verbosity] -> ShowS
    showList :: [Verbosity] -> ShowS
    Show,ReadPrec [Verbosity]
    ReadPrec Verbosity
    Int -> ReadS Verbosity
    ReadS [Verbosity]
    (Int -> ReadS Verbosity)
    -> ReadS [Verbosity]
    -> ReadPrec Verbosity
    -> ReadPrec [Verbosity]
    -> Read Verbosity
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Verbosity
    readsPrec :: Int -> ReadS Verbosity
    $creadList :: ReadS [Verbosity]
    readList :: ReadS [Verbosity]
    $creadPrec :: ReadPrec Verbosity
    readPrec :: ReadPrec Verbosity
    $creadListPrec :: ReadPrec [Verbosity]
    readListPrec :: ReadPrec [Verbosity]
    Read,Typeable,Typeable Verbosity
    Typeable Verbosity
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Verbosity -> c Verbosity)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Verbosity)
    -> (Verbosity -> Constr)
    -> (Verbosity -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Verbosity))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Verbosity))
    -> ((forall b. Data b => b -> b) -> Verbosity -> Verbosity)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Verbosity -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Verbosity -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Verbosity -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Verbosity -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity)
    -> Data Verbosity
    Verbosity -> Constr
    Verbosity -> DataType
    (forall b. Data b => b -> b) -> Verbosity -> Verbosity
    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) -> Verbosity -> u
    forall u. (forall d. Data d => d -> u) -> Verbosity -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Verbosity -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Verbosity -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Verbosity
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Verbosity -> c Verbosity
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Verbosity)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Verbosity)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Verbosity -> c Verbosity
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Verbosity -> c Verbosity
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Verbosity
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Verbosity
    $ctoConstr :: Verbosity -> Constr
    toConstr :: Verbosity -> Constr
    $cdataTypeOf :: Verbosity -> DataType
    dataTypeOf :: Verbosity -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Verbosity)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Verbosity)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Verbosity)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Verbosity)
    $cgmapT :: (forall b. Data b => b -> b) -> Verbosity -> Verbosity
    gmapT :: (forall b. Data b => b -> b) -> Verbosity -> Verbosity
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Verbosity -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Verbosity -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Verbosity -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Verbosity -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Verbosity -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Verbosity -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Verbosity -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Verbosity -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verbosity -> m Verbosity
    Data,Int -> Verbosity
    Verbosity -> Int
    Verbosity -> [Verbosity]
    Verbosity -> Verbosity
    Verbosity -> Verbosity -> [Verbosity]
    Verbosity -> Verbosity -> Verbosity -> [Verbosity]
    (Verbosity -> Verbosity)
    -> (Verbosity -> Verbosity)
    -> (Int -> Verbosity)
    -> (Verbosity -> Int)
    -> (Verbosity -> [Verbosity])
    -> (Verbosity -> Verbosity -> [Verbosity])
    -> (Verbosity -> Verbosity -> [Verbosity])
    -> (Verbosity -> Verbosity -> Verbosity -> [Verbosity])
    -> Enum Verbosity
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Verbosity -> Verbosity
    succ :: Verbosity -> Verbosity
    $cpred :: Verbosity -> Verbosity
    pred :: Verbosity -> Verbosity
    $ctoEnum :: Int -> Verbosity
    toEnum :: Int -> Verbosity
    $cfromEnum :: Verbosity -> Int
    fromEnum :: Verbosity -> Int
    $cenumFrom :: Verbosity -> [Verbosity]
    enumFrom :: Verbosity -> [Verbosity]
    $cenumFromThen :: Verbosity -> Verbosity -> [Verbosity]
    enumFromThen :: Verbosity -> Verbosity -> [Verbosity]
    $cenumFromTo :: Verbosity -> Verbosity -> [Verbosity]
    enumFromTo :: Verbosity -> Verbosity -> [Verbosity]
    $cenumFromThenTo :: Verbosity -> Verbosity -> Verbosity -> [Verbosity]
    enumFromThenTo :: Verbosity -> Verbosity -> Verbosity -> [Verbosity]
    Enum,Verbosity
    Verbosity -> Verbosity -> Bounded Verbosity
    forall a. a -> a -> Bounded a
    $cminBound :: Verbosity
    minBound :: Verbosity
    $cmaxBound :: Verbosity
    maxBound :: Verbosity
    Bounded)

    -- | Apply the 'shakeRebuild' flags to a file, determining the desired behaviour
    shakeRebuildApply :: ShakeOptions -> (FilePath -> Rebuild)
    shakeRebuildApply :: ShakeOptions -> String -> Rebuild
    shakeRebuildApply ShakeOptions{shakeRebuild :: ShakeOptions -> [(Rebuild, String)]
    shakeRebuild=[(Rebuild, String)]
    rs}
        | [(Rebuild, String)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [(Rebuild, String)]
    rs = Rebuild -> String -> Rebuild
    forall a b. a -> b -> a
    const Rebuild
    RebuildNormal
        | Bool
    otherwise = \String
    x -> Rebuild -> Maybe Rebuild -> Rebuild
    forall a. a -> Maybe a -> a
    fromMaybe Rebuild
    RebuildNormal (Maybe Rebuild -> Rebuild) -> Maybe Rebuild -> Rebuild
    forall a b. (a -> b) -> a -> b
    $ ((Rebuild, String -> Bool) -> Maybe Rebuild)
    -> [(Rebuild, String -> Bool)] -> Maybe Rebuild
    forall a b. (a -> Maybe b) -> [a] -> Maybe b
    firstJust (\(Rebuild
    r,String -> Bool
    pat) -> if String -> Bool
    pat String
    x then Rebuild -> Maybe Rebuild
    forall a. a -> Maybe a
    Just Rebuild
    r else Maybe Rebuild
    forall a. Maybe a
    Nothing) [(Rebuild, String -> Bool)]
    rs2
            where rs2 :: [(Rebuild, String -> Bool)]
    rs2 = ((Rebuild, String) -> (Rebuild, String -> Bool))
    -> [(Rebuild, String)] -> [(Rebuild, String -> Bool)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((String -> String -> Bool)
    -> (Rebuild, String) -> (Rebuild, String -> Bool)
    forall b b' a. (b -> b') -> (a, b) -> (a, b')
    second String -> String -> Bool
    (?==)) ([(Rebuild, String)] -> [(Rebuild, String -> Bool)])
    -> [(Rebuild, String)] -> [(Rebuild, String -> Bool)]
    forall a b. (a -> b) -> a -> b
    $ [(Rebuild, String)] -> [(Rebuild, String)]
    forall a. [a] -> [a]
    reverse [(Rebuild, String)]
    rs

    shakeAbbreviationsApply :: ShakeOptions -> String -> String
    shakeAbbreviationsApply :: ShakeOptions -> ShowS
    shakeAbbreviationsApply ShakeOptions{shakeAbbreviations :: ShakeOptions -> [(String, String)]
    shakeAbbreviations=[(String, String)]
    abbrev}
        | [(String, String)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [(String, String)]
    abbrev = ShowS
    forall a. a -> a
    id
        | Bool
    otherwise = ShowS
    f
            where
                -- order so longer abbreviations are preferred
                ordAbbrev :: [(String, String)]
    ordAbbrev = ((String, String) -> Int)
    -> [(String, String)] -> [(String, String)]
    forall b a. Ord b => (a -> b) -> [a] -> [a]
    sortOn (Int -> Int
    forall a. Num a => a -> a
    negate (Int -> Int)
    -> ((String, String) -> Int) -> (String, String) -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length (String -> Int)
    -> ((String, String) -> String) -> (String, String) -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (String, String) -> String
    forall a b. (a, b) -> a
    fst) [(String, String)]
    abbrev

                f :: ShowS
    f [] = []
                f String
    x | (String
    to,String
    rest):[(String, String)]
    _ <- [(String
    to,String
    rest) | (String
    from,String
    to) <- [(String, String)]
    ordAbbrev, Just String
    rest <- [String -> String -> Maybe String
    forall a. Eq a => [a] -> [a] -> Maybe [a]
    stripPrefix String
    from String
    x]] = String
    to String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ShowS
    f String
    rest
                f (Char
    x:String
    xs) = Char
    x Char -> ShowS
    forall a. a -> [a] -> [a]
    : ShowS
    f String
    xs