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


-- | CI Assistant for Haskell projects
--   
--   CI Assistant for Haskell projects. Implements package caching.
@package cabal-cache
@version 1.0.0.8

module App.Static
homeDirectory :: FilePath

module HaskellWorks.CabalCache.Concurrent.Fork
forkThreadsWait :: Int -> IO () -> IO ()

module HaskellWorks.CabalCache.Data.Relation.Type
data Relation a b
Relation :: Map a (Set b) -> Map b (Set a) -> Relation a b
[domain] :: Relation a b -> Map a (Set b)
[range] :: Relation a b -> Map b (Set a)
instance GHC.Generics.Generic (HaskellWorks.CabalCache.Data.Relation.Type.Relation a b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (HaskellWorks.CabalCache.Data.Relation.Type.Relation a b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (HaskellWorks.CabalCache.Data.Relation.Type.Relation a b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (HaskellWorks.CabalCache.Data.Relation.Type.Relation a b)

module HaskellWorks.CabalCache.Data.Relation
data Relation a b
Relation :: Map a (Set b) -> Map b (Set a) -> Relation a b
empty :: Relation a b
null :: Relation a b -> Bool
fromList :: (Ord a, Ord b) => [(a, b)] -> Relation a b
toList :: Relation a b -> [(a, b)]
singleton :: a -> b -> Relation a b
insert :: (Ord a, Ord b) => a -> b -> Relation a b -> Relation a b
delete :: (Ord a, Ord b) => a -> b -> Relation a b -> Relation a b
domain :: Relation a b -> Set a
range :: Relation a b -> Set b
restrictDomain :: (Ord a, Ord b) => Set a -> Relation a b -> Relation a b
restrictRange :: (Ord a, Ord b) => Set b -> Relation a b -> Relation a b
withoutDomain :: (Ord a, Ord b) => Set a -> Relation a b -> Relation a b
withoutRange :: (Ord a, Ord b) => Set b -> Relation a b -> Relation a b

module HaskellWorks.CabalCache.GhcPkg
runGhcPkg :: [String] -> IO ()
testAvailability :: IO ()
recache :: FilePath -> IO ()
init :: FilePath -> IO ()

module HaskellWorks.CabalCache.Hash
hashStorePath :: String -> String

module HaskellWorks.CabalCache.IO.Console
putStrLn :: MonadIO m => Text -> m ()
print :: (MonadIO m, Show a) => a -> m ()
hPutStrLn :: MonadIO m => Handle -> Text -> m ()
hPrint :: (MonadIO m, Show a) => Handle -> a -> m ()

module HaskellWorks.CabalCache.IO.File
copyDirectoryRecursive :: MonadIO m => FilePath -> FilePath -> ExceptT String m ()
listMaybeDirectory :: MonadIO m => FilePath -> m [FilePath]

module HaskellWorks.CabalCache.Location
class IsPath a s | a -> s
(</>) :: IsPath a s => a -> s -> a
(<.>) :: IsPath a s => a -> s -> a
infixr 5 </>
infixr 7 <.>
data Location
S3 :: S3Uri -> Location
Local :: FilePath -> Location
HttpUri :: Text -> Location
toLocation :: Text -> Maybe Location
instance GHC.Generics.Generic HaskellWorks.CabalCache.Location.Location
instance GHC.Classes.Eq HaskellWorks.CabalCache.Location.Location
instance GHC.Show.Show HaskellWorks.CabalCache.Location.Location
instance Network.AWS.Data.Text.ToText HaskellWorks.CabalCache.Location.Location
instance HaskellWorks.CabalCache.Location.IsPath HaskellWorks.CabalCache.Location.Location Data.Text.Internal.Text
instance HaskellWorks.CabalCache.Location.IsPath Data.Text.Internal.Text Data.Text.Internal.Text
instance (a Data.Type.Equality.~ GHC.Types.Char) => HaskellWorks.CabalCache.Location.IsPath [a] [a]
instance HaskellWorks.CabalCache.Location.IsPath Antiope.S3.Types.S3Uri Data.Text.Internal.Text

module App.Commands.Options.Types
data SyncToArchiveOptions
SyncToArchiveOptions :: Region -> Location -> FilePath -> Maybe String -> Int -> Maybe LogLevel -> SyncToArchiveOptions
[$sel:region:SyncToArchiveOptions] :: SyncToArchiveOptions -> Region
[$sel:archiveUri:SyncToArchiveOptions] :: SyncToArchiveOptions -> Location
[$sel:storePath:SyncToArchiveOptions] :: SyncToArchiveOptions -> FilePath
[$sel:storePathHash:SyncToArchiveOptions] :: SyncToArchiveOptions -> Maybe String
[$sel:threads:SyncToArchiveOptions] :: SyncToArchiveOptions -> Int
[$sel:awsLogLevel:SyncToArchiveOptions] :: SyncToArchiveOptions -> Maybe LogLevel
data SyncFromArchiveOptions
SyncFromArchiveOptions :: Region -> Location -> FilePath -> Maybe String -> Int -> Maybe LogLevel -> SyncFromArchiveOptions
[$sel:region:SyncFromArchiveOptions] :: SyncFromArchiveOptions -> Region
[$sel:archiveUri:SyncFromArchiveOptions] :: SyncFromArchiveOptions -> Location
[$sel:storePath:SyncFromArchiveOptions] :: SyncFromArchiveOptions -> FilePath
[$sel:storePathHash:SyncFromArchiveOptions] :: SyncFromArchiveOptions -> Maybe String
[$sel:threads:SyncFromArchiveOptions] :: SyncFromArchiveOptions -> Int
[$sel:awsLogLevel:SyncFromArchiveOptions] :: SyncFromArchiveOptions -> Maybe LogLevel
data VersionOptions
VersionOptions :: VersionOptions
instance GHC.Generics.Generic App.Commands.Options.Types.VersionOptions
instance GHC.Show.Show App.Commands.Options.Types.VersionOptions
instance GHC.Classes.Eq App.Commands.Options.Types.VersionOptions
instance GHC.Generics.Generic App.Commands.Options.Types.SyncFromArchiveOptions
instance GHC.Show.Show App.Commands.Options.Types.SyncFromArchiveOptions
instance GHC.Classes.Eq App.Commands.Options.Types.SyncFromArchiveOptions
instance GHC.Generics.Generic App.Commands.Options.Types.SyncToArchiveOptions
instance GHC.Show.Show App.Commands.Options.Types.SyncToArchiveOptions
instance GHC.Classes.Eq App.Commands.Options.Types.SyncToArchiveOptions

module App.Commands.Options.Parser
optsSyncFromArchive :: Parser SyncFromArchiveOptions
optsSyncToArchive :: Parser SyncToArchiveOptions
optsVersion :: Parser VersionOptions
text :: FromText a => ReadM a

module HaskellWorks.CabalCache.Options
readOrFromTextOption :: (Read a, FromText a) => Mod OptionFields a -> Parser a

module HaskellWorks.CabalCache.Show
tshow :: Show a => a -> Text

module HaskellWorks.CabalCache.AppError
data AppError
AwsAppError :: Status -> AppError
[status] :: AppError -> Status
HttpAppError :: Status -> AppError
[status] :: AppError -> Status
RetriesFailedAppError :: AppError
NotFound :: AppError
GenericAppError :: Text -> AppError
displayAppError :: AppError -> Text
appErrorStatus :: AppError -> Maybe Int
instance GHC.Generics.Generic HaskellWorks.CabalCache.AppError.AppError
instance GHC.Show.Show HaskellWorks.CabalCache.AppError.AppError
instance GHC.Classes.Eq HaskellWorks.CabalCache.AppError.AppError
instance Data.String.IsString HaskellWorks.CabalCache.AppError.AppError

module HaskellWorks.CabalCache.IO.Tar
data TarGroup
TarGroup :: FilePath -> [FilePath] -> TarGroup
[basePath] :: TarGroup -> FilePath
[entryPaths] :: TarGroup -> [FilePath]
createTar :: MonadIO m => FilePath -> [TarGroup] -> ExceptT AppError m ()
extractTar :: MonadIO m => FilePath -> FilePath -> ExceptT AppError m ()
instance Control.DeepSeq.NFData HaskellWorks.CabalCache.IO.Tar.TarGroup
instance GHC.Generics.Generic HaskellWorks.CabalCache.IO.Tar.TarGroup
instance GHC.Classes.Eq HaskellWorks.CabalCache.IO.Tar.TarGroup
instance GHC.Show.Show HaskellWorks.CabalCache.IO.Tar.TarGroup

module HaskellWorks.CabalCache.IO.Lazy
readResource :: (MonadResource m, MonadCatch m) => Env -> Location -> m (Either AppError ByteString)
readFirstAvailableResource :: (MonadResource m, MonadCatch m) => Env -> [Location] -> m (Either AppError (ByteString, Location))
resourceExists :: (MonadUnliftIO m, MonadCatch m, MonadIO m) => Env -> Location -> m Bool
firstExistingResource :: (MonadUnliftIO m, MonadCatch m, MonadIO m) => Env -> [Location] -> m (Maybe Location)
headS3Uri :: (MonadResource m, MonadCatch m) => Env -> S3Uri -> m (Either AppError HeadObjectResponse)
writeResource :: (MonadUnliftIO m, MonadCatch m) => Env -> Location -> ByteString -> m (Either AppError ())
createLocalDirectoryIfMissing :: (MonadCatch m, MonadIO m) => Location -> m ()
linkOrCopyResource :: (MonadUnliftIO m, MonadCatch m) => Env -> Location -> Location -> ExceptT AppError m ()
readHttpUri :: (MonadIO m, MonadCatch m) => Text -> m (Either AppError ByteString)
removePathRecursive :: (MonadIO m, MonadCatch m) => FilePath -> m (Either AppError ())

module HaskellWorks.CabalCache.IO.Error
exceptFatal :: MonadIO m => ExceptT AppError m a -> ExceptT AppError m a
exceptWarn :: MonadIO m => ExceptT AppError m a -> ExceptT AppError m a
maybeToExcept :: Monad m => AppError -> Maybe a -> ExceptT AppError m a
maybeToExceptM :: Monad m => AppError -> m (Maybe a) -> ExceptT AppError m a

module HaskellWorks.CabalCache.AWS.Env
awsLogger :: Maybe LogLevel -> LogLevel -> ByteString -> IO ()

module HaskellWorks.CabalCache.Text
maybeStripPrefix :: Text -> Text -> Text

module HaskellWorks.CabalCache.Types
type CompilerId = Text
type PackageId = Text
data PlanJson
PlanJson :: CompilerId -> [Package] -> PlanJson
[$sel:compilerId:PlanJson] :: PlanJson -> CompilerId
[$sel:installPlan:PlanJson] :: PlanJson -> [Package]
data Package
Package :: Text -> PackageId -> Text -> Text -> Maybe Text -> Maybe Text -> Maybe Components -> [Text] -> [Text] -> Package
[$sel:packageType:Package] :: Package -> Text
[$sel:id:Package] :: Package -> PackageId
[$sel:name:Package] :: Package -> Text
[$sel:version:Package] :: Package -> Text
[$sel:style:Package] :: Package -> Maybe Text
[$sel:componentName:Package] :: Package -> Maybe Text
[$sel:components:Package] :: Package -> Maybe Components
[$sel:depends:Package] :: Package -> [Text]
[$sel:exeDepends:Package] :: Package -> [Text]
newtype Components
Components :: Maybe Lib -> Components
[$sel:lib:Components] :: Components -> Maybe Lib
data Lib
Lib :: [Text] -> [Text] -> Lib
[$sel:depends:Lib] :: Lib -> [Text]
[$sel:exeDepends:Lib] :: Lib -> [Text]
instance GHC.Generics.Generic HaskellWorks.CabalCache.Types.PlanJson
instance GHC.Show.Show HaskellWorks.CabalCache.Types.PlanJson
instance GHC.Classes.Eq HaskellWorks.CabalCache.Types.PlanJson
instance GHC.Generics.Generic HaskellWorks.CabalCache.Types.Package
instance GHC.Show.Show HaskellWorks.CabalCache.Types.Package
instance GHC.Classes.Eq HaskellWorks.CabalCache.Types.Package
instance GHC.Generics.Generic HaskellWorks.CabalCache.Types.Components
instance GHC.Show.Show HaskellWorks.CabalCache.Types.Components
instance GHC.Classes.Eq HaskellWorks.CabalCache.Types.Components
instance GHC.Generics.Generic HaskellWorks.CabalCache.Types.Lib
instance GHC.Show.Show HaskellWorks.CabalCache.Types.Lib
instance GHC.Classes.Eq HaskellWorks.CabalCache.Types.Lib
instance Data.Aeson.Types.FromJSON.FromJSON HaskellWorks.CabalCache.Types.PlanJson
instance Data.Aeson.Types.FromJSON.FromJSON HaskellWorks.CabalCache.Types.Package
instance Data.Aeson.Types.FromJSON.FromJSON HaskellWorks.CabalCache.Types.Components
instance Data.Aeson.Types.FromJSON.FromJSON HaskellWorks.CabalCache.Types.Lib

module HaskellWorks.CabalCache.Topology
newtype PlanData
PlanData :: Set PackageId -> PlanData
[nonShareable] :: PlanData -> Set PackageId
buildPlanData :: PlanJson -> [PackageId] -> PlanData
canShare :: PlanData -> PackageId -> Bool
instance GHC.Generics.Generic HaskellWorks.CabalCache.Topology.PlanData

module HaskellWorks.CabalCache.Core
data PackageInfo
PackageInfo :: CompilerId -> PackageId -> PackageDir -> Tagged ConfPath Presence -> [Library] -> PackageInfo
[$sel:compilerId:PackageInfo] :: PackageInfo -> CompilerId
[$sel:packageId:PackageInfo] :: PackageInfo -> PackageId
[$sel:packageDir:PackageInfo] :: PackageInfo -> PackageDir
[$sel:confPath:PackageInfo] :: PackageInfo -> Tagged ConfPath Presence
[$sel:libs:PackageInfo] :: PackageInfo -> [Library]
data Tagged a t
Tagged :: a -> t -> Tagged a t
[$sel:value:Tagged] :: Tagged a t -> a
[$sel:tag:Tagged] :: Tagged a t -> t
data Presence
Present :: Presence
Absent :: Presence
getPackages :: FilePath -> PlanJson -> IO [PackageInfo]
relativePaths :: FilePath -> PackageInfo -> [TarGroup]
loadPlan :: IO (Either AppError PlanJson)
instance Control.DeepSeq.NFData HaskellWorks.CabalCache.Core.PackageInfo
instance GHC.Generics.Generic HaskellWorks.CabalCache.Core.PackageInfo
instance GHC.Classes.Eq HaskellWorks.CabalCache.Core.PackageInfo
instance GHC.Show.Show HaskellWorks.CabalCache.Core.PackageInfo
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData t) => Control.DeepSeq.NFData (HaskellWorks.CabalCache.Core.Tagged a t)
instance GHC.Generics.Generic (HaskellWorks.CabalCache.Core.Tagged a t)
instance (GHC.Show.Show a, GHC.Show.Show t) => GHC.Show.Show (HaskellWorks.CabalCache.Core.Tagged a t)
instance (GHC.Classes.Eq a, GHC.Classes.Eq t) => GHC.Classes.Eq (HaskellWorks.CabalCache.Core.Tagged a t)
instance GHC.Generics.Generic HaskellWorks.CabalCache.Core.Presence
instance Control.DeepSeq.NFData HaskellWorks.CabalCache.Core.Presence
instance GHC.Show.Show HaskellWorks.CabalCache.Core.Presence
instance GHC.Classes.Eq HaskellWorks.CabalCache.Core.Presence

module HaskellWorks.CabalCache.Metadata
metaDir :: String
createMetadata :: MonadIO m => FilePath -> PackageInfo -> [(Text, ByteString)] -> m TarGroup
loadMetadata :: MonadIO m => FilePath -> m (Map Text ByteString)
deleteMetadata :: MonadIO m => FilePath -> m ()

module HaskellWorks.CabalCache.Concurrent.Type
data DownloadQueue
DownloadQueue :: TVar (Relation ConsumerId ProviderId) -> TVar (Set PackageId) -> TVar (Set PackageId) -> DownloadQueue
[$sel:tDependencies:DownloadQueue] :: DownloadQueue -> TVar (Relation ConsumerId ProviderId)
[$sel:tUploading:DownloadQueue] :: DownloadQueue -> TVar (Set PackageId)
[$sel:tFailures:DownloadQueue] :: DownloadQueue -> TVar (Set PackageId)
type ConsumerId = PackageId
type ProviderId = PackageId
type PackageId = Text
instance GHC.Generics.Generic HaskellWorks.CabalCache.Concurrent.Type.DownloadQueue

module HaskellWorks.CabalCache.Concurrent.DownloadQueue
createDownloadQueue :: [(ProviderId, ConsumerId)] -> STM DownloadQueue
anchor :: PackageId -> Map ConsumerId ProviderId -> Map ConsumerId ProviderId
runQueue :: MonadIO m => DownloadQueue -> (PackageId -> m Bool) -> m ()

module HaskellWorks.CabalCache.Version
archiveVersion :: IsString s => s

module App.Commands.SyncToArchive
cmdSyncToArchive :: Mod CommandFields (IO ())

module App.Commands.SyncFromArchive
cmdSyncFromArchive :: Mod CommandFields (IO ())

module App.Commands.Version
cmdVersion :: Mod CommandFields (IO ())

module App.Commands
commands :: Parser (IO ())
commandsGeneral :: Parser (IO ())