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


-- | A build tool for ATS
--   
--   A collection of scripts to simplify building ATS projects.
@package ats-pkg
@version 2.7.1.2

module Distribution.ATS
cleanATSCabal :: IO ()
fetchDependencies :: ConfigFlags -> [ATSDependency] -> IO ()
newtype Version :: *
Version :: [Integer] -> Version
data ATSDependency
ATSDependency :: String -> FilePath -> String -> ATSDependency

-- | Library name
[_libName] :: ATSDependency -> String

-- | Directory to unpack library into
[_filepath] :: ATSDependency -> FilePath

-- | URL of tarball containing ATS library.
[_url] :: ATSDependency -> String

-- | GMP bindings for ATS
libgmp :: Version -> ATSDependency

-- | Arbitrary-precision arithmetic library for ATS
intinf :: Version -> ATSDependency

-- | ATS prelude
atsPrelude :: Version -> ATSDependency
atsContrib :: Version -> ATSDependency

-- | This uses the users hooks as is <tt>simpleUserHooks</tt>, modified to
--   build the ATS library.
cabalHooks :: UserHooks

-- | This generates user hooks for a Cabal distribution that has some ATS
--   library dependencies. This will *not* do anything with the ATS source
--   files, but it *will* download any files necessary for the bundled C to
--   compile.
atsUserHooks :: [ATSDependency] -> UserHooks

-- | Use this in place of <a>defaultMain</a> for a simple build.
atsPolyglotBuild :: IO ()

module Language.ATS.Package

-- | Build in current directory or indicated directory
buildAll :: Maybe String -> Maybe FilePath -> IO ()
check :: Maybe FilePath -> IO Bool
mkPkg :: Bool -> Bool -> Bool -> [IO ()] -> [String] -> Maybe String -> Int -> IO ()
cleanAll :: IO ()
buildHelper :: Bool -> ATSDependency -> IO ()
checkPkg :: FilePath -> Bool -> IO ATSPackageSet
displayList :: String -> IO ()
upgradeBin :: String -> String -> IO ()
atspkgVersion :: Version

-- | Make a tarball from a directory containing the compiler.
packageCompiler :: FilePath -> IO ()

-- | The default set of install dirs for an ATS package.
atsInstallDirs :: Hashable a => IO (InstallDirs a)
newtype Version :: *
Version :: [Integer] -> Version

-- | Data type associated with <tt>atspkg.dhall</tt> file.
data Pkg
Pkg :: [Bin] -> [Bin] -> [Lib] -> Maybe Text -> Maybe Text -> Version -> Version -> [LibDep] -> [LibDep] -> [LibDep] -> Text -> [Text] -> [Src] -> Bool -> Pkg

-- | List of binaries to be built
[$sel:bin:Pkg] :: Pkg -> [Bin]

-- | List of test suites
[$sel:test:Pkg] :: Pkg -> [Bin]

-- | List of libraries to be built
[$sel:libraries:Pkg] :: Pkg -> [Lib]

-- | Optional (markdown) manpages to be converted using <tt>pandoc</tt>.
[$sel:man:Pkg] :: Pkg -> Maybe Text

-- | Optional <tt>compleat</tt> completions to be installed alongside
--   package.
[$sel:completions:Pkg] :: Pkg -> Maybe Text

-- | Library version
[$sel:version:Pkg] :: Pkg -> Version

-- | Compiler version
[$sel:compiler:Pkg] :: Pkg -> Version

-- | List of library dependencies
[$sel:dependencies:Pkg] :: Pkg -> [LibDep]

-- | List of C library dependencies
[$sel:clib:Pkg] :: Pkg -> [LibDep]

-- | List of ATS library dependencies
[$sel:buildDeps:Pkg] :: Pkg -> [LibDep]

-- | The C compiler we should use
[$sel:ccompiler:Pkg] :: Pkg -> Text

-- | List of flags to pass to the C compiler
[$sel:cflags:Pkg] :: Pkg -> [Text]

-- | ATS source to be compile to C.
[$sel:atsSource:Pkg] :: Pkg -> [Src]

-- | Don't link statically, instead, use libraries installed by
--   <tt>atspkg</tt>.
[$sel:dynLink:Pkg] :: Pkg -> Bool
data Bin
Bin :: Text -> Text -> [Text] -> [ForeignCabal] -> [TargetPair] -> Bool -> [Text] -> Bin

-- | Source file (should end with <tt>.dats</tt>)
[$sel:src:Bin] :: Bin -> Text

-- | Binary to be built
[$sel:target:Bin] :: Bin -> Text

-- | Libraries to link against (e.g. <tt>[ "pthread" ]</tt>)
[$sel:libs:Bin] :: Bin -> [Text]

-- | Haskell <tt>.cabal</tt> files associated with the final library we
--   want to make
[$sel:hsDeps:Bin] :: Bin -> [ForeignCabal]

-- | List of sources and targets for <tt>hs2ats</tt>
[$sel:hs2ats:Bin] :: Bin -> [TargetPair]

-- | Whether to use the garbage collector
[$sel:gcBin:Bin] :: Bin -> Bool

-- | Extra source files the build depends on
[$sel:extras:Bin] :: Bin -> [Text]
data Lib
Lib :: Text -> [Text] -> Text -> [Text] -> [Text] -> [ForeignCabal] -> [(Text, Text)] -> [TargetPair] -> [Text] -> Bool -> Lib

-- | Name of library being provided
[$sel:name:Lib] :: Lib -> Text

-- | Source files (should end with <tt>.dats</tt>) to be compiled to object
--   files
[$sel:src:Lib] :: Lib -> [Text]
[$sel:libTarget:Lib] :: Lib -> Text

-- | Libraries to link against (e.g. <tt>[ "pthread" ]</tt>)
[$sel:libs:Lib] :: Lib -> [Text]

-- | Include files to be installed with the library
[$sel:includes:Lib] :: Lib -> [Text]

-- | Haskell <tt>.cabal</tt> files associated with object files
[$sel:hsDeps:Lib] :: Lib -> [ForeignCabal]

-- | Generate link files.
[$sel:links:Lib] :: Lib -> [(Text, Text)]

-- | Sources and targets for <tt>hs2ats</tt>
[$sel:hs2ats:Lib] :: Lib -> [TargetPair]

-- | Other source files the build depends on
[$sel:extras:Lib] :: Lib -> [Text]

-- | Whether to make a static library
[$sel:static:Lib] :: Lib -> Bool
data Src
Src :: Text -> Text -> [TargetPair] -> [Text] -> Src
[$sel:atsSrc:Src] :: Src -> Text
[$sel:cTarget:Src] :: Src -> Text
[$sel:atsGen:Src] :: Src -> [TargetPair]
[$sel:extras:Src] :: Src -> [Text]
data ATSConstraint
ATSConstraint :: Maybe Version -> Maybe Version -> ATSConstraint
[$sel:lower:ATSConstraint] :: ATSConstraint -> Maybe Version
[$sel:upper:ATSConstraint] :: ATSConstraint -> Maybe Version

-- | Type for a dependency
data ATSDependency
ATSDependency :: Text -> Text -> Text -> Maybe Text -> Version -> [LibDep] -> [LibDep] -> [LibDep] -> ATSDependency

-- | Library name, e.g.
[$sel:libName:ATSDependency] :: ATSDependency -> Text

-- | Directory we should unpack to
[$sel:dir:ATSDependency] :: ATSDependency -> Text

-- | Url pointing to tarball
[$sel:url:ATSDependency] :: ATSDependency -> Text

-- | Package description
[$sel:description:ATSDependency] :: ATSDependency -> Maybe Text
[$sel:libVersion:ATSDependency] :: ATSDependency -> Version

-- | Dependencies to be unpacked
[$sel:libDeps:ATSDependency] :: ATSDependency -> [LibDep]

-- | Dependencies to be built
[$sel:libBldDeps:ATSDependency] :: ATSDependency -> [LibDep]

-- | C dependencies to be built
[$sel:libCDeps:ATSDependency] :: ATSDependency -> [LibDep]

-- | This is just a tuple, except I can figure out how to use it with
--   Dhall.
data TargetPair
TargetPair :: Text -> Text -> Bool -> TargetPair
[$sel:hs:TargetPair] :: TargetPair -> Text
[$sel:ats:TargetPair] :: TargetPair -> Text
[$sel:cpphs:TargetPair] :: TargetPair -> Bool

-- | Data type containing information about Haskell components of a build.
--   Any functions exposed in the object file will be callable in C or ATS
--   code.
data ForeignCabal :: *
ForeignCabal :: Maybe Text -> Text -> Text -> ForeignCabal

-- | <tt>cabal.project</tt> file to track
[projectFile] :: ForeignCabal -> Maybe Text

-- | <tt>.cabal</tt> file associated with the library
[cabalFile] :: ForeignCabal -> Text

-- | Object file to be generated
[objectFile] :: ForeignCabal -> Text
newtype ATSPackageSet
ATSPackageSet :: [ATSDependency] -> ATSPackageSet
[_atsPkgSet] :: ATSPackageSet -> [ATSDependency]
type LibDep = (Text, ATSConstraint)

-- | You likely want <a>$sel:libDeps:ATSDependency</a> or
--   <a>$sel:libBldDeps:ATSDependency</a>
type DepSelector = ATSDependency -> [LibDep]
data PackageError
Unrecognized :: String -> PackageError
DepErr :: ResolveError -> PackageError

-- | The package monad provides information about the package to be
--   installed, in particular, the directory for installation and the
--   directories for dependencies.
newtype Package a b
Package :: ReaderT (InstallDirs a) IO b -> Package a b
[unPack] :: Package a b -> ReaderT (InstallDirs a) IO b

-- | Functions containing installation information about a particular type.
data InstallDirs a
InstallDirs :: (a -> FilePath) -> (a -> String -> FilePath) -> (a -> FilePath) -> (a -> [FilePath]) -> (a -> [FilePath]) -> InstallDirs a
[binDir] :: InstallDirs a -> a -> FilePath
[libDir] :: InstallDirs a -> a -> String -> FilePath
[includeDir] :: InstallDirs a -> a -> FilePath
[includeDeps] :: InstallDirs a -> a -> [FilePath]
[libDeps] :: InstallDirs a -> a -> [FilePath]

-- | Any type implementing <a>GenericPackage</a> can be depended on by
--   other packages.
class Hashable a => GenericPackage a
binRules :: GenericPackage a => a -> Package a ()
libRules :: GenericPackage a => a -> Package a ()
includeRules :: GenericPackage a => a -> Package a ()
dirLens :: Lens' ATSDependency Text