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


-- | A tool and library for building virtual machine images.
--   
--   Build virtual machine images for vm-deployments; resize, un-partition,
--   create from scratch or convert disk image files in a variety of
--   formats; assemble and generate all associated files from templates and
--   regular files. VM images can further be modifed through scripts, which
--   are executed in LXC containers into which the vm-images as well as
--   arbitrary directories from the host are mounted. All assembled files
--   can also be accessed by vm build scripts through a special directory
--   mounted in the build container, and/or can be written to directories,
--   ISO- or VFAT-images. The ISO/VFAT images that B9 creates are
--   compatible to 'cloud-init's <a>NoCloud</a> data source; B9 is also
--   very well suited for compiling in a containerized environment. For
--   these applications, the images can be marked as <a>Transient</a> to
--   indicate no further interest in the VM-image itself, and B9 will
--   discard them after the build. B9 will never over-write source files,
--   not even large vm-image files - there is no intended way to modify a
--   source vm-image file 'in-place'. B9 operates in random build
--   directories, which are discarded when the build exists.
@package b9
@version 3.1.0


-- | Programmatic Interface to b9 artifact generation.
--   
--   An extensible approach to vm deployment configuration management.
--   
--   TODO: do it.
module B9.Artifact


-- | Error handling in B9 via extensible effects. B9 wraps errors in
--   <a>SomeException</a>.
module B9.B9Error

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwSomeException :: (Member ExcB9 e, Exception x) => x -> Eff e a

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwSomeException_ :: (Member ExcB9 e, Exception x) => x -> Eff e ()

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwB9Error :: Member ExcB9 e => String -> Eff e a

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwB9Error_ :: Member ExcB9 e => String -> Eff e ()

-- | Run an <a>ExcB9</a> and rethrow the exception with <a>error</a>.
errorOnException :: Lifted IO e => Eff (ExcB9 : e) a -> Eff e a

-- | The exception effect used in most places in B9. This is <a>Exc</a>
--   specialized with <a>SomeException</a>.
type ExcB9 = Exc SomeException

-- | Constraint alias for the exception effect that allows to throw
--   <a>SomeException</a>.
type WithIoExceptions e = SetMember Exc (Exc SomeException) e

-- | Run an <a>ExcB9</a>.
runExcB9 :: Eff (ExcB9 : e) a -> Eff e (Either SomeException a)

-- | This is a simple runtime exception to indicate that B9 code
--   encountered some exceptional event.
newtype B9Error
MkB9Error :: String -> B9Error
fromB9Error :: B9Error -> String

-- | Catch exceptions.
catchB9Error :: Member ExcB9 e => Eff e a -> (SomeException -> Eff e a) -> Eff e a

-- | Catch exceptions and return them via <a>Either</a>.
catchB9ErrorAsEither :: Member ExcB9 e => Eff e a -> Eff e (Either SomeException a)

-- | Always execute an action and rethrow any exceptions caught.
finallyB9 :: Member ExcB9 e => Eff e a -> Eff e () -> Eff e a
instance Data.String.IsString B9.B9Error.B9Error
instance GHC.Show.Show B9.B9Error.B9Error
instance GHC.Exception.Type.Exception B9.B9Error.B9Error


-- | Utility module to extract a primary partition from an MBR partition on
--   a raw image file.
module B9.MBR
getPartition :: Int -> FilePath -> IO (Word64, Word64)
data PrimaryPartition
PrimaryPartition :: !Word8 -> !CHS -> !Word8 -> !CHS -> !Word32 -> !Word32 -> PrimaryPartition
[primPartStatus] :: PrimaryPartition -> !Word8
[primPartChsStart] :: PrimaryPartition -> !CHS
[primPartPartType] :: PrimaryPartition -> !Word8
[primPartChsEnd] :: PrimaryPartition -> !CHS
[primPartLbaStart] :: PrimaryPartition -> !Word32
[primPartSectors] :: PrimaryPartition -> !Word32
data MBR
MBR :: !PrimaryPartition -> !PrimaryPartition -> !PrimaryPartition -> !PrimaryPartition -> MBR
[mbrPart1] :: MBR -> !PrimaryPartition
[mbrPart2] :: MBR -> !PrimaryPartition
[mbrPart3] :: MBR -> !PrimaryPartition
[mbrPart4] :: MBR -> !PrimaryPartition
data CHS
CHS :: !Word8 -> !Word8 -> !Word8 -> CHS
[chsH] :: CHS -> !Word8
[chs_CUpper2_S] :: CHS -> !Word8
[chs_CLower8] :: CHS -> !Word8
instance GHC.Show.Show B9.MBR.MBR
instance GHC.Show.Show B9.MBR.PrimaryPartition
instance GHC.Show.Show B9.MBR.CHS


-- | Function to find the file offsets of primary partitions in raw disk
--   images. Currently only MBR partitions are supported. See <a>MBR</a>
module B9.PartitionTable
getPartition :: Int -> FilePath -> IO (Word64, Word64, Word64)


-- | Some QuickCheck utility functions.
module B9.QCUtil
arbitraryEnv :: Arbitrary a => Gen [(String, a)]
halfSize :: Gen a -> Gen a
smaller :: Gen a -> Gen a
arbitraryFilePath :: Gen FilePath
arbitraryLetter :: Gen Char
arbitraryLetterUpper :: Gen Char
arbitraryLetterLower :: Gen Char
arbitraryDigit :: Gen Char


-- | Data types that describe all B9 relevant elements of virtual machine
--   disk images.
module B9.DiskImages

-- | Build target for disk images; the destination, format and size of the
--   image to generate, as well as how to create or obtain the image before
--   a <a>VmScript</a> is executed with the image mounted at a
--   <a>MountPoint</a>.
data ImageTarget
ImageTarget :: ImageDestination -> ImageSource -> MountPoint -> ImageTarget

-- | A mount point or <a>NotMounted</a>
data MountPoint
MountPoint :: FilePath -> MountPoint
NotMounted :: MountPoint

-- | The destination of an image.
data ImageDestination

-- | Create the image and some meta data so that other builds can use them
--   as <a>ImageSource</a>s via <a>From</a>.
Share :: String -> ImageType -> ImageResize -> ImageDestination

-- | <b>DEPRECATED</b> Export a raw image that can directly be booted.
LiveInstallerImage :: String -> FilePath -> ImageResize -> ImageDestination

-- | Write an image file to the path in the first argument., possible
--   resizing it,
LocalFile :: Image -> ImageResize -> ImageDestination

-- | Do not export the image. Usefule if the main objective of the b9 build
--   is not an image file, but rather some artifact produced by executing
--   by a containerize build.
Transient :: ImageDestination

-- | Specification of how the image to build is obtained.
data ImageSource

-- | Create an empty image file having a file system label (first
--   parameter), a file system type (e.g. <a>Ext4</a>) and an
--   <a>ImageSize</a>
EmptyImage :: String -> FileSystem -> ImageType -> ImageSize -> ImageSource

-- | <b>DEPRECATED</b>
CopyOnWrite :: Image -> ImageSource

-- | Clone an existing image file; if the image file contains partitions,
--   select the partition to use, b9 will extract that partition by reading
--   the offset of the partition from the partition table and extract it
--   using <tt>dd</tt>.
SourceImage :: Image -> Partition -> ImageResize -> ImageSource

-- | Use an image previously shared by via <a>Share</a>.
From :: String -> ImageResize -> ImageSource

-- | The partition to extract.
data Partition

-- | There is no partition table on the image
NoPT :: Partition

-- | Extract partition <tt>n</tt> <tt>n</tt> must be in <tt>0..3</tt>
Partition :: Int -> Partition

-- | A vm disk image file consisting of a path to the image file, and the
--   type and file system.
data Image
Image :: FilePath -> ImageType -> FileSystem -> Image

-- | An image type defines the actual <i>file format</i> of a file
--   containing file systems. These are like <i>virtual harddrives</i>
data ImageType
Raw :: ImageType
QCow2 :: ImageType
Vmdk :: ImageType

-- | The file systems that b9 can use and convert.
data FileSystem
NoFileSystem :: FileSystem
Ext4 :: FileSystem
Ext4_64 :: FileSystem
ISO9660 :: FileSystem
VFAT :: FileSystem

-- | A data type for image file or file system size; instead of passing
--   <a>Int</a>s around this also captures a size unit so that the
--   <a>Int</a> can be kept small
data ImageSize
ImageSize :: Int -> SizeUnit -> ImageSize

-- | Convert a size in bytes to an <a>ImageSize</a>
bytesToKiloBytes :: Int -> ImageSize

-- | Convert an <a>ImageSize</a> to kibi bytes.
imageSizeToKiB :: ImageSize -> Int

-- | Convert a <a>SizeUnit</a> to the number of kibi bytes one element
--   represents.
sizeUnitKiB :: SizeUnit -> Int

-- | Choose the greatest unit possible to exactly represent an
--   <a>ImageSize</a>.
normalizeSize :: ImageSize -> ImageSize

-- | Return the sum of two <tt><a>ImageSize</a>s</tt>.
addImageSize :: ImageSize -> ImageSize -> ImageSize

-- | Enumeration of size multipliers. The exact semantics may vary
--   depending on what external tools look at these. E.g. the size unit is
--   convert to a size parameter of the <tt>qemu-img</tt> command line
--   tool.
data SizeUnit
KB :: SizeUnit
MB :: SizeUnit
GB :: SizeUnit

-- | How to resize an image file.
data ImageResize

-- | Resize the image <b>but not the file system</b>. Note that a file
--   system contained in the image file might be corrupted by this
--   operation. To not only resize the image file but also the fil system
--   contained in it, use <a>Resize</a>.
ResizeImage :: ImageSize -> ImageResize

-- | Resize an image and the contained file system.
Resize :: ImageSize -> ImageResize

-- | Shrink to minimum size needed and increase by the amount given.
ShrinkToMinimumAndIncrease :: ImageSize -> ImageResize

-- | Resize an image and the contained file system to the smallest size to
--   fit the contents of the file system.
ShrinkToMinimum :: ImageResize

-- | Do not change the image size.
KeepSize :: ImageResize

-- | A type alias that indicates that something of type <tt>a</tt> is mount
--   at a <a>MountPoint</a>
type Mounted a = (a, MountPoint)

-- | <a>SharedImage</a> holds all data necessary to describe an
--   <b>instance</b> of a shared image identified by a
--   <a>SharedImageName</a>. Shared images are stored in
--   <a>Repository</a>s.
data SharedImage
SharedImage :: SharedImageName -> SharedImageDate -> SharedImageBuildId -> ImageType -> FileSystem -> SharedImage

-- | The name of the image is the de-facto identifier for push, pull,
--   <a>From</a> and <a>Share</a>. B9 always selects the newest version the
--   shared image identified by that name when using a shared image as an
--   <a>ImageSource</a>. This is a wrapper around a string that identifies
--   a <a>SharedImage</a>
newtype SharedImageName
SharedImageName :: String -> SharedImageName

-- | Get the String representation of a <a>SharedImageName</a>.
fromSharedImageName :: SharedImageName -> String

-- | The exact time that build job <b>started</b>. This is a wrapper around
--   a string contains the build date of a <a>SharedImage</a>; this is
--   purely additional convenience and typesafety
newtype SharedImageDate
SharedImageDate :: String -> SharedImageDate

-- | Every B9 build running in a <tt>B9Monad</tt> contains a random unique
--   id that is generated once per build (no matter how many artifacts are
--   created in that build) This field contains the build id of the build
--   that created the shared image instance. This is A wrapper around a
--   string contains the build id of a <a>SharedImage</a>; this is purely
--   additional convenience and typesafety
newtype SharedImageBuildId
SharedImageBuildId :: String -> SharedImageBuildId

-- | Get the String representation of a <a>SharedImageBuildId</a>.
fromSharedImageBuildId :: SharedImageBuildId -> String

-- | Transform a list of <a>SharedImage</a> values into a <a>Map</a> that
--   associates each <a>SharedImageName</a> with a <a>Set</a> of the actual
--   images with that name.
--   
--   The <a>Set</a> contains values of type <tt><a>SharedImage</a></tt>.
--   
--   The <a>Ord</a> instance of <a>SharedImage</a> sorts by name first and
--   then by <a>sharedImageDate</a>, since the values in a <a>Set</a> share
--   the same <a>sharedImageName</a>, they are effectively orderd by build
--   date, which is useful the shared image cleanup.
sharedImagesToMap :: [SharedImage] -> Map SharedImageName (Set SharedImage)

-- | Return the <a>SharedImage</a> with the highest <a>sharedImageDate</a>.
takeLatestSharedImage :: [SharedImage] -> Maybe SharedImage

-- | Return the name of the file corresponding to an <a>Image</a>
imageFileName :: Image -> FilePath

-- | Return the <a>ImageType</a> of an <a>Image</a>
imageImageType :: Image -> ImageType

-- | Return the files generated for a <a>LocalFile</a> or a
--   <a>LiveInstallerImage</a>; <a>SharedImage</a> and <a>Transient</a> are
--   treated like they have no output files because the output files are
--   manged by B9.
getImageDestinationOutputFiles :: ImageTarget -> [FilePath]

-- | Return the name of a shared image, if the <a>ImageDestination</a> is a
--   <a>Share</a> destination
imageDestinationSharedImageName :: ImageDestination -> Maybe SharedImageName

-- | Return the name of a shared source image, if the <a>ImageSource</a> is
--   a <a>From</a> source
imageSourceSharedImageName :: ImageSource -> Maybe SharedImageName

-- | Get the <a>ImageDestination</a> of an <a>ImageTarget</a>
itImageDestination :: ImageTarget -> ImageDestination

-- | Get the <a>ImageSource</a> of an <a>ImageTarget</a>
itImageSource :: ImageTarget -> ImageSource

-- | Get the <a>MountPoint</a> of an <a>ImageTarget</a>
itImageMountPoint :: ImageTarget -> MountPoint

-- | Return true if a <a>Partition</a> parameter is actually referring to a
--   partition, false if it is <a>NoPT</a>
isPartitioned :: Partition -> Bool

-- | Return the <a>Partition</a> index or throw a runtime error if applied
--   to <a>NoPT</a>
getPartition :: Partition -> Int

-- | Return the file name extension of an image file with a specific image
--   format.
imageFileExtension :: ImageType -> String

-- | Change the image file format and also rename the image file name to
--   have the appropriate file name extension. See
--   <a>imageFileExtension</a> and <a>replaceExtension</a>
changeImageFormat :: ImageType -> Image -> Image
changeImageDirectory :: FilePath -> Image -> Image
getImageSourceImageType :: ImageSource -> Maybe ImageType

-- | Return the name of a shared image.
sharedImageName :: SharedImage -> SharedImageName

-- | Return the build date of a shared image.
sharedImageDate :: SharedImage -> SharedImageDate

-- | Return the build id of a shared image.
sharedImageBuildId :: SharedImage -> SharedImageBuildId

-- | Print the contents of the shared image in one line
prettyPrintSharedImages :: Set SharedImage -> String

-- | Return the disk image of an sharedImage
sharedImageImage :: SharedImage -> Image

-- | Calculate the path to the text file holding the serialized
--   <a>SharedImage</a> relative to the directory of shared images in a
--   repository.
sharedImageFileName :: SharedImage -> FilePath
sharedImagesRootDirectory :: FilePath
sharedImageFileExtension :: String

-- | The internal image type to use as best guess when dealing with a
--   <a>From</a> value.
sharedImageDefaultImageType :: ImageType

-- | Use a <a>QCow2</a> image with an <a>Ext4</a> file system
transientCOWImage :: FilePath -> FilePath -> ImageTarget

-- | Use a shared image
transientSharedImage :: SharedImageName -> FilePath -> ImageTarget

-- | Use a shared image
transientLocalImage :: FilePath -> FilePath -> ImageTarget

-- | Share a <a>QCow2</a> image with <a>Ext4</a> fs
shareCOWImage :: FilePath -> SharedImageName -> FilePath -> ImageTarget

-- | Share an image based on a shared image
shareSharedImage :: SharedImageName -> SharedImageName -> FilePath -> ImageTarget

-- | Share a <a>QCow2</a> image with <a>Ext4</a> fs
shareLocalImage :: FilePath -> SharedImageName -> FilePath -> ImageTarget

-- | Export a <a>QCow2</a> image with <a>Ext4</a> fs
cowToliveInstallerImage :: String -> FilePath -> FilePath -> FilePath -> ImageTarget

-- | Export a <a>QCow2</a> image file with <a>Ext4</a> fs as a local file
cowToLocalImage :: FilePath -> FilePath -> FilePath -> ImageTarget

-- | Export a <a>QCow2</a> image file with <a>Ext4</a> fs as a local file
localToLocalImage :: FilePath -> FilePath -> FilePath -> ImageTarget

-- | Create a local image file from the contents of the first partition of
--   a local <a>QCow2</a> image.
partition1ToLocalImage :: FilePath -> FilePath -> FilePath -> ImageTarget

-- | Split any image target into two image targets, one for creating an
--   intermediate shared image and one from the intermediate shared image
--   to the output image.
splitToIntermediateSharedImage :: ImageTarget -> SharedImageName -> (ImageTarget, ImageTarget)
arbitrarySharedImageName :: Gen String
unitTests :: Spec
instance GHC.Generics.Generic B9.DiskImages.SharedImage
instance Data.Data.Data B9.DiskImages.SharedImage
instance GHC.Show.Show B9.DiskImages.SharedImage
instance GHC.Read.Read B9.DiskImages.SharedImage
instance GHC.Classes.Eq B9.DiskImages.SharedImage
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.DiskImages.SharedImageBuildId
instance Control.DeepSeq.NFData B9.DiskImages.SharedImageBuildId
instance Data.Binary.Class.Binary B9.DiskImages.SharedImageBuildId
instance Data.Hashable.Class.Hashable B9.DiskImages.SharedImageBuildId
instance Data.Data.Data B9.DiskImages.SharedImageBuildId
instance GHC.Show.Show B9.DiskImages.SharedImageBuildId
instance GHC.Read.Read B9.DiskImages.SharedImageBuildId
instance GHC.Classes.Ord B9.DiskImages.SharedImageBuildId
instance GHC.Classes.Eq B9.DiskImages.SharedImageBuildId
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.DiskImages.SharedImageDate
instance Control.DeepSeq.NFData B9.DiskImages.SharedImageDate
instance Data.Binary.Class.Binary B9.DiskImages.SharedImageDate
instance Data.Hashable.Class.Hashable B9.DiskImages.SharedImageDate
instance Data.Data.Data B9.DiskImages.SharedImageDate
instance GHC.Show.Show B9.DiskImages.SharedImageDate
instance GHC.Read.Read B9.DiskImages.SharedImageDate
instance GHC.Classes.Ord B9.DiskImages.SharedImageDate
instance GHC.Classes.Eq B9.DiskImages.SharedImageDate
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.DiskImages.SharedImageName
instance Control.DeepSeq.NFData B9.DiskImages.SharedImageName
instance Data.Binary.Class.Binary B9.DiskImages.SharedImageName
instance Data.Hashable.Class.Hashable B9.DiskImages.SharedImageName
instance Data.Data.Data B9.DiskImages.SharedImageName
instance GHC.Show.Show B9.DiskImages.SharedImageName
instance GHC.Read.Read B9.DiskImages.SharedImageName
instance GHC.Classes.Ord B9.DiskImages.SharedImageName
instance GHC.Classes.Eq B9.DiskImages.SharedImageName
instance GHC.Generics.Generic B9.DiskImages.ImageTarget
instance GHC.Classes.Eq B9.DiskImages.ImageTarget
instance Data.Data.Data B9.DiskImages.ImageTarget
instance GHC.Show.Show B9.DiskImages.ImageTarget
instance GHC.Read.Read B9.DiskImages.ImageTarget
instance GHC.Generics.Generic B9.DiskImages.ImageDestination
instance GHC.Classes.Eq B9.DiskImages.ImageDestination
instance Data.Data.Data B9.DiskImages.ImageDestination
instance GHC.Show.Show B9.DiskImages.ImageDestination
instance GHC.Read.Read B9.DiskImages.ImageDestination
instance GHC.Generics.Generic B9.DiskImages.ImageSource
instance GHC.Classes.Eq B9.DiskImages.ImageSource
instance Data.Data.Data B9.DiskImages.ImageSource
instance GHC.Read.Read B9.DiskImages.ImageSource
instance GHC.Show.Show B9.DiskImages.ImageSource
instance GHC.Generics.Generic B9.DiskImages.ImageResize
instance Data.Data.Data B9.DiskImages.ImageResize
instance GHC.Read.Read B9.DiskImages.ImageResize
instance GHC.Show.Show B9.DiskImages.ImageResize
instance GHC.Classes.Eq B9.DiskImages.ImageResize
instance GHC.Generics.Generic B9.DiskImages.ImageSize
instance Data.Data.Data B9.DiskImages.ImageSize
instance GHC.Read.Read B9.DiskImages.ImageSize
instance GHC.Show.Show B9.DiskImages.ImageSize
instance GHC.Classes.Eq B9.DiskImages.ImageSize
instance GHC.Generics.Generic B9.DiskImages.SizeUnit
instance Data.Data.Data B9.DiskImages.SizeUnit
instance GHC.Enum.Bounded B9.DiskImages.SizeUnit
instance GHC.Enum.Enum B9.DiskImages.SizeUnit
instance GHC.Classes.Ord B9.DiskImages.SizeUnit
instance GHC.Read.Read B9.DiskImages.SizeUnit
instance GHC.Show.Show B9.DiskImages.SizeUnit
instance GHC.Classes.Eq B9.DiskImages.SizeUnit
instance GHC.Generics.Generic B9.DiskImages.Image
instance Data.Data.Data B9.DiskImages.Image
instance GHC.Read.Read B9.DiskImages.Image
instance GHC.Show.Show B9.DiskImages.Image
instance GHC.Classes.Eq B9.DiskImages.Image
instance GHC.Generics.Generic B9.DiskImages.FileSystem
instance Data.Data.Data B9.DiskImages.FileSystem
instance GHC.Read.Read B9.DiskImages.FileSystem
instance GHC.Show.Show B9.DiskImages.FileSystem
instance GHC.Classes.Eq B9.DiskImages.FileSystem
instance GHC.Generics.Generic B9.DiskImages.ImageType
instance GHC.Show.Show B9.DiskImages.ImageType
instance Data.Data.Data B9.DiskImages.ImageType
instance GHC.Read.Read B9.DiskImages.ImageType
instance GHC.Classes.Eq B9.DiskImages.ImageType
instance GHC.Generics.Generic B9.DiskImages.Partition
instance Data.Data.Data B9.DiskImages.Partition
instance GHC.Read.Read B9.DiskImages.Partition
instance GHC.Show.Show B9.DiskImages.Partition
instance GHC.Classes.Eq B9.DiskImages.Partition
instance GHC.Generics.Generic B9.DiskImages.MountPoint
instance GHC.Classes.Eq B9.DiskImages.MountPoint
instance Data.Data.Data B9.DiskImages.MountPoint
instance GHC.Read.Read B9.DiskImages.MountPoint
instance GHC.Show.Show B9.DiskImages.MountPoint
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.SharedImage
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.DiskImages.SharedImage
instance Test.QuickCheck.Function.Function B9.DiskImages.SharedImage
instance Data.Hashable.Class.Hashable B9.DiskImages.SharedImage
instance Data.Binary.Class.Binary B9.DiskImages.SharedImage
instance Control.DeepSeq.NFData B9.DiskImages.SharedImage
instance GHC.Classes.Ord B9.DiskImages.SharedImage
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.SharedImageBuildId
instance Test.QuickCheck.Function.Function B9.DiskImages.SharedImageBuildId
instance Test.QuickCheck.Function.Function B9.DiskImages.SharedImageDate
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.SharedImageDate
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.SharedImageName
instance Test.QuickCheck.Function.Function B9.DiskImages.SharedImageName
instance Data.Hashable.Class.Hashable B9.DiskImages.ImageTarget
instance Data.Binary.Class.Binary B9.DiskImages.ImageTarget
instance Control.DeepSeq.NFData B9.DiskImages.ImageTarget
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.ImageTarget
instance Data.Hashable.Class.Hashable B9.DiskImages.ImageDestination
instance Data.Binary.Class.Binary B9.DiskImages.ImageDestination
instance Control.DeepSeq.NFData B9.DiskImages.ImageDestination
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.ImageDestination
instance Data.Hashable.Class.Hashable B9.DiskImages.ImageSource
instance Data.Binary.Class.Binary B9.DiskImages.ImageSource
instance Control.DeepSeq.NFData B9.DiskImages.ImageSource
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.ImageSource
instance Data.Hashable.Class.Hashable B9.DiskImages.ImageResize
instance Data.Binary.Class.Binary B9.DiskImages.ImageResize
instance Control.DeepSeq.NFData B9.DiskImages.ImageResize
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.ImageResize
instance Data.Hashable.Class.Hashable B9.DiskImages.ImageSize
instance Data.Binary.Class.Binary B9.DiskImages.ImageSize
instance Control.DeepSeq.NFData B9.DiskImages.ImageSize
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.ImageSize
instance Data.Hashable.Class.Hashable B9.DiskImages.SizeUnit
instance Data.Binary.Class.Binary B9.DiskImages.SizeUnit
instance Control.DeepSeq.NFData B9.DiskImages.SizeUnit
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.SizeUnit
instance Data.Hashable.Class.Hashable B9.DiskImages.Image
instance Data.Binary.Class.Binary B9.DiskImages.Image
instance Control.DeepSeq.NFData B9.DiskImages.Image
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.Image
instance Test.QuickCheck.Function.Function B9.DiskImages.FileSystem
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.DiskImages.FileSystem
instance Data.Hashable.Class.Hashable B9.DiskImages.FileSystem
instance Data.Binary.Class.Binary B9.DiskImages.FileSystem
instance Control.DeepSeq.NFData B9.DiskImages.FileSystem
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.FileSystem
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.DiskImages.ImageType
instance Test.QuickCheck.Function.Function B9.DiskImages.ImageType
instance Data.Hashable.Class.Hashable B9.DiskImages.ImageType
instance Data.Binary.Class.Binary B9.DiskImages.ImageType
instance Control.DeepSeq.NFData B9.DiskImages.ImageType
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.ImageType
instance Data.Hashable.Class.Hashable B9.DiskImages.Partition
instance Data.Binary.Class.Binary B9.DiskImages.Partition
instance Control.DeepSeq.NFData B9.DiskImages.Partition
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.Partition
instance Data.Hashable.Class.Hashable B9.DiskImages.MountPoint
instance Data.Binary.Class.Binary B9.DiskImages.MountPoint
instance Control.DeepSeq.NFData B9.DiskImages.MountPoint
instance Test.QuickCheck.Arbitrary.Arbitrary B9.DiskImages.MountPoint


-- | Data types describing the execution environment of virtual machine
--   builds. <a>ExecEnv</a>, <a>Resources</a> and <a>SharedDirectory</a>
--   describe how <a>B9.LibVirtLXC</a> should configure and execute build
--   scripts, as defined in <a>B9.ShellScript</a> and <a>B9.Vm</a>.
module B9.ExecEnv

-- | The environment for the execution of <tt>Script</tt>s inside a
--   <tt>Container</tt>
data ExecEnv
ExecEnv :: String -> [Mounted Image] -> [SharedDirectory] -> Resources -> ExecEnv
[envName] :: ExecEnv -> String
[envImageMounts] :: ExecEnv -> [Mounted Image]
[envSharedDirectories] :: ExecEnv -> [SharedDirectory]
[envResources] :: ExecEnv -> Resources
data Resources
Resources :: RamSize -> Int -> CPUArch -> Resources
[maxMemory] :: Resources -> RamSize
[cpuCount] :: Resources -> Int
[cpuArch] :: Resources -> CPUArch
noResources :: Resources
data SharedDirectory
SharedDirectory :: FilePath -> MountPoint -> SharedDirectory
SharedDirectoryRO :: FilePath -> MountPoint -> SharedDirectory
SharedSources :: MountPoint -> SharedDirectory
data CPUArch
X86_64 :: CPUArch
I386 :: CPUArch
data RamSize
RamSize :: Int -> SizeUnit -> RamSize
AutomaticRamSize :: RamSize
instance GHC.Generics.Generic B9.ExecEnv.ExecEnv
instance GHC.Classes.Eq B9.ExecEnv.ExecEnv
instance Data.Data.Data B9.ExecEnv.ExecEnv
instance GHC.Show.Show B9.ExecEnv.ExecEnv
instance GHC.Read.Read B9.ExecEnv.ExecEnv
instance GHC.Generics.Generic B9.ExecEnv.Resources
instance Data.Data.Data B9.ExecEnv.Resources
instance GHC.Show.Show B9.ExecEnv.Resources
instance GHC.Read.Read B9.ExecEnv.Resources
instance GHC.Classes.Eq B9.ExecEnv.Resources
instance GHC.Generics.Generic B9.ExecEnv.RamSize
instance Data.Data.Data B9.ExecEnv.RamSize
instance GHC.Classes.Ord B9.ExecEnv.RamSize
instance GHC.Show.Show B9.ExecEnv.RamSize
instance GHC.Read.Read B9.ExecEnv.RamSize
instance GHC.Classes.Eq B9.ExecEnv.RamSize
instance GHC.Generics.Generic B9.ExecEnv.CPUArch
instance GHC.Classes.Eq B9.ExecEnv.CPUArch
instance Data.Data.Data B9.ExecEnv.CPUArch
instance GHC.Show.Show B9.ExecEnv.CPUArch
instance GHC.Read.Read B9.ExecEnv.CPUArch
instance GHC.Generics.Generic B9.ExecEnv.SharedDirectory
instance GHC.Classes.Eq B9.ExecEnv.SharedDirectory
instance Data.Data.Data B9.ExecEnv.SharedDirectory
instance GHC.Show.Show B9.ExecEnv.SharedDirectory
instance GHC.Read.Read B9.ExecEnv.SharedDirectory
instance Data.Hashable.Class.Hashable B9.ExecEnv.ExecEnv
instance Data.Binary.Class.Binary B9.ExecEnv.ExecEnv
instance Control.DeepSeq.NFData B9.ExecEnv.ExecEnv
instance Data.Hashable.Class.Hashable B9.ExecEnv.Resources
instance Data.Binary.Class.Binary B9.ExecEnv.Resources
instance Control.DeepSeq.NFData B9.ExecEnv.Resources
instance GHC.Base.Semigroup B9.ExecEnv.Resources
instance GHC.Base.Monoid B9.ExecEnv.Resources
instance Data.Hashable.Class.Hashable B9.ExecEnv.RamSize
instance Data.Binary.Class.Binary B9.ExecEnv.RamSize
instance Control.DeepSeq.NFData B9.ExecEnv.RamSize
instance GHC.Base.Semigroup B9.ExecEnv.RamSize
instance GHC.Base.Monoid B9.ExecEnv.RamSize
instance Data.Hashable.Class.Hashable B9.ExecEnv.CPUArch
instance Data.Binary.Class.Binary B9.ExecEnv.CPUArch
instance Control.DeepSeq.NFData B9.ExecEnv.CPUArch
instance GHC.Base.Semigroup B9.ExecEnv.CPUArch
instance GHC.Base.Monoid B9.ExecEnv.CPUArch
instance Data.Hashable.Class.Hashable B9.ExecEnv.SharedDirectory
instance Data.Binary.Class.Binary B9.ExecEnv.SharedDirectory
instance Control.DeepSeq.NFData B9.ExecEnv.SharedDirectory


-- | Definition of <a>Script</a> and functions to convert <a>Script</a>s to
--   bash scripts.
module B9.ShellScript

-- | Convert <tt>script</tt> to bash-shell-script written to <tt>file</tt>
--   and make <tt>file</tt> executable.
writeSh :: FilePath -> Script -> IO ()
renderScript :: Script -> String

-- | Check if a script has the same effect as <a>NoOP</a>
emptyScript :: Script -> Bool
data CmdVerbosity
Debug :: CmdVerbosity
Verbose :: CmdVerbosity
OnlyStdErr :: CmdVerbosity
Quiet :: CmdVerbosity
data Cwd
Cwd :: FilePath -> Cwd
NoCwd :: Cwd
data User
User :: String -> User
NoUser :: User
data Script
In :: FilePath -> [Script] -> Script
As :: String -> [Script] -> Script
IgnoreErrors :: Bool -> [Script] -> Script
Verbosity :: CmdVerbosity -> [Script] -> Script
Begin :: [Script] -> Script
Run :: FilePath -> [String] -> Script
NoOP :: Script
instance GHC.Generics.Generic B9.ShellScript.Ctx
instance GHC.Classes.Eq B9.ShellScript.Ctx
instance Data.Data.Data B9.ShellScript.Ctx
instance GHC.Read.Read B9.ShellScript.Ctx
instance GHC.Show.Show B9.ShellScript.Ctx
instance GHC.Generics.Generic B9.ShellScript.Cmd
instance GHC.Classes.Eq B9.ShellScript.Cmd
instance Data.Data.Data B9.ShellScript.Cmd
instance GHC.Read.Read B9.ShellScript.Cmd
instance GHC.Show.Show B9.ShellScript.Cmd
instance GHC.Generics.Generic B9.ShellScript.User
instance GHC.Classes.Eq B9.ShellScript.User
instance Data.Data.Data B9.ShellScript.User
instance GHC.Read.Read B9.ShellScript.User
instance GHC.Show.Show B9.ShellScript.User
instance GHC.Generics.Generic B9.ShellScript.Cwd
instance GHC.Classes.Eq B9.ShellScript.Cwd
instance Data.Data.Data B9.ShellScript.Cwd
instance GHC.Read.Read B9.ShellScript.Cwd
instance GHC.Show.Show B9.ShellScript.Cwd
instance GHC.Generics.Generic B9.ShellScript.Script
instance GHC.Classes.Eq B9.ShellScript.Script
instance Data.Data.Data B9.ShellScript.Script
instance GHC.Read.Read B9.ShellScript.Script
instance GHC.Show.Show B9.ShellScript.Script
instance GHC.Generics.Generic B9.ShellScript.CmdVerbosity
instance GHC.Classes.Eq B9.ShellScript.CmdVerbosity
instance Data.Data.Data B9.ShellScript.CmdVerbosity
instance GHC.Read.Read B9.ShellScript.CmdVerbosity
instance GHC.Show.Show B9.ShellScript.CmdVerbosity
instance Data.Hashable.Class.Hashable B9.ShellScript.Ctx
instance Data.Binary.Class.Binary B9.ShellScript.Ctx
instance Control.DeepSeq.NFData B9.ShellScript.Ctx
instance Data.Hashable.Class.Hashable B9.ShellScript.Cmd
instance Data.Binary.Class.Binary B9.ShellScript.Cmd
instance Control.DeepSeq.NFData B9.ShellScript.Cmd
instance Data.Hashable.Class.Hashable B9.ShellScript.User
instance Data.Binary.Class.Binary B9.ShellScript.User
instance Control.DeepSeq.NFData B9.ShellScript.User
instance Data.Hashable.Class.Hashable B9.ShellScript.Cwd
instance Data.Binary.Class.Binary B9.ShellScript.Cwd
instance Control.DeepSeq.NFData B9.ShellScript.Cwd
instance Data.Hashable.Class.Hashable B9.ShellScript.Script
instance Data.Binary.Class.Binary B9.ShellScript.Script
instance Control.DeepSeq.NFData B9.ShellScript.Script
instance GHC.Base.Semigroup B9.ShellScript.Script
instance GHC.Base.Monoid B9.ShellScript.Script
instance Data.Hashable.Class.Hashable B9.ShellScript.CmdVerbosity
instance Data.Binary.Class.Binary B9.ShellScript.CmdVerbosity
instance Control.DeepSeq.NFData B9.ShellScript.CmdVerbosity


-- | This module enables debugging all <a>ByteString</a> to <a>Text</a> to
--   <a>String</a> conversions. This is an internal module.
module B9.Text

-- | A space efficient, packed, unboxed Unicode text type.
data Text

-- | Lazy texts.
--   
--   A type alias to <a>Text</a> that can be used everywhere such that
--   references don't need to be qualified with the complete module name
--   everywere.
type LazyText = Text

-- | A space-efficient representation of a <a>Word8</a> vector, supporting
--   many efficient operations.
--   
--   A <a>ByteString</a> contains 8-bit bytes, or by using the operations
--   from <a>Data.ByteString.Char8</a> it can be interpreted as containing
--   8-bit characters.
data ByteString

-- | Lazy byte strings.
--   
--   A type alias to <a>ByteString</a> that can be used everywhere such
--   that references don't need to be qualified with the complete module
--   name everywere.
type LazyByteString = ByteString

-- | A class for values that can be converted to/from <a>Text</a>.
class Textual a

-- | Convert a <a>String</a> to <a>Text</a> If an error occured, return
--   <a>Left</a> with the error message.
renderToText :: (Textual a, HasCallStack) => a -> Either String Text

-- | Convert a <a>Text</a> to <a>String</a>
parseFromText :: (Textual a, HasCallStack) => Text -> Either String a

-- | Render a <a>Text</a> to a file.
writeTextFile :: (HasCallStack, MonadIO m) => FilePath -> Text -> m ()

-- | Render a <a>Text</a> via <a>renderToText</a> and throw a runtime
--   exception when rendering fails.
unsafeRenderToText :: (Textual a, HasCallStack) => a -> Text

-- | Parse a <a>Text</a> via <a>parseFromText</a> and throw a runtime
--   exception when parsing fails.
unsafeParseFromText :: (Textual a, HasCallStack) => Text -> a

-- | Parse the given <a>Text</a>. -- Return <tt>Left errorMessage</tt> or
--   <tt>Right a</tt>.
parseFromTextWithErrorMessage :: (HasCallStack, Textual a) => String -> Text -> Either String a

-- | Encode a <a>String</a> as UTF-8 encoded into a <a>LazyByteString</a>.
encodeAsUtf8LazyByteString :: HasCallStack => String -> LazyByteString
instance B9.Text.Textual Data.Text.Internal.Text
instance B9.Text.Textual GHC.Base.String
instance B9.Text.Textual Data.ByteString.Internal.ByteString
instance B9.Text.Textual B9.Text.LazyByteString


-- | An <a>Environment</a> contains textual key value pairs, relavant for
--   string template substitution.
--   
--   The variables are passed to the B9 build either via command line, OS
--   environment variables or configuration file.
module B9.Environment

-- | A map of textual keys to textual values.
data Environment

-- | Create an <a>Environment</a> from a list of pairs (<a>String</a>s).
--   Duplicated entries are ignored.
fromStringPairs :: [(String, String)] -> Environment

-- | Insert a key value binding to the <a>Environment</a>.
--   
--   Throw <a>DuplicateKey</a> if the key already exists, but the value is
--   not equal to the given value.
addBinding :: Member ExcB9 e => (Text, Text) -> Environment -> Eff e Environment

-- | Insert <a>String</a>s into the <a>Environment</a>, see
--   <a>addBinding</a>.
addStringBinding :: Member ExcB9 e => (String, String) -> Environment -> Eff e Environment

-- | Insert a value into an <a>Environment</a> like
--   <a>addStringBinding</a>, but add it to the environment of the given
--   effect, as in <a>localEnvironment</a>.
addLocalStringBinding :: (Member EnvironmentReader e, Member ExcB9 e) => (String, String) -> Eff e a -> Eff e a

-- | If environment variables <tt>arg_1 .. arg_n</tt> are bound and a list
--   of <tt>k</tt> additional values are passed to this function, store
--   them with keys <tt>arg_(n+1) .. arg_(n+k)</tt>.
--   
--   Note that the Environment contains an index of the next position.
addPositionalArguments :: [Text] -> Environment -> Environment

-- | Convenient wrapper around <a>addPositionalArguments</a> and
--   <a>localEnvironment</a>.
addLocalPositionalArguments :: Member EnvironmentReader e => [String] -> Eff e a -> Eff e a

-- | A monad transformer providing a <tt>MonadReader</tt> instance for
--   <a>Environment</a>
type EnvironmentReader = Reader Environment

-- | A predicate that is satisfied when a key exists in the environment.
hasKey :: Member EnvironmentReader e => Text -> Eff e Bool

-- | Run a <tt>ReaderT</tt> of <a>Environment</a>.
runEnvironmentReader :: Environment -> Eff (EnvironmentReader : e) a -> Eff e a

-- | Get the current <a>Environment</a>
askEnvironment :: Member EnvironmentReader e => Eff e Environment

-- | Run a computation with a modified <a>Environment</a>
localEnvironment :: Member EnvironmentReader e => (Environment -> Environment) -> Eff e a -> Eff e a

-- | Lookup a key for a value.
--   
--   <tt>throwM</tt> a <a>KeyNotFound</a> <a>Exception</a> if no value with
--   the given key exists in the <a>Environment</a>.
--   
--   @Since 0.5.62
lookupOrThrow :: '[ExcB9, EnvironmentReader] <:: e => Text -> Eff e Text

-- | Lookup a key for a value.
--   
--   Return <a>Either</a> <a>Left</a> <a>KeyNotFound</a>, if no value with
--   the given key exists in the <a>Environment</a>, or <a>Right</a> the
--   value.
--   
--   @Since 0.5.62
lookupEither :: Member EnvironmentReader e => Text -> Eff e (Either KeyNotFound Text)

-- | An <a>Exception</a> thrown by <a>lookupOrThrow</a> indicating that a
--   key does not exist.
--   
--   @Since 0.5.62
data KeyNotFound
MkKeyNotFound :: Text -> Environment -> KeyNotFound

-- | An <a>Exception</a> thrown by <a>addBinding</a> indicating that a key
--   already exists.
--   
--   @Since 0.5.62
data DuplicateKey
MkDuplicateKey :: Text -> Text -> Text -> DuplicateKey
[duplicateKey] :: DuplicateKey -> Text
[duplicateKeyOldValue] :: DuplicateKey -> Text
[duplicateKeyNewValue] :: DuplicateKey -> Text
instance GHC.Classes.Eq B9.Environment.KeyNotFound
instance GHC.Classes.Eq B9.Environment.DuplicateKey
instance GHC.Show.Show B9.Environment.DuplicateKey
instance GHC.Generics.Generic B9.Environment.Environment
instance GHC.Classes.Eq B9.Environment.Environment
instance Data.Data.Data B9.Environment.Environment
instance GHC.Show.Show B9.Environment.Environment
instance GHC.Exception.Type.Exception B9.Environment.KeyNotFound
instance GHC.Show.Show B9.Environment.KeyNotFound
instance GHC.Exception.Type.Exception B9.Environment.DuplicateKey
instance Control.DeepSeq.NFData B9.Environment.Environment
instance GHC.Base.Semigroup B9.Environment.Environment
instance GHC.Base.Monoid B9.Environment.Environment


-- | Erlang term parser and pretty printer.
module B9.Artifact.Content.ErlTerms

-- | Parse a subset of valid Erlang terms. It parses no maps and binaries
--   are restricted to either empty binaries or binaries with a string. The
--   input encoding must be restricted to ascii compatible 8-bit characters
--   (e.g. latin-1 or UTF8).
parseErlTerm :: String -> Text -> Either String SimpleErlangTerm
erlTermParser :: Parser SimpleErlangTerm

-- | Convert an abstract Erlang term to a pretty byte string preserving the
--   encoding.
renderErlTerm :: SimpleErlangTerm -> Text

-- | Simplified Erlang term representation.
data SimpleErlangTerm
ErlString :: String -> SimpleErlangTerm
ErlFloat :: Double -> SimpleErlangTerm
ErlNatural :: Integer -> SimpleErlangTerm
ErlAtom :: String -> SimpleErlangTerm
ErlChar :: Char -> SimpleErlangTerm
ErlBinary :: String -> SimpleErlangTerm
ErlList :: [SimpleErlangTerm] -> SimpleErlangTerm
ErlTuple :: [SimpleErlangTerm] -> SimpleErlangTerm
arbitraryErlSimpleAtom :: Gen SimpleErlangTerm
arbitraryErlString :: Gen SimpleErlangTerm
arbitraryErlNumber :: Gen SimpleErlangTerm
arbitraryErlNatural :: Gen SimpleErlangTerm
arbitraryErlFloat :: Gen SimpleErlangTerm
arbitraryErlNameChar :: Gen Char
instance GHC.Generics.Generic B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance Data.Data.Data B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance GHC.Show.Show B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance GHC.Read.Read B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance GHC.Classes.Ord B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance GHC.Classes.Eq B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance Data.Hashable.Class.Hashable B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance Data.Binary.Class.Binary B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance Control.DeepSeq.NFData B9.Artifact.Content.ErlTerms.SimpleErlangTerm
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Content.ErlTerms.SimpleErlangTerm


-- | Some utilities to deal with IO in B9.
module System.IO.B9Extras

-- | A data type encapsulating different kinds of relative or absolute
--   paths.
data SystemPath

-- | A path that will just be passed through
Path :: FilePath -> SystemPath

-- | A OS specific path relative to the home directory of a user.
InHomeDir :: FilePath -> SystemPath

-- | A path relative to the <tt>b9</tt> sub of the users application
--   configuration directory <a>getAppUserDataDirectory</a>
InB9UserDir :: FilePath -> SystemPath

-- | A path relative to the systems temporary directory.
InTempDir :: FilePath -> SystemPath

-- | Transform a <a>SystemPath</a>
overSystemPath :: (FilePath -> FilePath) -> SystemPath -> SystemPath

-- | Convert a <a>SystemPath</a> to a <a>FilePath</a>.
resolve :: MonadIO m => SystemPath -> m FilePath

-- | Create all missing parent directories of a file path.
ensureSystemPath :: MonadIO m => SystemPath -> m ()

-- | Create all missing parent directories of a file path. Note that the
--   file path is assumed to be of a regular file, and <a>takeDirectory</a>
--   is applied before creating the directory.
ensureDir :: MonadIO m => FilePath -> m ()

-- | Get all files from <tt>dir</tt> that is get ONLY files not directories
getDirectoryFiles :: MonadIO m => FilePath -> m [FilePath]

-- | Write a value of a type that is an instance of <a>Show</a> to file.
--   This function uses <a>ppShow</a> instead of the given <a>Show</a>
--   instance.
prettyPrintToFile :: (MonadIO m, Show a) => FilePath -> a -> m ()

-- | Read a value of a type that is an instance of <a>Read</a> from a file.
--   This function throws a <a>ConsultException</a> when the read the file
--   failed.
consult :: (MonadIO m, Read a) => FilePath -> m a

-- | An <a>Exception</a> thrown by <a>consult</a> to indicate the file does
--   not contain a <a>read</a>able String
data ConsultException
ConsultException :: FilePath -> String -> ConsultException

-- | Generate a random <a>UUID</a>.
randomUUID :: MonadIO m => m UUID

-- | A bunch of numbers, enough to make globally unique IDs. Create one of
--   these using <a>randomUUID</a>.
data UUID
removeIfExists :: FilePath -> IO ()
instance GHC.Classes.Ord System.IO.B9Extras.UUID
instance GHC.Classes.Eq System.IO.B9Extras.UUID
instance GHC.Show.Show System.IO.B9Extras.UUID
instance GHC.Read.Read System.IO.B9Extras.UUID
instance GHC.Show.Show System.IO.B9Extras.ConsultException
instance Data.Data.Data System.IO.B9Extras.SystemPath
instance GHC.Show.Show System.IO.B9Extras.SystemPath
instance GHC.Read.Read System.IO.B9Extras.SystemPath
instance GHC.Classes.Eq System.IO.B9Extras.SystemPath
instance Text.Printf.PrintfArg System.IO.B9Extras.UUID
instance GHC.Exception.Type.Exception System.IO.B9Extras.ConsultException


-- | Extensions to <a>ConfigFile</a> and utility functions for dealing with
--   configuration in general and reading/writing files.
module Data.ConfigFile.B9Extras

-- | An alias for <a>add_section</a>.
addSectionCP :: MonadError CPError m => CPDocument -> CPSectionSpec -> m CPDocument

-- | An alias for <a>setshow</a>.
setShowCP :: (Show a, MonadError CPError m) => CPDocument -> CPSectionSpec -> CPOptionSpec -> a -> m CPDocument

-- | An alias for <a>set</a>.
setCP :: MonadError CPError m => CPDocument -> CPSectionSpec -> CPOptionSpec -> String -> m CPDocument

-- | An alias for <a>get</a>.
readCP :: (CPGet a, MonadError CPError m) => CPDocument -> CPSectionSpec -> CPOptionSpec -> m a

-- | An alias for <a>merge</a>.
mergeCP :: CPDocument -> CPDocument -> CPDocument

-- | An alias for <a>to_string</a>
toStringCP :: CPDocument -> String

-- | An alias for <a>sections</a>.
sectionsCP :: CPDocument -> [SectionSpec]

-- | The default empty <a>ConfigFile</a> object.
--   
--   The content contains only an empty mandatory <tt>DEFAULT</tt> section.
--   
--   <a>optionxform</a> is set to <tt>map toLower</tt>.
--   
--   <a>usedefault</a> is set to <tt>True</tt>.
--   
--   <a>accessfunc</a> is set to <a>simpleAccess</a>.
emptyCP :: ConfigParser

-- | An alias for <a>Get_C</a>
type CPGet a = Get_C a

-- | An alias for <a>OptionSpec</a>
type CPOptionSpec = OptionSpec

-- | An alias for <a>SectionSpec</a>.
type CPSectionSpec = SectionSpec

-- | An alias for <a>ConfigParser</a>
type CPDocument = ConfigParser

-- | Indicates an error occurred. The String is an explanation of the
--   location of the error.
type CPError = (CPErrorData, String)

-- | Read a file and try to parse the contents as a <a>CPDocument</a>, if
--   something goes wrong throw a <a>CPReadException</a>
readCPDocument :: MonadIO m => SystemPath -> m CPDocument

-- | An exception thrown by <a>readCPDocument</a>.
data CPReadException
CPReadException :: FilePath -> CPError -> CPReadException
instance GHC.Show.Show Data.ConfigFile.B9Extras.CPReadException
instance GHC.Exception.Type.Exception Data.ConfigFile.B9Extras.CPReadException

module B9.B9Config.Repository
data RemoteRepo
RemoteRepo :: String -> FilePath -> SshPrivKey -> SshRemoteHost -> SshRemoteUser -> RemoteRepo
remoteRepoRepoId :: RemoteRepo -> String
newtype RepoCache
RepoCache :: FilePath -> RepoCache
newtype SshPrivKey
SshPrivKey :: FilePath -> SshPrivKey
newtype SshRemoteHost
SshRemoteHost :: (String, Int) -> SshRemoteHost
newtype SshRemoteUser
SshRemoteUser :: String -> SshRemoteUser

-- | Persist a repo to a configuration file.
remoteRepoToCPDocument :: RemoteRepo -> CPDocument -> Either CPError CPDocument

-- | Load a repository from a configuration file that has been written by
--   <tt>writeRepositoryToB9Config</tt>.
parseRemoteRepos :: CPDocument -> Either CPError [RemoteRepo]
instance GHC.Classes.Ord B9.B9Config.Repository.RemoteRepo
instance GHC.Classes.Eq B9.B9Config.Repository.RemoteRepo
instance Data.Data.Data B9.B9Config.Repository.RemoteRepo
instance GHC.Show.Show B9.B9Config.Repository.RemoteRepo
instance GHC.Read.Read B9.B9Config.Repository.RemoteRepo
instance GHC.Classes.Ord B9.B9Config.Repository.SshRemoteUser
instance GHC.Classes.Eq B9.B9Config.Repository.SshRemoteUser
instance Data.Data.Data B9.B9Config.Repository.SshRemoteUser
instance GHC.Show.Show B9.B9Config.Repository.SshRemoteUser
instance GHC.Read.Read B9.B9Config.Repository.SshRemoteUser
instance GHC.Classes.Ord B9.B9Config.Repository.SshRemoteHost
instance GHC.Classes.Eq B9.B9Config.Repository.SshRemoteHost
instance Data.Data.Data B9.B9Config.Repository.SshRemoteHost
instance GHC.Show.Show B9.B9Config.Repository.SshRemoteHost
instance GHC.Read.Read B9.B9Config.Repository.SshRemoteHost
instance GHC.Classes.Ord B9.B9Config.Repository.SshPrivKey
instance GHC.Classes.Eq B9.B9Config.Repository.SshPrivKey
instance Data.Data.Data B9.B9Config.Repository.SshPrivKey
instance GHC.Show.Show B9.B9Config.Repository.SshPrivKey
instance GHC.Read.Read B9.B9Config.Repository.SshPrivKey
instance Data.Data.Data B9.B9Config.Repository.RepoCache
instance GHC.Show.Show B9.B9Config.Repository.RepoCache
instance GHC.Read.Read B9.B9Config.Repository.RepoCache
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.Repository.RemoteRepo
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.Repository.SshRemoteUser
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.Repository.SshRemoteHost
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.Repository.SshPrivKey

module B9.B9Config.Container
parseContainerCapabilities :: CPDocument -> CPSectionSpec -> Either CPError [ContainerCapability]

-- | Available capabilities for Linux containers. This maps directly to the
--   capabilities defined in 'man 7 capabilities'.
data ContainerCapability
CAP_MKNOD :: ContainerCapability
CAP_AUDIT_CONTROL :: ContainerCapability
CAP_AUDIT_READ :: ContainerCapability
CAP_AUDIT_WRITE :: ContainerCapability
CAP_BLOCK_SUSPEND :: ContainerCapability
CAP_CHOWN :: ContainerCapability
CAP_DAC_OVERRIDE :: ContainerCapability
CAP_DAC_READ_SEARCH :: ContainerCapability
CAP_FOWNER :: ContainerCapability
CAP_FSETID :: ContainerCapability
CAP_IPC_LOCK :: ContainerCapability
CAP_IPC_OWNER :: ContainerCapability
CAP_KILL :: ContainerCapability
CAP_LEASE :: ContainerCapability
CAP_LINUX_IMMUTABLE :: ContainerCapability
CAP_MAC_ADMIN :: ContainerCapability
CAP_MAC_OVERRIDE :: ContainerCapability
CAP_NET_ADMIN :: ContainerCapability
CAP_NET_BIND_SERVICE :: ContainerCapability
CAP_NET_BROADCAST :: ContainerCapability
CAP_NET_RAW :: ContainerCapability
CAP_SETGID :: ContainerCapability
CAP_SETFCAP :: ContainerCapability
CAP_SETPCAP :: ContainerCapability
CAP_SETUID :: ContainerCapability
CAP_SYS_ADMIN :: ContainerCapability
CAP_SYS_BOOT :: ContainerCapability
CAP_SYS_CHROOT :: ContainerCapability
CAP_SYS_MODULE :: ContainerCapability
CAP_SYS_NICE :: ContainerCapability
CAP_SYS_PACCT :: ContainerCapability
CAP_SYS_PTRACE :: ContainerCapability
CAP_SYS_RAWIO :: ContainerCapability
CAP_SYS_RESOURCE :: ContainerCapability
CAP_SYS_TIME :: ContainerCapability
CAP_SYS_TTY_CONFIG :: ContainerCapability
CAP_SYSLOG :: ContainerCapability
CAP_WAKE_ALARM :: ContainerCapability
containerCapsToCPDocument :: CPDocument -> CPSectionSpec -> [ContainerCapability] -> Either CPError CPDocument
instance GHC.Enum.Bounded B9.B9Config.Container.ContainerCapability
instance GHC.Enum.Enum B9.B9Config.Container.ContainerCapability
instance GHC.Classes.Eq B9.B9Config.Container.ContainerCapability
instance GHC.Show.Show B9.B9Config.Container.ContainerCapability
instance GHC.Read.Read B9.B9Config.Container.ContainerCapability
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.Container.ContainerCapability

module B9.B9Config.SystemdNspawn
systemdNspawnConfigToCPDocument :: SystemdNspawnConfig -> CPDocument -> Either CPError CPDocument
defaultSystemdNspawnConfig :: SystemdNspawnConfig
parseSystemdNspawnConfig :: CPDocument -> Either CPError SystemdNspawnConfig
data SystemdNspawnConfig
SystemdNspawnConfig :: [ContainerCapability] -> Bool -> Maybe Int -> Maybe String -> Maybe FilePath -> SystemdNspawnConsole -> SystemdNspawnConfig
[_systemdNspawnCapabilities] :: SystemdNspawnConfig -> [ContainerCapability]
[_systemdNspawnUseSudo] :: SystemdNspawnConfig -> Bool
[_systemdNspawnMaxLifetimeSeconds] :: SystemdNspawnConfig -> Maybe Int
[_systemdNspawnExtraArgs] :: SystemdNspawnConfig -> Maybe String
[_systemdNspawnExecutable] :: SystemdNspawnConfig -> Maybe FilePath
[_systemdNspawnConsole] :: SystemdNspawnConfig -> SystemdNspawnConsole
data SystemdNspawnConsole
SystemdNspawnInteractive :: SystemdNspawnConsole
SystemdNspawnReadOnly :: SystemdNspawnConsole
SystemdNspawnPassive :: SystemdNspawnConsole
SystemdNspawnPipe :: SystemdNspawnConsole
systemdNspawnCapabilities :: Lens' SystemdNspawnConfig [ContainerCapability]
systemdNspawnUseSudo :: Lens' SystemdNspawnConfig Bool
systemdNspawnMaxLifetimeSeconds :: Lens' SystemdNspawnConfig (Maybe Int)
systemdNspawnExtraArgs :: Lens' SystemdNspawnConfig (Maybe String)
systemdNspawnExecutable :: Lens' SystemdNspawnConfig (Maybe FilePath)
systemdNspawnConsole :: Lens' SystemdNspawnConfig SystemdNspawnConsole
instance GHC.Classes.Eq B9.B9Config.SystemdNspawn.SystemdNspawnConfig
instance GHC.Show.Show B9.B9Config.SystemdNspawn.SystemdNspawnConfig
instance GHC.Read.Read B9.B9Config.SystemdNspawn.SystemdNspawnConfig
instance GHC.Classes.Eq B9.B9Config.SystemdNspawn.SystemdNspawnConsole
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.SystemdNspawn.SystemdNspawnConfig
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.SystemdNspawn.SystemdNspawnConsole
instance GHC.Show.Show B9.B9Config.SystemdNspawn.SystemdNspawnConsole
instance GHC.Read.Read B9.B9Config.SystemdNspawn.SystemdNspawnConsole

module B9.B9Config.Podman
podmanConfigToCPDocument :: PodmanConfig -> CPDocument -> Either CPError CPDocument
defaultPodmanConfig :: PodmanConfig
parsePodmanConfig :: CPDocument -> Either CPError PodmanConfig
data PodmanConfig
PodmanConfig :: Maybe String -> [ContainerCapability] -> PodmanConfig
[_podmanNetworkId] :: PodmanConfig -> Maybe String
[_podmanCapabilities] :: PodmanConfig -> [ContainerCapability]
podmanNetworkId :: Lens' PodmanConfig (Maybe String)
podmanCapabilities :: Lens' PodmanConfig [ContainerCapability]
instance GHC.Classes.Eq B9.B9Config.Podman.PodmanConfig
instance GHC.Show.Show B9.B9Config.Podman.PodmanConfig
instance GHC.Read.Read B9.B9Config.Podman.PodmanConfig

module B9.B9Config.LibVirtLXC
libVirtLXCConfigToCPDocument :: LibVirtLXCConfig -> CPDocument -> Either CPError CPDocument
defaultLibVirtLXCConfig :: LibVirtLXCConfig
parseLibVirtLXCConfig :: CPDocument -> Either CPError LibVirtLXCConfig
data LibVirtLXCConfig
LibVirtLXCConfig :: Bool -> Maybe FilePath -> FilePath -> Maybe String -> [ContainerCapability] -> RamSize -> LibVirtLXCConfig
[useSudo] :: LibVirtLXCConfig -> Bool
[emulator] :: LibVirtLXCConfig -> Maybe FilePath
[virshURI] :: LibVirtLXCConfig -> FilePath
[_networkId] :: LibVirtLXCConfig -> Maybe String
[guestCapabilities] :: LibVirtLXCConfig -> [ContainerCapability]
[guestRamSize] :: LibVirtLXCConfig -> RamSize
networkId :: Lens' LibVirtLXCConfig (Maybe String)

-- | Return the path to
--   <tt><i>usr</i>lib<i>libvirt</i>libexec/libvirt_lxc</tt> the
--   <a>emulatorK</a> field from the config file, or set the path in the
--   environment variable named like the value in <a>emulatorEnvVar</a>
--   dictates.
getEmulatorPath :: MonadIO m => LibVirtLXCConfig -> m FilePath
instance GHC.Classes.Eq B9.B9Config.LibVirtLXC.LibVirtLXCConfig
instance GHC.Show.Show B9.B9Config.LibVirtLXC.LibVirtLXCConfig
instance GHC.Read.Read B9.B9Config.LibVirtLXC.LibVirtLXCConfig
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.LibVirtLXC.LibVirtLXCConfig

module B9.B9Config.Docker
dockerConfigToCPDocument :: DockerConfig -> CPDocument -> Either CPError CPDocument
defaultDockerConfig :: DockerConfig
parseDockerConfig :: CPDocument -> Either CPError DockerConfig
data DockerConfig
DockerConfig :: Maybe String -> [ContainerCapability] -> DockerConfig
[_dockerNetworkId] :: DockerConfig -> Maybe String
[_dockerCapabilities] :: DockerConfig -> [ContainerCapability]
dockerNetworkId :: Lens' DockerConfig (Maybe String)
dockerCapabilities :: Lens' DockerConfig [ContainerCapability]
instance GHC.Classes.Eq B9.B9Config.Docker.DockerConfig
instance GHC.Show.Show B9.B9Config.Docker.DockerConfig
instance GHC.Read.Read B9.B9Config.Docker.DockerConfig


-- | Static B9 configuration. Read, write and merge configurable
--   properties. The properties are independent of specific build targets.
module B9.B9Config
data B9Config
B9Config :: Maybe LogLevel -> Maybe FilePath -> Maybe FilePath -> Bool -> Bool -> Maybe SystemPath -> Maybe String -> Maybe Int -> Maybe SystemdNspawnConfig -> Maybe PodmanConfig -> Maybe DockerConfig -> Maybe LibVirtLXCConfig -> Set RemoteRepo -> Maybe Timeout -> Maybe Int -> [String] -> B9Config
[_verbosity] :: B9Config -> Maybe LogLevel
[_logFile] :: B9Config -> Maybe FilePath
[_projectRoot] :: B9Config -> Maybe FilePath
[_keepTempDirs] :: B9Config -> Bool
[_uniqueBuildDirs] :: B9Config -> Bool
[_repositoryCache] :: B9Config -> Maybe SystemPath
[_repository] :: B9Config -> Maybe String
[_maxLocalSharedImageRevisions] :: B9Config -> Maybe Int
[_systemdNspawnConfigs] :: B9Config -> Maybe SystemdNspawnConfig
[_podmanConfigs] :: B9Config -> Maybe PodmanConfig
[_dockerConfigs] :: B9Config -> Maybe DockerConfig
[_libVirtLXCConfigs] :: B9Config -> Maybe LibVirtLXCConfig
[_remoteRepos] :: B9Config -> Set RemoteRepo
[_defaultTimeout] :: B9Config -> Maybe Timeout
[_timeoutFactor] :: B9Config -> Maybe Int
[_ext4Attributes] :: B9Config -> [String]

-- | A way to specify a time intervall for example for the timeouts of
--   system commands.
newtype Timeout
TimeoutMicros :: Int -> Timeout

-- | Run a <a>B9ConfigReader</a>.
runB9ConfigReader :: HasCallStack => B9Config -> Eff (B9ConfigReader : e) a -> Eff e a

-- | Reader for <a>B9Config</a>. See <a>getB9Config</a> and
--   <a>localB9Config</a>.
type B9ConfigReader = Reader B9Config

-- | Return the runtime configuration, that should be the configuration
--   merged from all configuration sources. This is the configuration to be
--   used during a VM image build.
getB9Config :: Member B9ConfigReader e => Eff e B9Config

-- | An alias for <a>getB9Config</a>.
--   
--   @deprecated
getConfig :: Member B9ConfigReader e => Eff e B9Config

-- | Ask for the <a>LogLevel</a>.
getLogVerbosity :: Member B9ConfigReader e => Eff e (Maybe LogLevel)

-- | Ask for the project root directory.
getProjectRoot :: Member B9ConfigReader e => Eff e FilePath

-- | Ask for the <a>RemoteRepo</a>s.
getRemoteRepos :: Member B9ConfigReader e => Eff e (Set RemoteRepo)

-- | Accumulate <a>B9Config</a> changes that go back to the config file.
--   See <a>B9ConfigAction</a> and <a>modifyPermanentConfig</a>.
type B9ConfigWriter = Writer (Endo B9Config)
verbosity :: Lens' B9Config (Maybe LogLevel)
logFile :: Lens' B9Config (Maybe FilePath)
ext4Attributes :: Lens' B9Config [String]
projectRoot :: Lens' B9Config (Maybe FilePath)
keepTempDirs :: Lens' B9Config Bool
uniqueBuildDirs :: Lens' B9Config Bool
repositoryCache :: Lens' B9Config (Maybe SystemPath)
repository :: Lens' B9Config (Maybe String)
defaultTimeout :: Lens' B9Config (Maybe Timeout)
libVirtLXCConfigs :: Lens' B9Config (Maybe LibVirtLXCConfig)
dockerConfigs :: Lens' B9Config (Maybe DockerConfig)
podmanConfigs :: Lens' B9Config (Maybe PodmanConfig)
systemdNspawnConfigs :: Lens' B9Config (Maybe SystemdNspawnConfig)
remoteRepos :: Lens' B9Config (Set RemoteRepo)
timeoutFactor :: Lens' B9Config (Maybe Int)
maxLocalSharedImageRevisionsK :: String
maxLocalSharedImageRevisions :: Lens' B9Config (Maybe Int)

-- | Override b9 configuration items and/or the path of the b9
--   configuration file. This is useful, i.e. when dealing with command
--   line parameters.
data B9ConfigOverride
B9ConfigOverride :: [SystemPath] -> Endo B9Config -> Environment -> Maybe SystemPath -> B9ConfigOverride
[_customB9ConfigPath] :: B9ConfigOverride -> [SystemPath]
[_customB9Config] :: B9ConfigOverride -> Endo B9Config
[_customEnvironment] :: B9ConfigOverride -> Environment
[_customDefaulB9ConfigPath] :: B9ConfigOverride -> Maybe SystemPath

-- | An empty default <a>B9ConfigOverride</a> value, that will neither
--   apply any additional <a>B9Config</a> nor change the path of the
--   configuration file.
noB9ConfigOverride :: B9ConfigOverride

-- | A monad that gives access to the (transient) <a>B9Config</a> to be
--   used at _runtime_ with <a>getB9Config</a> or <a>localB9Config</a>, and
--   that allows to write permanent <a>B9Config</a> changes back to the
--   configuration file using <a>modifyPermanentConfig</a>. This is the
--   amalgamation of <a>B9ConfigWriter</a> <a>B9ConfigReader</a> and
--   <a>IO</a>.
type B9ConfigAction a = Eff '[B9ConfigWriter, B9ConfigReader, EnvironmentReader, Lift IO] a

-- | Execute a <a>B9ConfigAction</a>. It will take a
--   <a>B9ConfigOverride</a> as input. The <a>B9Config</a> in that value is
--   treated as the _runtime_ configuration, and the
--   <tt>_customConfigPath</tt> is used as the alternative location of the
--   configuration file. The configuration file is read from either the
--   path in <a>_customB9ConfigPath</a> or from <a>defaultB9ConfigFile</a>.
--   Every modification done via <a>modifyPermanentConfig</a> is applied to
--   the **contents** of the configuration file and written back to that
--   file, note that these changes are ONLY reflected in the configuration
--   file and **not** in the _runtime configuration_.
--   
--   See also <a>runB9ConfigAction</a>, which does not need the
--   <a>B9ConfigOverride</a> parameter.
runB9ConfigActionWithOverrides :: HasCallStack => B9ConfigAction a -> B9ConfigOverride -> IO a

-- | Run a <a>B9ConfigAction</a> using <a>noB9ConfigOverride</a>. See
--   <a>runB9ConfigActionWithOverrides</a> for more details.
runB9ConfigAction :: HasCallStack => B9ConfigAction a -> IO a

-- | Run an action with an updated runtime configuration.
localB9Config :: Member B9ConfigReader e => (B9Config -> B9Config) -> Eff e a -> Eff e a

-- | Add a modification to the permanent configuration file.
modifyPermanentConfig :: (HasCallStack, Member B9ConfigWriter e) => Endo B9Config -> Eff e ()
customB9Config :: Lens' B9ConfigOverride (Endo B9Config)
customB9ConfigPath :: Lens' B9ConfigOverride [SystemPath]
customEnvironment :: Lens' B9ConfigOverride Environment
customDefaulB9ConfigPath :: Lens' B9ConfigOverride (Maybe SystemPath)

-- | Convenience utility to override the B9 configuration file path.
overrideB9ConfigPath :: SystemPath -> B9ConfigOverride -> B9ConfigOverride

-- | Convenience utility to override the *default* B9 configuration file
--   path.
overrideDefaultB9ConfigPath :: SystemPath -> B9ConfigOverride -> B9ConfigOverride

-- | Modify the runtime configuration.
overrideB9Config :: (B9Config -> B9Config) -> B9ConfigOverride -> B9ConfigOverride

-- | Define the current working directory to be used when building.
overrideWorkingDirectory :: FilePath -> B9ConfigOverride -> B9ConfigOverride

-- | Define the default timeout for external commands.
overrideDefaultTimeout :: Maybe Timeout -> B9ConfigOverride -> B9ConfigOverride

-- | Define the timeout factor for external commands.
overrideTimeoutFactor :: Maybe Int -> B9ConfigOverride -> B9ConfigOverride

-- | Overwrite the <a>verbosity</a> settings in the configuration with
--   those given.
overrideVerbosity :: LogLevel -> B9ConfigOverride -> B9ConfigOverride

-- | Overwrite the <a>keepTempDirs</a> flag in the configuration with those
--   given.
overrideKeepBuildDirs :: Bool -> B9ConfigOverride -> B9ConfigOverride

-- | Overwrite the <a>ext4Attributes</a>
overrideExt4Attributes :: [String] -> B9ConfigOverride -> B9ConfigOverride
defaultB9ConfigFile :: SystemPath
defaultRepositoryCache :: SystemPath
defaultB9Config :: B9Config

-- | Open the configuration file that contains the <a>B9Config</a>. If the
--   configuration does not exist, write a default configuration file, and
--   create a all missing directories.
openOrCreateB9Config :: (HasCallStack, MonadIO m) => FilePath -> m CPDocument

-- | Write the configuration in the <a>CPDocument</a> to either the user
--   supplied configuration file path or to <a>defaultB9ConfigFile</a>.
--   Create all missing (parent) directories.
writeB9CPDocument :: (HasCallStack, MonadIO m) => Maybe SystemPath -> CPDocument -> m ()
readB9Config :: (HasCallStack, MonadIO m) => Maybe SystemPath -> m CPDocument
parseB9Config :: HasCallStack => CPDocument -> Either CPError B9Config

-- | Parse a <a>B9Config</a>, modify it, and merge it back to the given
--   <a>CPDocument</a>.
modifyCPDocument :: CPDocument -> Endo B9Config -> Either CPError CPDocument

-- | Append a config file section for the <a>B9Config</a> to an empty
--   <a>CPDocument</a>.
b9ConfigToCPDocument :: HasCallStack => B9Config -> Either CPError CPDocument
data LogLevel
LogTrace :: LogLevel
LogDebug :: LogLevel
LogInfo :: LogLevel
LogError :: LogLevel
LogNothing :: LogLevel

-- | A map of textual keys to textual values.
data Environment
instance GHC.Classes.Eq B9.B9Config.B9Config
instance GHC.Show.Show B9.B9Config.B9Config
instance GHC.Read.Read B9.B9Config.LogLevel
instance GHC.Classes.Ord B9.B9Config.LogLevel
instance GHC.Show.Show B9.B9Config.LogLevel
instance GHC.Classes.Eq B9.B9Config.LogLevel
instance GHC.Read.Read B9.B9Config.Timeout
instance GHC.Classes.Ord B9.B9Config.Timeout
instance GHC.Classes.Eq B9.B9Config.Timeout
instance GHC.Show.Show B9.B9Config.Timeout
instance GHC.Show.Show B9.B9Config.B9ConfigOverride
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.B9Config
instance GHC.Base.Semigroup B9.B9Config.B9Config
instance GHC.Base.Monoid B9.B9Config.B9Config
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.LogLevel
instance Test.QuickCheck.Arbitrary.Arbitrary B9.B9Config.Timeout


-- | B9 has a concept of <a>SharedImaged</a>. Shared images can be pulled
--   and pushed to/from remote locations via rsync+ssh. B9 also maintains a
--   local cache; the whole thing is supposed to be build-server-safe, that
--   means no two builds shall interfere with each other. This is
--   accomplished by refraining from automatic cache updates from/to remote
--   repositories.
module B9.Repository

-- | Alias for a <a>Reader</a> <a>Eff</a>ect that reads a list of
--   <a>RemoteRepo</a>s.
type RepoCacheReader = Reader RepoCache

-- | Ask for the <a>RepoCache</a> initialized by <tt>withRemoteRepos</tt>.
getRepoCache :: Member RepoCacheReader e => Eff e RepoCache

-- | Run a <a>SelectedRemoteRepoReader</a> with the
--   <a>SelectedRemoteRepo</a> selected in the <a>B9Config</a>.
--   
--   If the selected repo does not exist, and exception is thrown.
withSelectedRemoteRepo :: (Member B9ConfigReader e, Member ExcB9 e) => Eff (SelectedRemoteRepoReader : e) a -> Eff e a

-- | Ask for the <a>RemoteRepo</a> selected by the <a>B9Config</a> value
--   <a>_repository</a>. See <a>withSelectedRemoteRepo</a>.
getSelectedRemoteRepo :: Member SelectedRemoteRepoReader e => Eff e SelectedRemoteRepo

-- | Alias for a <a>Reader</a> <a>Eff</a>ect that reads the
--   <a>RemoteRepo</a> selected by the <a>B9Config</a> value
--   <a>_repository</a>. See <a>withSelectedRemoteRepo</a>.
type SelectedRemoteRepoReader = Reader SelectedRemoteRepo
data Repository
Cache :: Repository
Remote :: String -> Repository

-- | A <a>Map</a> that maps <a>Repository</a>s to the <a>SharedImage</a>s
--   they hold.
type RepoImagesMap = Map Repository (Set SharedImage)

-- | Convert a <a>RemoteRepo</a> down to a mere <a>Repository</a>
toRemoteRepository :: RemoteRepo -> Repository

-- | Contains the <a>Just</a> the <a>RemoteRepo</a> selected by the
--   <a>B9Config</a> value <a>_repository</a>, or <a>Nothing</a> of no
--   <a>RemoteRepo</a> was selected in the <a>B9Config</a>.
newtype SelectedRemoteRepo
MkSelectedRemoteRepo :: Maybe RemoteRepo -> SelectedRemoteRepo
[fromSelectedRemoteRepo] :: SelectedRemoteRepo -> Maybe RemoteRepo

-- | Return the cache directory for a remote repository relative to the
--   root cache dir.
remoteRepoCacheDir :: RepoCache -> String -> FilePath

-- | Return the local repository directory.
localRepoDir :: RepoCache -> FilePath

-- | Select the first <a>RemoteRepo</a> with a given <tt>repoId</tt>.
lookupRemoteRepo :: Set RemoteRepo -> String -> Maybe RemoteRepo

-- | Filter the <a>SharedImage</a>s returned by <tt>getSharedImages</tt>
--   using a <a>Repository</a>-, and a <a>SharedImage</a> predicate.
filterRepoImagesMap :: (Repository -> Bool) -> (SharedImage -> Bool) -> RepoImagesMap -> RepoImagesMap

-- | Return the versions of a shared image named <tt>name</tt> from the
--   local cache.
lookupCachedImages :: SharedImageName -> RepoImagesMap -> Set SharedImage

-- | Keep <a>SharedImage</a>s that are in the <a>Cache</a>
--   <a>Repository</a>.
allCachedSharedImages :: RepoImagesMap -> Set SharedImage

-- | Fetch all <a>SharedImage</a>s like <a>allSharedImages</a> but attach
--   the <a>Repository</a> that the image belongs to.
--   
--   Usage example: In combination with <a>filterRepoImagesMap</a> to find
--   the latest version of a certain image in all known repositories.
allSharedImagesWithRepo :: RepoImagesMap -> Set (SharedImage, Repository)

-- | Return the maximum with regard to the <a>Ord</a> instance of
--   <a>SharedImage</a> from an <a>RepoImagesMap</a>
maxSharedImageOfAllRepos :: RepoImagesMap -> Maybe (SharedImage, Repository)

-- | Return the <a>SharedImage</a>s, that are contained in a
--   <a>Repository</a>.
allSharedImagesInRepo :: Repository -> RepoImagesMap -> Set SharedImage

-- | Get a <a>Set</a> of all <a>SharedImage</a>s in all <a>Repository</a>s.
allSharedImages :: RepoImagesMap -> Set SharedImage

-- | Return a <a>Set</a> of <a>Repository</a> names from a
--   <a>RepoImagesMap</a>
allRepositories :: RepoImagesMap -> Set Repository

-- | Group by <a>SharedImageName</a>.
groupBySharedImageName :: Set SharedImage -> Map SharedImageName (Set SharedImage)

-- | Take a subset that contains the <tt>n</tt> latest versions of
--   <a>SharedImage</a>s with the same name.
--   
--   For example, if the input contains:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:31" ,
--   SharedImage "foo" "2020-07-07 13:34:32" , SharedImage "foo"
--   "2020-07-07 13:34:33" , SharedImage "bar" "2020-07-07 13:34:34" ,
--   SharedImage "bar" "2020-07-07 13:34:35" , SharedImage "bar"
--   "2020-07-07 13:34:36" ] </tt>@@
--   
--   The output of <tt>keepNLatestSharedImages 2</tt> will be:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:32" ,
--   SharedImage "foo" "2020-07-07 13:34:33" , SharedImage "bar"
--   "2020-07-07 13:34:35" , SharedImage "bar" "2020-07-07 13:34:36" ]
--   </tt>@@
keepNLatestSharedImages :: Int -> Set SharedImage -> Set SharedImage

-- | Take a subset that contains obsolete images.
--   
--   Do the opposite of <a>keepNLatestSharedImages</a>, and return all
--   **but** the <tt>n</tt> latest versions of <a>SharedImage</a>s with the
--   same name.
--   
--   For example, if the input contains:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:31" ,
--   SharedImage "foo" "2020-07-07 13:34:32" , SharedImage "foo"
--   "2020-07-07 13:34:33" , SharedImage "bar" "2020-07-07 13:34:34" ,
--   SharedImage "bar" "2020-07-07 13:34:35" , SharedImage "bar"
--   "2020-07-07 13:34:36" ] </tt>@@
--   
--   The output of <tt>keepNLatestSharedImages 2</tt> will be:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:31" ,
--   SharedImage "bar" "2020-07-07 13:34:34" ] </tt>@@
dropAllButNLatestSharedImages :: Int -> Set SharedImage -> Set SharedImage
instance GHC.Generics.Generic B9.Repository.Repository
instance GHC.Show.Show B9.Repository.Repository
instance GHC.Read.Read B9.Repository.Repository
instance GHC.Classes.Ord B9.Repository.Repository
instance GHC.Classes.Eq B9.Repository.Repository
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Repository.Repository
instance Test.QuickCheck.Function.Function B9.Repository.Repository
instance Test.QuickCheck.Arbitrary.CoArbitrary B9.Repository.Repository


-- | This modules contains support for logging.
module B9.B9Logging

-- | The logger to write log messages to.
newtype Logger
MkLogger :: Maybe Handle -> Logger
[logFileHandle] :: Logger -> Maybe Handle

-- | Convenience type alias for <a>Eff</a>ects that have a <a>B9Config</a>,
--   a <a>Logger</a>, <a>MonadIO</a> and <a>MonadBaseControl</a>.
type CommandIO e = (MonadBaseControl IO (Eff e), MonadIO (Eff e), Member LoggerReader e, Member B9ConfigReader e)

-- | Effect that reads a <a>Logger</a>.
type LoggerReader = Reader Logger

-- | Lookup the selected <a>getLogVerbosity</a> and <a>_logFile</a> from
--   the <a>B9Config</a> and open it.
--   
--   Then run the given action; if the action crashes, the log file will be
--   closed.
withLogger :: (MonadBaseControl IO (Eff e), MonadIO (Eff e), Member B9ConfigReader e) => Eff (LoggerReader : e) a -> Eff e a
b9Log :: CommandIO e => LogLevel -> String -> Eff e ()
traceL :: CommandIO e => String -> Eff e ()
dbgL :: CommandIO e => String -> Eff e ()
infoL :: CommandIO e => String -> Eff e ()
errorL :: CommandIO e => String -> Eff e ()
errorExitL :: (CommandIO e, Member ExcB9 e) => String -> Eff e a
printHash :: Hashable a => a -> String


-- | Provide information about the current build.
--   
--   This module provides build meta information like build directory,
--   build-id and build-time.
module B9.BuildInfo
getBuildId :: Member BuildInfoReader e => Eff e String
getBuildDate :: Member BuildInfoReader e => Eff e String
getBuildDir :: Member BuildInfoReader e => Eff e FilePath

-- | Create the build directories, generate (hash) the build-id and execute
--   the given action.
--   
--   Bindings added to the text template parameter environment:
--   
--   <ul>
--   <li><tt>projectRoot</tt> the directory that contains the sources of
--   the project to build</li>
--   <li><tt>buildDir</tt> the temporary directory used store the build
--   artifacts passed into- or outof the build</li>
--   </ul>
--   
--   Unless <a>_keepTempDirs</a> is <tt>True</tt> clean up the build
--   directories after the actions returns - even if the action throws a
--   runtime exception.
withBuildInfo :: (Lifted IO e, MonadBaseControl IO (Eff e), Member B9ConfigReader e, Member ExcB9 e, Member EnvironmentReader e, Member LoggerReader e, HasCallStack) => Bool -> Eff (BuildInfoReader : e) a -> Eff e a

-- | Type alias for a <a>BuildInfo</a> <a>Reader</a>
type BuildInfoReader = Reader BuildInfo

-- | Ask whether <tt>stdin</tt> of the <tt>B9</tt> process should be
--   redirected to the external commands executed during the build.
isInteractive :: Member BuildInfoReader e => Eff e Bool
instance GHC.Show.Show B9.BuildInfo.BuildInfo
instance GHC.Classes.Eq B9.BuildInfo.BuildInfo


-- | An interface for container backends such as libvirt-lxc or docker
module B9.Container

-- | Class of backends that run a <a>Script</a> in an <a>ExecEnv</a> in an
--   OS-level container like docker or lxc.
class Backend config

-- | Return <a>Nothing</a> if the configuration **disables** this container
--   backend, and return 'Just ...' if the configuration **enables** this
--   container backend.
getBackendConfig :: forall proxy e. (Backend config, Member BuildInfoReader e, CommandIO e) => proxy config -> Eff e (Maybe config)

-- | The input images, that a given container accepts
supportedImageTypes :: Backend config => proxy config -> [ImageType]

-- | Run a <a>Script</a> in an <a>ExecEnv</a>, and return <a>True</a> if
--   the script completed successfully.
runInEnvironment :: forall e. (Backend config, Member BuildInfoReader e, CommandIO e, Member ExcB9 e) => config -> ExecEnv -> Script -> Eff e Bool


-- | Implementation of an execution environment that uses <i>podman</i>.
module B9.Podman
newtype Podman
Podman :: PodmanConfig -> Podman
instance B9.Container.Backend B9.Podman.Podman


-- | Implementation of an execution environment that uses <i>docker</i>.
module B9.Docker
newtype Docker
Docker :: DockerConfig -> Docker
instance B9.Container.Backend B9.Docker.Docker


-- | This modules contains support for external command execution.
module B9.B9Exec

-- | Execute the given shell command.
--   
--   The command and the output is either logged to the logfile with
--   <a>traceL</a> or <a>errorL</a> or written to stdout.
--   
--   If the command exists with non-zero exit code, the current process
--   exists with the same exit code.
cmd :: (HasCallStack, Member ExcB9 e, CommandIO e) => String -> Eff e ()

-- | Execute the given shell command and collect its standard output.
--   
--   The command and the output is additionally either logged to the
--   logfile with <a>traceL</a> or <a>errorL</a> or written to stdout.
--   
--   If the command exists with non-zero exit code, the current process
--   exists with the same exit code.
cmdStdout :: (HasCallStack, Member ExcB9 e, CommandIO e) => String -> Eff e ByteString

-- | Execute the given shell command.
--   
--   If <a>isInteractive</a> is true, the standard-in will be passed to the
--   external command, and all output of the program will be directed to
--   standard-out.
--   
--   The command and the output is either logged to the logfile with
--   <a>traceL</a> or <a>errorL</a> or written to stdout.
--   
--   If the command exists with non-zero exit code, the current process
--   exists with the same exit code.
cmdInteractive :: (HasCallStack, Member ExcB9 e, Member BuildInfoReader e, CommandIO e) => String -> Eff e ()

-- | Run a shell command defined by a string and optionally interrupt the
--   command after a given time has elapsed. This is only useful for
--   non-interactive commands.
hostCmdEither :: forall e. CommandIO e => HostCommandStdin -> String -> Maybe Timeout -> Eff e (Either Timeout ExitCode)

-- | Run a shell command defined by a string and optionally interrupt the
--   command after a given time has elapsed. This is only useful for
--   non-interactive commands.
--   
--   Also provide the possibility to receive the stdout of the command. It
--   of course be collected in ram, so be sure the command doesn't have to
--   much output.
hostCmdStdoutEither :: forall e a. CommandIO e => HostCommandStdin -> HostCommandStdout a -> String -> Maybe Timeout -> Eff e (Either Timeout a)

-- | Run a shell command defined by a string and optionally interrupt the
--   command after a given time has elapsed. If the shell command did not
--   exit with <a>ExitSuccess</a>, or the timer elapsed, a <a>B9Error</a>
--   is thrown.
--   
--   This is only useful for non-interactive commands.
hostCmd :: (CommandIO e, Member ExcB9 e) => String -> Maybe Timeout -> Eff e Bool

-- | Like <a>hostCmd</a> but with std-input attached.
hostCmdStdIn :: (CommandIO e, Member ExcB9 e) => HostCommandStdin -> String -> Maybe Timeout -> Eff e Bool

-- | A way to specify a time intervall for example for the timeouts of
--   system commands.
newtype Timeout
TimeoutMicros :: Int -> Timeout

-- | Execute the given shell command in a newly created pseudo terminal, if
--   necessary.
ptyCmdInteractive :: (HasCallStack, Member ExcB9 e, Member BuildInfoReader e, CommandIO e) => Maybe Timeout -> String -> [String] -> Eff e ()

-- | Ways to process std-input.
data HostCommandStdin

-- | Disbale std-in
HostCommandNoStdin :: HostCommandStdin

-- | Inherit std-in
HostCommandInheritStdin :: HostCommandStdin

-- | Produce std-in
HostCommandStdInConduit :: ConduitT () ByteString IO () -> HostCommandStdin

-- | Ways to process std-output.
data HostCommandStdout a

-- | Write std-out to the log sink.
[HostCommandStdoutLog] :: HostCommandStdout ExitCode

-- | Write std-out to the log sink, additionally collect and return it.
[HostCommandStdoutLogAndCapture] :: HostCommandStdout (ByteString, ExitCode)


-- | Implementation of an execution environment that uses
--   <i>systemdNspawn</i>.
module B9.SystemdNspawn
newtype SystemdNspawn
SystemdNspawn :: SystemdNspawnConfig -> SystemdNspawn
instance GHC.Show.Show B9.SystemdNspawn.BootScript
instance GHC.Show.Show B9.SystemdNspawn.ContainerMounts
instance GHC.Show.Show B9.SystemdNspawn.LoopbackMount
instance GHC.Show.Show B9.SystemdNspawn.ContainerRootImage
instance GHC.Show.Show B9.SystemdNspawn.ContainerBuildDirectories
instance B9.Container.Backend B9.SystemdNspawn.SystemdNspawn


-- | Effectful functions executing shared image respository operations. See
--   <a>B9.Repository</a>
module B9.RepositoryIO

-- | Find files which are in <tt>subDir</tt> and match <tt>glob</tt> in the
--   repository cache. NOTE: This operates on the repository cache, but
--   does not enforce a repository cache update.
repoSearch :: forall e. (CommandIO e, Member RepoCacheReader e) => FilePath -> FilePathGlob -> Eff e [(Repository, [FilePath])]

-- | Push a file from the cache to a remote repository
pushToRepo :: (Member ExcB9 e, CommandIO e) => RemoteRepo -> FilePath -> FilePath -> Eff e ()

-- | Pull a file from a remote repository to cache
pullFromRepo :: (Member ExcB9 e, CommandIO e) => RemoteRepo -> FilePath -> FilePath -> Eff e ()

-- | Initialize the local repository cache directory and the
--   <a>RemoteRepo</a>s. Run the given action with a <a>B9Config</a> that
--   contains the initialized repositories in <a>_remoteRepos</a>.
withRemoteRepos :: (Member B9ConfigReader e, Lifted IO e) => Eff (RepoCacheReader : e) a -> Eff e a

-- | Push a file from the cache to a remote repository
pullGlob :: (Member ExcB9 e, CommandIO e, Member RepoCacheReader e) => FilePath -> FilePathGlob -> RemoteRepo -> Eff e ()

-- | Express a pattern for file paths, used when searching repositories.
newtype FilePathGlob
FileExtension :: String -> FilePathGlob

-- | Return a list of all existing sharedImages from cached repositories.
getSharedImages :: (HasCallStack, CommandIO e, Lifted IO e, Member RepoCacheReader e) => Eff e (Map Repository (Set SharedImage))

-- | Return the path to the sub directory in the cache that contains files
--   of shared images.
getSharedImagesCacheDir :: '[RepoCacheReader] <:: e => Eff e FilePath

-- | Return either all remote repos or just the single selected repo.
getSelectedRepos :: '[B9ConfigReader, SelectedRemoteRepoReader] <:: e => Eff e (Set RemoteRepo)

-- | Pull metadata files from all remote repositories.
pullRemoteRepos :: (HasCallStack, Member ExcB9 e, Lifted IO e, CommandIO e, '[SelectedRemoteRepoReader, RepoCacheReader] <:: e) => Eff e ()

-- | Pull the latest version of an image, either from the selected remote
--   repo or from the repo that has the latest version.
pullLatestImage :: (HasCallStack, Lifted IO e, CommandIO e, '[ExcB9, RepoCacheReader, SelectedRemoteRepoReader] <:: e) => SharedImageName -> Eff e (Maybe SharedImageBuildId)

-- | Depending on the <a>maxLocalSharedImageRevisions</a> <a>B9Config</a>
--   settings either do nothing or delete all but the configured number of
--   most recent shared images with the given name from the local cache.
cleanOldSharedImageRevisionsFromCache :: ('[RepoCacheReader, ExcB9] <:: e, Lifted IO e, CommandIO e) => SharedImageName -> Eff e ()

-- | Clean all obsolete images in the local image cache.
cleanLocalRepoCache :: ('[RepoCacheReader, ExcB9] <:: e, Lifted IO e, CommandIO e) => Eff e ()

-- | Upload a shared image from the cache to a selected remote repository
pushToSelectedRepo :: (Member ExcB9 e, Lifted IO e, CommandIO e, '[RepoCacheReader, SelectedRemoteRepoReader] <:: e) => SharedImage -> Eff e ()

-- | Publish the latest version of a shared image identified by name to the
--   selected repository from the cache.
pushSharedImageLatestVersion :: (Lifted IO e, CommandIO e, '[SelectedRemoteRepoReader, RepoCacheReader, ExcB9] <:: e) => SharedImageName -> Eff e ()

-- | Return the <a>Image</a> of the latest version of a shared image named
--   <tt>name</tt> from the local cache.
getLatestImageByName :: (HasCallStack, Lifted IO e, CommandIO e, Member RepoCacheReader e) => SharedImageName -> Eff e (Maybe Image)

-- | Empty the repository; load the corresponding settings from the config
--   file, check that the priv key exists and create the correspondig cache
--   directory.
cleanRemoteRepo :: MonadIO m => RepoCache -> RemoteRepo -> m ()

-- | Check for existance of priv-key and make it an absolute path.
remoteRepoCheckSshPrivKey :: MonadIO m => RemoteRepo -> m RemoteRepo

module B9.B9Monad

-- | Execute a <a>B9</a> effect and return an action that needs the
--   <a>B9Config</a>.
runB9 :: HasCallStack => B9 a -> B9ConfigAction a

-- | Execute a <a>B9</a> effect like <a>runB9</a> but run external
--   commands, such as `systemd-nspawn`, <i>interactively</i>.
--   
--   When run <i>interactively</i>, the stdin/stdout of certain commands is
--   inherited from the main process.
runB9Interactive :: HasCallStack => B9 a -> B9ConfigAction a

-- | Definition of the B9 monad. See <a>B9Eff</a>.
--   
--   This module is used by the _effectful_ functions in this library.
type B9 a = Eff B9Eff a

-- | Definition of the B9 effect list. It encapsulates logging, a reader
--   for the <a>B9.B9Config</a> and access to the current build id, the
--   current build directory and the artifact to build.
--   
--   This monad is used by the _effectful_ functions in this library.
type B9Eff = '[SelectedRemoteRepoReader, RepoCacheReader, BuildInfoReader, LoggerReader, B9ConfigReader, EnvironmentReader, ExcB9, Lift IO]

-- | A constraint that contains all effects of <a>B9Eff</a>
type IsB9 e = (HasCallStack, Lifted IO e, CommandIO e, B9Eff <:: e)


-- | Content is what is written to files in the generated VM images and
--   cloud configuration.
--   
--   Contains the monadic actions that generate the content that is written
--   to the generated artifacts.
module B9.Artifact.Content

-- | A <a>B9</a> action that procuces a <a>Text</a>.
type ContentGenerator = B9 Text

-- | Types whose values can be turned into an <a>Eff</a>ect that produces
--   <a>Text</a>, e.g. <a>ContentGenerator</a>
class ToContentGenerator c
toContentGenerator :: (ToContentGenerator c, HasCallStack, IsB9 e) => c -> Eff e Text

-- | A space efficient, packed, unboxed Unicode text type.
data Text


-- | Implementation of an execution environment that uses "libvirt-lxc".
module B9.LibVirtLXC
newtype LibVirtLXC
LibVirtLXC :: LibVirtLXCConfig -> LibVirtLXC
instance B9.Container.Backend B9.LibVirtLXC.LibVirtLXC


-- | Utility functions based on <a>Template</a> to offer <tt> $var </tt>
--   variable expansion in string throughout a B9 artifact.
--   
--   @deprecated
--   
--   TODO remove this in the move to Dhall
module B9.Artifact.Content.StringTemplate

-- | <a>Text</a> template substitution.
subst :: (Member ExcB9 e, Member EnvironmentReader e) => Text -> Eff e Text

-- | <a>String</a> template substitution
substStr :: (Member ExcB9 e, Member EnvironmentReader e) => String -> Eff e String
substFile :: (Member EnvironmentReader e, Member ExcB9 e, MonadIO (Eff e)) => FilePath -> FilePath -> Eff e ()
substPath :: (Member EnvironmentReader e, Member ExcB9 e) => SystemPath -> Eff e SystemPath
readTemplateFile :: (MonadIO (Eff e), '[ExcB9, EnvironmentReader] <:: e) => SourceFile -> Eff e Text

-- | Extend an <a>Environment</a> with new bindings, where each value may
--   contain string templates with like <tt>"Hello $name, how is life on
--   $planet these days?"</tt>.
withSubstitutedStringBindings :: (Member EnvironmentReader e, Member ExcB9 e) => [(String, String)] -> Eff e s -> Eff e s

-- | A wrapper around a file path and a flag indicating if template
--   variable expansion should be performed when reading the file contents.
data SourceFile
Source :: SourceFileConversion -> FilePath -> SourceFile
data SourceFileConversion
NoConversion :: SourceFileConversion
ExpandVariables :: SourceFileConversion
instance GHC.Generics.Generic B9.Artifact.Content.StringTemplate.SourceFile
instance GHC.Classes.Eq B9.Artifact.Content.StringTemplate.SourceFile
instance Data.Data.Data B9.Artifact.Content.StringTemplate.SourceFile
instance GHC.Show.Show B9.Artifact.Content.StringTemplate.SourceFile
instance GHC.Read.Read B9.Artifact.Content.StringTemplate.SourceFile
instance GHC.Generics.Generic B9.Artifact.Content.StringTemplate.SourceFileConversion
instance GHC.Classes.Eq B9.Artifact.Content.StringTemplate.SourceFileConversion
instance Data.Data.Data B9.Artifact.Content.StringTemplate.SourceFileConversion
instance GHC.Show.Show B9.Artifact.Content.StringTemplate.SourceFileConversion
instance GHC.Read.Read B9.Artifact.Content.StringTemplate.SourceFileConversion
instance Data.Hashable.Class.Hashable B9.Artifact.Content.StringTemplate.SourceFile
instance Data.Binary.Class.Binary B9.Artifact.Content.StringTemplate.SourceFile
instance Control.DeepSeq.NFData B9.Artifact.Content.StringTemplate.SourceFile
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Content.StringTemplate.SourceFile
instance Data.Hashable.Class.Hashable B9.Artifact.Content.StringTemplate.SourceFileConversion
instance Data.Binary.Class.Binary B9.Artifact.Content.StringTemplate.SourceFileConversion
instance Control.DeepSeq.NFData B9.Artifact.Content.StringTemplate.SourceFileConversion


-- | Definition of <a>VmScript</a> an artifact encapsulating several
--   virtual machines disk images that can be mounted in an execution
--   environment like <a>B9.LibVirtLXC</a>. A <a>VmScript</a> is embedded
--   by in an <a>ArtifactGenerator</a>.
module B9.Vm

-- | Describe a virtual machine, i.e. a set up disk images to create and a
--   shell script to put things together.
data VmScript
VmScript :: CPUArch -> [SharedDirectory] -> Script -> VmScript
NoVmScript :: VmScript
substVmScript :: forall e. (Member EnvironmentReader e, Member ExcB9 e) => VmScript -> Eff e VmScript
instance GHC.Generics.Generic B9.Vm.VmScript
instance GHC.Classes.Eq B9.Vm.VmScript
instance Data.Data.Data B9.Vm.VmScript
instance GHC.Show.Show B9.Vm.VmScript
instance GHC.Read.Read B9.Vm.VmScript
instance Data.Hashable.Class.Hashable B9.Vm.VmScript
instance Data.Binary.Class.Binary B9.Vm.VmScript
instance Control.DeepSeq.NFData B9.Vm.VmScript


-- | Effectful functions that create and convert disk image files.
module B9.DiskImageBuilder

-- | Create an image from an image source. The destination image must have
--   a compatible image type and filesystem. The directory of the image
--   MUST be present and the image file itself MUST NOT alredy exist.
materializeImageSource :: IsB9 e => ImageSource -> Image -> Eff e ()

-- | Replace $... variables inside an <a>ImageTarget</a>
substImageTarget :: forall e. (HasCallStack, Member EnvironmentReader e, Member ExcB9 e) => ImageTarget -> Eff e ImageTarget

-- | Return all valid image types sorted by preference.
preferredDestImageTypes :: IsB9 e => ImageSource -> Eff e [ImageType]

-- | Return all supported source <a>ImageType</a>s compatible to a
--   <tt>ImageDestinaion</tt> in the preferred order.
preferredSourceImageTypes :: HasCallStack => ImageDestination -> [ImageType]

-- | Resolve an ImageSource to an <a>Image</a>. The ImageSource might not
--   exist, as is the case for <a>EmptyImage</a>.
resolveImageSource :: IsB9 e => ImageSource -> Eff e Image

-- | Convert some <a>Image</a>, e.g. a temporary image used during the
--   build phase to the final destination.
createDestinationImage :: IsB9 e => Image -> ImageDestination -> Eff e ()

-- | Resize an image, including the file system inside the image.
resizeImage :: IsB9 e => ImageResize -> Image -> Eff e ()

-- | Import a disk image from some external source into the build directory
--   if necessary convert the image.
importImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Export a disk image from the build directory; if necessary convert the
--   image.
exportImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Export a disk image from the build directory; if necessary convert the
--   image.
exportAndRemoveImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Convert an image in the build directory to another format and return
--   the new image.
convertImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Publish an sharedImage made from an image and image meta data to the
--   configured repository
shareImage :: IsB9 e => Image -> SharedImageName -> Eff e SharedImage

-- | Create the parent directories for the file that contains the
--   <a>Image</a>. If the path to the image file is relative, prepend
--   <a>_projectRoot</a> from the <a>B9Config</a>.
ensureAbsoluteImageDirExists :: IsB9 e => Image -> Eff e Image

-- | Determine the virtual size of a raw image
getVirtualSizeForRawImage :: IsB9 e => FilePath -> Eff e (Either String Integer)


-- | B9 produces not only VM-Images but also text documents such as
--   configuration files required by virtual machines. This module is about
--   creating and merging files containing parsable syntactic structures,
--   such as most configuration files do.
--   
--   B9 can be used to create configuration files by assembling structured
--   documents, for example Yaml, JSON, Erlang Terms.
--   
--   One example is creating a single cloud-init 'user-data' file from a
--   set of 'user-data' snippets - all of which using yaml syntax to
--   declare the same object (e.g <tt>"user-data"</tt>).
--   
--   The goal is, that b9 is able to merge these snippets into one,
--   intelligently merging fields as one would expect, e.g. when merging
--   multiple snippets with <tt>writefiles</tt> fields, the output object's
--   <tt>writefiles</tt> field contains all the <tt>write_file</tt>
--   objects.
--   
--   Another example is the OTP<i>Erlang sys.config for configuring
--   OTP</i>Erlang releases.
module B9.Artifact.Content.AST

-- | Types of values that describe content, that can be created from an
--   <a>AST</a>.
class FromAST a
fromAST :: (FromAST a, IsB9 e, ToContentGenerator c) => AST c a -> Eff e a

-- | Describe how to create structured content that has a tree-like
--   syntactic structure, e.g. yaml, JSON and erlang-proplists. The first
--   parameter defines a <i>context</i> into which the <a>AST</a> is
--   embedded, e.g. B9.Artifact.Content'. The second parameter defines a
--   specifix syntax, e.g <a>ErlangPropList</a> that the <a>AST</a> value
--   generates.
data AST c a

-- | Create an object similar to a Json object.
ASTObj :: [(String, AST c a)] -> AST c a

-- | An array.
ASTArr :: [AST c a] -> AST c a

-- | Merge the nested elements, this is a very powerful tool that allows to
--   combine
ASTMerge :: [AST c a] -> AST c a
ASTEmbed :: c -> AST c a
ASTString :: String -> AST c a
ASTInt :: Int -> AST c a
ASTParse :: SourceFile -> AST c a
AST :: a -> AST c a

-- | Parse the given <a>Text</a>. -- Return <tt>Left errorMessage</tt> or
--   <tt>Right a</tt>.
parseFromTextWithErrorMessage :: (HasCallStack, Textual a) => String -> Text -> Either String a
instance GHC.Generics.Generic (B9.Artifact.Content.AST.AST c a)
instance (GHC.Classes.Eq c, GHC.Classes.Eq a) => GHC.Classes.Eq (B9.Artifact.Content.AST.AST c a)
instance (Data.Data.Data c, Data.Data.Data a) => Data.Data.Data (B9.Artifact.Content.AST.AST c a)
instance (GHC.Show.Show c, GHC.Show.Show a) => GHC.Show.Show (B9.Artifact.Content.AST.AST c a)
instance (GHC.Read.Read c, GHC.Read.Read a) => GHC.Read.Read (B9.Artifact.Content.AST.AST c a)
instance GHC.Base.Functor (B9.Artifact.Content.AST.AST c)
instance (Data.Hashable.Class.Hashable c, Data.Hashable.Class.Hashable a) => Data.Hashable.Class.Hashable (B9.Artifact.Content.AST.AST c a)
instance (Data.Binary.Class.Binary c, Data.Binary.Class.Binary a) => Data.Binary.Class.Binary (B9.Artifact.Content.AST.AST c a)
instance (Control.DeepSeq.NFData c, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (B9.Artifact.Content.AST.AST c a)
instance (Test.QuickCheck.Arbitrary.Arbitrary c, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (B9.Artifact.Content.AST.AST c a)


-- | A wrapper around Yaml with <a>Semigroup</a> and <a>Monoid</a>
--   instances for merging, reading and writing yaml files within B9.
module B9.Artifact.Content.YamlObject

-- | A wrapper type around yaml values with a Semigroup instance useful for
--   combining yaml documents describing system configuration like e.g.
--   user-data.
newtype YamlObject
YamlObject :: Value -> YamlObject
[_fromYamlObject] :: YamlObject -> Value
instance GHC.Generics.Generic B9.Artifact.Content.YamlObject.YamlObject
instance Data.Data.Data B9.Artifact.Content.YamlObject.YamlObject
instance GHC.Classes.Eq B9.Artifact.Content.YamlObject.YamlObject
instance Control.DeepSeq.NFData B9.Artifact.Content.YamlObject.YamlObject
instance Data.Hashable.Class.Hashable B9.Artifact.Content.YamlObject.YamlObject
instance B9.Text.Textual B9.Artifact.Content.YamlObject.YamlObject
instance GHC.Read.Read B9.Artifact.Content.YamlObject.YamlObject
instance GHC.Show.Show B9.Artifact.Content.YamlObject.YamlObject
instance GHC.Base.Semigroup B9.Artifact.Content.YamlObject.YamlObject
instance B9.Artifact.Content.AST.FromAST B9.Artifact.Content.YamlObject.YamlObject
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Content.YamlObject.YamlObject


-- | Allow reading, merging and writing Erlang terms.
module B9.Artifact.Content.ErlangPropList

-- | A wrapper type around erlang terms with a Semigroup instance useful
--   for combining sys.config files with OTP-application configurations in
--   a list of the form of a proplist.
newtype ErlangPropList
ErlangPropList :: SimpleErlangTerm -> ErlangPropList

-- | Parse a text containing an <tt>Erlang</tt> expression ending with a
--   <tt>.</tt> and Return an <a>AST</a>.
textToErlangAst :: Text -> AST c ErlangPropList

-- | Parse a string containing an <tt>Erlang</tt> expression ending with a
--   <tt>.</tt> and Return an <a>AST</a>.
stringToErlangAst :: String -> AST c ErlangPropList
instance GHC.Generics.Generic B9.Artifact.Content.ErlangPropList.ErlangPropList
instance Data.Data.Data B9.Artifact.Content.ErlangPropList.ErlangPropList
instance GHC.Show.Show B9.Artifact.Content.ErlangPropList.ErlangPropList
instance GHC.Classes.Eq B9.Artifact.Content.ErlangPropList.ErlangPropList
instance GHC.Read.Read B9.Artifact.Content.ErlangPropList.ErlangPropList
instance Data.Hashable.Class.Hashable B9.Artifact.Content.ErlangPropList.ErlangPropList
instance Control.DeepSeq.NFData B9.Artifact.Content.ErlangPropList.ErlangPropList
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Content.ErlangPropList.ErlangPropList
instance GHC.Base.Semigroup B9.Artifact.Content.ErlangPropList.ErlangPropList
instance B9.Text.Textual B9.Artifact.Content.ErlangPropList.ErlangPropList
instance B9.Artifact.Content.AST.FromAST B9.Artifact.Content.ErlangPropList.ErlangPropList


-- | This contains a <a>YamlObject</a> for Canonicals <tt>cloud-init</tt>.
--   
--   For some reason, cloud-config yaml documents <b>MUST</b> contain
--   <tt>#cloud-config</tt> in the first line.
--   
--   This is documented in the <a>cloud config documentation</a>.
--   
--   Otherwise, this is just a wrapper around <a>YamlObject</a>.
--   
--   @Since 0.5.62
module B9.Artifact.Content.CloudConfigYaml

-- | Cloud-init <tt>meta-data</tt> configuration Yaml.
--   
--   <tt>cloud-config</tt> yaml documents contain: <tt>#cloud-config</tt>
--   as first line.
--   
--   @Since 0.5.62
newtype CloudConfigYaml
MkCloudConfigYaml :: YamlObject -> CloudConfigYaml
[fromCloudConfigYaml] :: CloudConfigYaml -> YamlObject

-- | The header line, which must be the first line in the text file
--   containing the cloud-config Yaml document.
--   
--   @Since 0.5.62
cloudConfigFileHeader :: Text
instance GHC.Base.Semigroup B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance GHC.Show.Show B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance GHC.Read.Read B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance GHC.Generics.Generic B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance Data.Data.Data B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance GHC.Classes.Eq B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance Control.DeepSeq.NFData B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance Data.Hashable.Class.Hashable B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance B9.Artifact.Content.AST.FromAST B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml
instance B9.Text.Textual B9.Artifact.Content.CloudConfigYaml.CloudConfigYaml


-- | Content defined in text files (.b9 files), read with the <a>Read</a>
--   instances.
module B9.Artifact.Content.Readable

-- | This is content that can be <a>read</a> via the generated <a>Read</a>
--   instance.
data Content
RenderErlang :: AST Content ErlangPropList -> Content
RenderYamlObject :: AST Content YamlObject -> Content
RenderCloudConfig :: AST Content CloudConfigYaml -> Content

-- | This data will be passed through unaltered. This is used during the
--   transition phase from having B9 stuff read from files via <a>Read</a>
--   instances towards programatic use or the use of HOCON.
FromByteString :: ByteString -> Content

-- | Embed a literal string
FromString :: String -> Content

-- | Embed the contents of the <a>SourceFile</a> with template parameter
--   substitution.
FromTextFile :: SourceFile -> Content

-- | The data in the given file will be base64 encoded.
RenderBase64BinaryFile :: FilePath -> Content

-- | This data will be base64 encoded.
RenderBase64Binary :: ByteString -> Content

-- | Download the contents of the URL
FromURL :: String -> Content

-- | An <a>ErlangPropList</a> <a>AST</a> with <a>Content</a>
type ErlangAst = AST Content ErlangPropList
instance GHC.Generics.Generic B9.Artifact.Content.Readable.Content
instance Data.Data.Data B9.Artifact.Content.Readable.Content
instance GHC.Classes.Eq B9.Artifact.Content.Readable.Content
instance GHC.Show.Show B9.Artifact.Content.Readable.Content
instance GHC.Read.Read B9.Artifact.Content.Readable.Content
instance Control.DeepSeq.NFData B9.Artifact.Content.Readable.Content
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Content.Readable.Content
instance B9.Artifact.Content.ToContentGenerator B9.Artifact.Content.Readable.Content


-- | Source files for <a>Generator</a>s.
module B9.Artifact.Readable.Source

-- | Describe how input files for artifacts to build are obtained. The
--   general structure of each constructor is <b>FromXXX</b>
--   <i>destination</i> <i>source</i>
data ArtifactSource

-- | Copy a <a>SourceFile</a> potentially replacing variable defined in
--   <tt>Let</tt>-like parent elements.
FromFile :: FilePath -> SourceFile -> ArtifactSource

-- | Create a file from some <a>Content</a>
FromContent :: FilePath -> Content -> ArtifactSource

-- | Set the unix <i>file permissions</i> to all files generated by the
--   nested list of <a>ArtifactSource</a>s.
SetPermissions :: Int -> Int -> Int -> [ArtifactSource] -> ArtifactSource

-- | Assume a local directory as starting point for all relative source
--   files in the nested <a>ArtifactSource</a>s.
FromDirectory :: FilePath -> [ArtifactSource] -> ArtifactSource

-- | Specify an output directory for all the files generated by the nested
--   <a>ArtifactSource</a>s
IntoDirectory :: FilePath -> [ArtifactSource] -> ArtifactSource

-- | Return all source files generated by an <a>ArtifactSource</a>.
getArtifactSourceFiles :: ArtifactSource -> [FilePath]
instance GHC.Generics.Generic B9.Artifact.Readable.Source.ArtifactSource
instance Data.Data.Data B9.Artifact.Readable.Source.ArtifactSource
instance GHC.Classes.Eq B9.Artifact.Readable.Source.ArtifactSource
instance GHC.Show.Show B9.Artifact.Readable.Source.ArtifactSource
instance GHC.Read.Read B9.Artifact.Readable.Source.ArtifactSource
instance Control.DeepSeq.NFData B9.Artifact.Readable.Source.ArtifactSource
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Readable.Source.ArtifactSource


-- | Top-Level data types for B9 build artifacts.
module B9.Artifact.Readable

-- | Artifacts represent the things B9 can build. A generator specifies
--   howto generate parameterized, multiple artifacts. The general
--   structure is:
--   
--   <pre>
--   Let [ ... bindings ... ]
--       [ Sources
--           [ ... list all input files ... ]
--           [ Artifact ...
--           , Artifact ...
--           , Let [ ... ] [ ... ]
--           ]
--       ]
--   </pre>
--   
--   The reasons why <a>Sources</a> takes a list of
--   <a>ArtifactGenerator</a>s is that
--   
--   <ol>
--   <li>this makes the value easier to read/write for humans</li>
--   <li>the sources are static files used in all children (e.g. company
--   logo image)</li>
--   <li>the sources are parameterized by variables that bound to different
--   values for each artifact, e.g. a template network config file which
--   contains the host IP address.</li>
--   </ol>
--   
--   To bind such variables use <a>Let</a>, <a>Each</a>, <a>LetX</a> or
--   <a>EachT</a>.
--   
--   String substitution of these variables is done by
--   <a>B9.Artifact.Content.StringTemplate</a>. These variables can be used
--   as value in nested <a>Let</a>s, in most file names/paths and in source
--   files added with <a>SourceFile</a>
--   
--   <ul>
--   <li>- @deprecated TODO remove this when switching to Dhall</li>
--   </ul>
data ArtifactGenerator

-- | Add sources available to <a>ArtifactAssembly</a>s in nested artifact
--   generators.
Sources :: [ArtifactSource] -> [ArtifactGenerator] -> ArtifactGenerator

-- | Bind variables, variables are available in nested generators.
--   @deprecated TODO remove this when switching to Dhall
Let :: [(String, String)] -> [ArtifactGenerator] -> ArtifactGenerator

-- | A <a>Let</a> where each variable is assigned to each value; the nested
--   generator is executed for each permutation.
--   
--   <pre>
--   LetX [("x", ["1","2","3"]), ("y", ["a","b"])] [..]
--   </pre>
--   
--   Is equal to:
--   
--   <pre>
--   Let [] [
--     Let [("x", "1"), ("y", "a")] [..]
--     Let [("x", "1"), ("y", "b")] [..]
--     Let [("x", "2"), ("y", "a")] [..]
--     Let [("x", "2"), ("y", "b")] [..]
--     Let [("x", "3"), ("y", "a")] [..]
--     Let [("x", "3"), ("y", "b")] [..]
--   ]
--   </pre>
--   
--   @deprecated TODO remove this when switching to Dhall
LetX :: [(String, [String])] -> [ArtifactGenerator] -> ArtifactGenerator

-- | Bind each variable to their first value, then each variable to the
--   second value, etc ... and execute the nested generator in every step.
--   <a>LetX</a> represents a product of all variables, whereas <a>Each</a>
--   represents a sum of variable bindings - <a>Each</a> is more like a
--   <i>zip</i> whereas <a>LetX</a> is more like a list comprehension.
--   @deprecated TODO remove this when switching to Dhall
Each :: [(String, [String])] -> [ArtifactGenerator] -> ArtifactGenerator

-- | The transposed version of <a>Each</a>: Bind the variables in the first
--   list to each a set of values from the second argument; execute the
--   nested generators for each binding @deprecated TODO remove this when
--   switching to Dhall
EachT :: [String] -> [[String]] -> [ArtifactGenerator] -> ArtifactGenerator

-- | Generate an artifact defined by an <a>ArtifactAssembly</a>; the
--   assembly can access the files created from the <a>Sources</a> and
--   variables bound by <a>Let</a>ish elements. An artifact has an instance
--   id, that is a unique, human readable string describing the artifact to
--   assemble.
Artifact :: InstanceId -> ArtifactAssembly -> ArtifactGenerator
EmptyArtifact :: ArtifactGenerator

-- | Identify an artifact. <b>Deprecated</b> TODO: B9 does not check if all
--   instances IDs are unique.
newtype InstanceId
IID :: String -> InstanceId
data ArtifactTarget
CloudInitTarget :: CloudInitType -> FilePath -> ArtifactTarget
VmImagesTarget :: ArtifactTarget
data CloudInitType
CI_ISO :: CloudInitType
CI_VFAT :: CloudInitType
CI_DIR :: CloudInitType

-- | Define an <b>output</b> of a build. Assemblies are nested into
--   <a>ArtifactGenerator</a>s. They contain all the files defined by the
--   <a>Sources</a> they are nested into.
data ArtifactAssembly

-- | Generate a <b>cloud-init</b> compatible directory, ISO- or VFAT image,
--   as specified by the list of <a>CloudInitType</a>s. Every item will use
--   the second argument to create an appropriate <i>file name</i>, e.g.
--   for the <a>CI_ISO</a> type the output is <tt>second_param.iso</tt>.
CloudInit :: [CloudInitType] -> FilePath -> ArtifactAssembly

-- | a set of VM-images that were created by executing a build script on
--   them.
VmImages :: [ImageTarget] -> VmScript -> ArtifactAssembly

-- | A symbolic representation of the targets assembled by <a>assemble</a>
--   from an <a>ArtifactAssembly</a>. There is a list of
--   <a>ArtifactTarget</a>s because e.g. a single <a>CloudInit</a> can
--   produce up to three output files, a directory, an ISO image and a VFAT
--   image.
data AssembledArtifact
AssembledArtifact :: InstanceId -> [ArtifactTarget] -> AssembledArtifact

-- | The output of an <a>ArtifactAssembly</a> is either a set of generated
--   files, or it might be a directory that contains the artifacts sources.
data AssemblyOutput
AssemblyGeneratesOutputFiles :: [FilePath] -> AssemblyOutput
AssemblyCopiesSourcesToDirectory :: FilePath -> AssemblyOutput

-- | The variable containing the instance id. <b>Deprecated</b>
instanceIdKey :: String

-- | The variable containing the buildId that identifies each execution of
--   B9. For more info about variable substitution in source files see
--   <a>StringTemplate</a>
buildIdKey :: String

-- | The variable containing the date and time a build was started. For
--   more info about variable substitution in source files see
--   <a>StringTemplate</a>
buildDateKey :: String

-- | Return the files that the artifact assembly consist of.
getAssemblyOutput :: ArtifactAssembly -> [AssemblyOutput]

-- | Describe how input files for artifacts to build are obtained. The
--   general structure of each constructor is <b>FromXXX</b>
--   <i>destination</i> <i>source</i>
data ArtifactSource

-- | Copy a <a>SourceFile</a> potentially replacing variable defined in
--   <tt>Let</tt>-like parent elements.
FromFile :: FilePath -> SourceFile -> ArtifactSource

-- | Create a file from some <a>Content</a>
FromContent :: FilePath -> Content -> ArtifactSource

-- | Set the unix <i>file permissions</i> to all files generated by the
--   nested list of <a>ArtifactSource</a>s.
SetPermissions :: Int -> Int -> Int -> [ArtifactSource] -> ArtifactSource

-- | Assume a local directory as starting point for all relative source
--   files in the nested <a>ArtifactSource</a>s.
FromDirectory :: FilePath -> [ArtifactSource] -> ArtifactSource

-- | Specify an output directory for all the files generated by the nested
--   <a>ArtifactSource</a>s
IntoDirectory :: FilePath -> [ArtifactSource] -> ArtifactSource

-- | Return all source files generated by an <a>ArtifactSource</a>.
getArtifactSourceFiles :: ArtifactSource -> [FilePath]
instance GHC.Generics.Generic B9.Artifact.Readable.AssemblyOutput
instance GHC.Classes.Eq B9.Artifact.Readable.AssemblyOutput
instance Data.Data.Data B9.Artifact.Readable.AssemblyOutput
instance GHC.Show.Show B9.Artifact.Readable.AssemblyOutput
instance GHC.Read.Read B9.Artifact.Readable.AssemblyOutput
instance GHC.Generics.Generic B9.Artifact.Readable.ArtifactGenerator
instance Data.Data.Data B9.Artifact.Readable.ArtifactGenerator
instance GHC.Classes.Eq B9.Artifact.Readable.ArtifactGenerator
instance GHC.Show.Show B9.Artifact.Readable.ArtifactGenerator
instance GHC.Read.Read B9.Artifact.Readable.ArtifactGenerator
instance GHC.Generics.Generic B9.Artifact.Readable.ArtifactAssembly
instance GHC.Classes.Eq B9.Artifact.Readable.ArtifactAssembly
instance Data.Data.Data B9.Artifact.Readable.ArtifactAssembly
instance GHC.Show.Show B9.Artifact.Readable.ArtifactAssembly
instance GHC.Read.Read B9.Artifact.Readable.ArtifactAssembly
instance GHC.Generics.Generic B9.Artifact.Readable.AssembledArtifact
instance GHC.Classes.Eq B9.Artifact.Readable.AssembledArtifact
instance Data.Data.Data B9.Artifact.Readable.AssembledArtifact
instance GHC.Show.Show B9.Artifact.Readable.AssembledArtifact
instance GHC.Read.Read B9.Artifact.Readable.AssembledArtifact
instance GHC.Generics.Generic B9.Artifact.Readable.ArtifactTarget
instance GHC.Classes.Eq B9.Artifact.Readable.ArtifactTarget
instance Data.Data.Data B9.Artifact.Readable.ArtifactTarget
instance GHC.Show.Show B9.Artifact.Readable.ArtifactTarget
instance GHC.Read.Read B9.Artifact.Readable.ArtifactTarget
instance GHC.Generics.Generic B9.Artifact.Readable.CloudInitType
instance GHC.Classes.Eq B9.Artifact.Readable.CloudInitType
instance Data.Data.Data B9.Artifact.Readable.CloudInitType
instance GHC.Show.Show B9.Artifact.Readable.CloudInitType
instance GHC.Read.Read B9.Artifact.Readable.CloudInitType
instance Data.Hashable.Class.Hashable B9.Artifact.Readable.InstanceId
instance Data.Binary.Class.Binary B9.Artifact.Readable.InstanceId
instance Control.DeepSeq.NFData B9.Artifact.Readable.InstanceId
instance GHC.Classes.Eq B9.Artifact.Readable.InstanceId
instance Data.Data.Data B9.Artifact.Readable.InstanceId
instance GHC.Show.Show B9.Artifact.Readable.InstanceId
instance GHC.Read.Read B9.Artifact.Readable.InstanceId
instance Control.DeepSeq.NFData B9.Artifact.Readable.ArtifactGenerator
instance GHC.Base.Semigroup B9.Artifact.Readable.ArtifactGenerator
instance GHC.Base.Monoid B9.Artifact.Readable.ArtifactGenerator
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Readable.ArtifactGenerator
instance Data.Hashable.Class.Hashable B9.Artifact.Readable.ArtifactAssembly
instance Data.Binary.Class.Binary B9.Artifact.Readable.ArtifactAssembly
instance Control.DeepSeq.NFData B9.Artifact.Readable.ArtifactAssembly
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Readable.ArtifactAssembly
instance Data.Hashable.Class.Hashable B9.Artifact.Readable.AssembledArtifact
instance Data.Binary.Class.Binary B9.Artifact.Readable.AssembledArtifact
instance Control.DeepSeq.NFData B9.Artifact.Readable.AssembledArtifact
instance Data.Hashable.Class.Hashable B9.Artifact.Readable.ArtifactTarget
instance Data.Binary.Class.Binary B9.Artifact.Readable.ArtifactTarget
instance Control.DeepSeq.NFData B9.Artifact.Readable.ArtifactTarget
instance Data.Hashable.Class.Hashable B9.Artifact.Readable.CloudInitType
instance Data.Binary.Class.Binary B9.Artifact.Readable.CloudInitType
instance Control.DeepSeq.NFData B9.Artifact.Readable.CloudInitType
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Readable.CloudInitType
instance Test.QuickCheck.Arbitrary.Arbitrary B9.Artifact.Readable.InstanceId


-- | Effectful functions to execute and build virtual machine images using
--   an execution environment like e.g. libvirt-lxc.
module B9.VmBuilder
buildWithVm :: IsB9 e => InstanceId -> [ImageTarget] -> FilePath -> VmScript -> Eff e Bool


-- | Mostly effectful functions to assemble artifacts.
module B9.Artifact.Readable.Interpreter

-- | Execute an <a>ArtifactGenerator</a> and return a <tt>B9Invocation</tt>
--   that returns the build id obtained by <a>getBuildId</a>.
buildArtifacts :: ArtifactGenerator -> B9 String

-- | Run an artifact generator to produce the artifacts.
assemble :: ArtifactGenerator -> B9 [AssembledArtifact]

-- | Return a list of relative paths for the <i>local</i> files to be
--   generated by the ArtifactGenerator. This excludes <tt>Shared</tt> and
--   Transient image targets.
getArtifactOutputFiles :: ArtifactGenerator -> Either SomeException [FilePath]

-- | Interpret an <a>ArtifactGenerator</a> into a list of simple commands,
--   i.e. <a>InstanceGenerator</a>s
runArtifactGenerator :: Environment -> String -> String -> ArtifactGenerator -> Either SomeException [InstanceGenerator [TextFileWriter]]

-- | Create the <a>ArtifactTarget</a> from an <a>ArtifactAssembly</a> in
--   the directory <tt>instanceDir</tt>
runArtifactAssembly :: IsB9 e => InstanceId -> FilePath -> ArtifactAssembly -> Eff e [ArtifactTarget]
data InstanceGenerator e
IG :: InstanceId -> e -> ArtifactAssembly -> InstanceGenerator e

-- | Run an
runInstanceGenerator :: IsB9 e => InstanceGenerator FilePath -> Eff e AssembledArtifact

-- | Internal data structure. Only exposed for unit testing.
data InstanceSources
InstanceSources :: Environment -> [ArtifactSource] -> InstanceSources
[isEnv] :: InstanceSources -> Environment
[isSources] :: InstanceSources -> [ArtifactSource]
instance GHC.Classes.Eq B9.Artifact.Readable.Interpreter.TextFileWriter
instance GHC.Show.Show B9.Artifact.Readable.Interpreter.TextFileWriter
instance GHC.Classes.Eq B9.Artifact.Readable.Interpreter.FilePermissionAction
instance Data.Data.Data B9.Artifact.Readable.Interpreter.FilePermissionAction
instance GHC.Show.Show B9.Artifact.Readable.Interpreter.FilePermissionAction
instance GHC.Read.Read B9.Artifact.Readable.Interpreter.FilePermissionAction
instance GHC.Classes.Eq B9.Artifact.Readable.Interpreter.TextFileWriterInput
instance GHC.Show.Show B9.Artifact.Readable.Interpreter.TextFileWriterInput
instance GHC.Read.Read B9.Artifact.Readable.Interpreter.TextFileWriterInput
instance GHC.Classes.Eq e => GHC.Classes.Eq (B9.Artifact.Readable.Interpreter.InstanceGenerator e)
instance Data.Data.Data e => Data.Data.Data (B9.Artifact.Readable.Interpreter.InstanceGenerator e)
instance GHC.Show.Show e => GHC.Show.Show (B9.Artifact.Readable.Interpreter.InstanceGenerator e)
instance GHC.Read.Read e => GHC.Read.Read (B9.Artifact.Readable.Interpreter.InstanceGenerator e)
instance GHC.Classes.Eq B9.Artifact.Readable.Interpreter.InstanceSources
instance GHC.Show.Show B9.Artifact.Readable.Interpreter.InstanceSources


-- | B9 is a library and build tool with which one can create/convert
--   different types of VM images. Additionally installation steps - like
--   installing software - can be done in a LXC container, running on the
--   disk images.
--   
--   B9 allows to create and convert virtual machine image files as well as
--   related ISO and VFAT disk images for e.g. cloud-init configuration
--   sources.
--   
--   This module re-exports the modules needed to build a tool around the
--   library, e.g. see <tt>src/cli/Main.hs</tt> as an example.
--   
--   <a>B9.Artifact.Generator</a> is the module containing the basic data
--   structure used to describe a B9 build.
module B9

-- | Return the cabal package version of the B9 library.
b9Version :: Version

-- | Return the cabal package version of the B9 library, formatted using
--   <a>showVersion</a>.
b9VersionString :: String

-- | Just print the <a>b9VersionString</a>
runShowVersion :: MonadIO m => m ()

-- | Execute the artifact generators defined in a list of text files. Read
--   the text files in the list and parse them as <a>ArtifactGenerator</a>s
--   then <a>mappend</a> them and apply <a>buildArtifacts</a> to them.
runBuildArtifacts :: [FilePath] -> B9ConfigAction String

-- | Read all text files and parse them as <a>ArtifactGenerator</a>s. Then
--   overwrite the files with their contents but _pretty printed_ (i.e.
--   formatted).
runFormatBuildFiles :: MonadIO m => [FilePath] -> m ()

-- | Upload a <a>SharedImageName</a> to the default remote repository.
--   Note: The remote repository is specified in the <a>B9Config</a>.
runPush :: SharedImageName -> B9ConfigAction ()

-- | Either pull a list of available <a>SharedImageName</a>s from the
--   remote repository if <a>Nothing</a> is passed as parameter, or pull
--   the latest version of the image from the remote repository. Note: The
--   remote repository is specified in the <a>B9Config</a>.
runPull :: Maybe SharedImageName -> B9ConfigAction ()

-- | Execute an interactive root shell in a running container from a
--   <a>SharedImageName</a>.
runRun :: SharedImageName -> [String] -> B9ConfigAction String

-- | Delete all obsolete versions of all <a>SharedImageName</a>s.
runGcLocalRepoCache :: B9ConfigAction ()

-- | Clear the shared image cache for a remote. Note: The remote repository
--   is specified in the <a>B9Config</a>.
runGcRemoteRepoCache :: B9ConfigAction ()

-- | Print a list of shared images cached locally or remotely, if a remote
--   repository was selected. Note: The remote repository is specified in
--   the <a>B9Config</a>.
runListSharedImages :: B9ConfigAction (Set SharedImage)

-- | Check the SSH settings for a remote repository and add it to the user
--   wide B9 configuration file.
runAddRepo :: RemoteRepo -> B9ConfigAction ()

-- | Find the most recent version of a <a>SharedImageName</a> in the local
--   image cache.
runLookupLocalSharedImage :: SharedImageName -> B9ConfigAction (Maybe SharedImageBuildId)

-- | Append two lists, i.e.,
--   
--   <pre>
--   [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
--   [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
--   </pre>
--   
--   If the first list is not finite, the result is the first list.
(++) :: () => [a] -> [a] -> [a]
infixr 5 ++

-- | <a>filter</a>, applied to a predicate and a list, returns the list of
--   those elements that satisfy the predicate; i.e.,
--   
--   <pre>
--   filter p xs = [ x | x &lt;- xs, p x]
--   </pre>
filter :: () => (a -> Bool) -> [a] -> [a]

-- | <a>zip</a> takes two lists and returns a list of corresponding pairs.
--   
--   <pre>
--   zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]
--   </pre>
--   
--   If one input list is short, excess elements of the longer list are
--   discarded:
--   
--   <pre>
--   zip [1] ['a', 'b'] = [(1, 'a')]
--   zip [1, 2] ['a'] = [(1, 'a')]
--   </pre>
--   
--   <a>zip</a> is right-lazy:
--   
--   <pre>
--   zip [] _|_ = []
--   zip _|_ [] = _|_
--   </pre>
zip :: () => [a] -> [b] -> [(a, b)]

-- | <a>map</a> <tt>f xs</tt> is the list obtained by applying <tt>f</tt>
--   to each element of <tt>xs</tt>, i.e.,
--   
--   <pre>
--   map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
--   map f [x1, x2, ...] == [f x1, f x2, ...]
--   </pre>
map :: () => (a -> b) -> [a] -> [b]

-- | Conditional failure of <a>Alternative</a> computations. Defined by
--   
--   <pre>
--   guard True  = <a>pure</a> ()
--   guard False = <a>empty</a>
--   </pre>
--   
--   <h4><b>Examples</b></h4>
--   
--   Common uses of <a>guard</a> include conditionally signaling an error
--   in an error monad and conditionally rejecting the current choice in an
--   <a>Alternative</a>-based parser.
--   
--   As an example of signaling an error in the error monad <a>Maybe</a>,
--   consider a safe division function <tt>safeDiv x y</tt> that returns
--   <a>Nothing</a> when the denominator <tt>y</tt> is zero and
--   <tt><a>Just</a> (x `div` y)</tt> otherwise. For example:
--   
--   <pre>
--   &gt;&gt;&gt; safeDiv 4 0
--   Nothing
--   &gt;&gt;&gt; safeDiv 4 2
--   Just 2
--   </pre>
--   
--   A definition of <tt>safeDiv</tt> using guards, but not <a>guard</a>:
--   
--   <pre>
--   safeDiv :: Int -&gt; Int -&gt; Maybe Int
--   safeDiv x y | y /= 0    = Just (x `div` y)
--               | otherwise = Nothing
--   </pre>
--   
--   A definition of <tt>safeDiv</tt> using <a>guard</a> and <a>Monad</a>
--   <tt>do</tt>-notation:
--   
--   <pre>
--   safeDiv :: Int -&gt; Int -&gt; Maybe Int
--   safeDiv x y = do
--     guard (y /= 0)
--     return (x `div` y)
--   </pre>
guard :: Alternative f => Bool -> f ()

-- | The <a>join</a> function is the conventional monad join operator. It
--   is used to remove one level of monadic structure, projecting its bound
--   argument into the outer level.
--   
--   <h4><b>Examples</b></h4>
--   
--   A common use of <a>join</a> is to run an <a>IO</a> computation
--   returned from an <a>STM</a> transaction, since <a>STM</a> transactions
--   can't perform <a>IO</a> directly. Recall that
--   
--   <pre>
--   <a>atomically</a> :: STM a -&gt; IO a
--   </pre>
--   
--   is used to run <a>STM</a> transactions atomically. So, by specializing
--   the types of <a>atomically</a> and <a>join</a> to
--   
--   <pre>
--   <a>atomically</a> :: STM (IO b) -&gt; IO (IO b)
--   <a>join</a>       :: IO (IO b)  -&gt; IO b
--   </pre>
--   
--   we can compose them as
--   
--   <pre>
--   <a>join</a> . <a>atomically</a> :: STM (IO b) -&gt; IO b
--   </pre>
--   
--   to run an <a>STM</a> transaction and the <a>IO</a> action it returns.
join :: Monad m => m (m a) -> m a

-- | The <a>Monad</a> class defines the basic operations over a
--   <i>monad</i>, a concept from a branch of mathematics known as
--   <i>category theory</i>. From the perspective of a Haskell programmer,
--   however, it is best to think of a monad as an <i>abstract datatype</i>
--   of actions. Haskell's <tt>do</tt> expressions provide a convenient
--   syntax for writing monadic expressions.
--   
--   Instances of <a>Monad</a> should satisfy the following laws:
--   
--   <ul>
--   <li><pre><a>return</a> a <a>&gt;&gt;=</a> k = k a</pre></li>
--   <li><pre>m <a>&gt;&gt;=</a> <a>return</a> = m</pre></li>
--   <li><pre>m <a>&gt;&gt;=</a> (\x -&gt; k x <a>&gt;&gt;=</a> h) = (m
--   <a>&gt;&gt;=</a> k) <a>&gt;&gt;=</a> h</pre></li>
--   </ul>
--   
--   Furthermore, the <a>Monad</a> and <a>Applicative</a> operations should
--   relate as follows:
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>(<a>&lt;*&gt;</a>) = <a>ap</a></pre></li>
--   </ul>
--   
--   The above laws imply:
--   
--   <ul>
--   <li><pre><a>fmap</a> f xs = xs <a>&gt;&gt;=</a> <a>return</a> .
--   f</pre></li>
--   <li><pre>(<a>&gt;&gt;</a>) = (<a>*&gt;</a>)</pre></li>
--   </ul>
--   
--   and that <a>pure</a> and (<a>&lt;*&gt;</a>) satisfy the applicative
--   functor laws.
--   
--   The instances of <a>Monad</a> for lists, <a>Maybe</a> and <a>IO</a>
--   defined in the <a>Prelude</a> satisfy these laws.
class Applicative m => Monad (m :: Type -> Type)

-- | Sequentially compose two actions, passing any value produced by the
--   first as an argument to the second.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

-- | Sequentially compose two actions, discarding any value produced by the
--   first, like sequencing operators (such as the semicolon) in imperative
--   languages.
(>>) :: Monad m => m a -> m b -> m b

-- | Inject a value into the monadic type.
return :: Monad m => a -> m a

-- | Fail with a message. This operation is not part of the mathematical
--   definition of a monad, but is invoked on pattern-match failure in a
--   <tt>do</tt> expression.
--   
--   As part of the MonadFail proposal (MFP), this function is moved to its
--   own class <tt>MonadFail</tt> (see <a>Control.Monad.Fail</a> for more
--   details). The definition here will be removed in a future release.
fail :: Monad m => String -> m a
infixl 1 >>=
infixl 1 >>

-- | The <a>Functor</a> class is used for types that can be mapped over.
--   Instances of <a>Functor</a> should satisfy the following laws:
--   
--   <pre>
--   fmap id  ==  id
--   fmap (f . g)  ==  fmap f . fmap g
--   </pre>
--   
--   The instances of <a>Functor</a> for lists, <a>Maybe</a> and <a>IO</a>
--   satisfy these laws.
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b

-- | Replace all locations in the input with the same value. The default
--   definition is <tt><a>fmap</a> . <a>const</a></tt>, but this may be
--   overridden with a more efficient version.
(<$) :: Functor f => a -> f b -> f a
infixl 4 <$

-- | A functor with application, providing operations to
--   
--   <ul>
--   <li>embed pure expressions (<a>pure</a>), and</li>
--   <li>sequence computations and combine their results (<a>&lt;*&gt;</a>
--   and <a>liftA2</a>).</li>
--   </ul>
--   
--   A minimal complete definition must include implementations of
--   <a>pure</a> and of either <a>&lt;*&gt;</a> or <a>liftA2</a>. If it
--   defines both, then they must behave the same as their default
--   definitions:
--   
--   <pre>
--   (<a>&lt;*&gt;</a>) = <a>liftA2</a> <a>id</a>
--   </pre>
--   
--   <pre>
--   <a>liftA2</a> f x y = f <tt>&lt;$&gt;</tt> x <a>&lt;*&gt;</a> y
--   </pre>
--   
--   Further, any definition must satisfy the following:
--   
--   <ul>
--   <li><i><i>identity</i></i> <pre><a>pure</a> <a>id</a> <a>&lt;*&gt;</a>
--   v = v</pre></li>
--   <li><i><i>composition</i></i> <pre><a>pure</a> (.) <a>&lt;*&gt;</a> u
--   <a>&lt;*&gt;</a> v <a>&lt;*&gt;</a> w = u <a>&lt;*&gt;</a> (v
--   <a>&lt;*&gt;</a> w)</pre></li>
--   <li><i><i>homomorphism</i></i> <pre><a>pure</a> f <a>&lt;*&gt;</a>
--   <a>pure</a> x = <a>pure</a> (f x)</pre></li>
--   <li><i><i>interchange</i></i> <pre>u <a>&lt;*&gt;</a> <a>pure</a> y =
--   <a>pure</a> (<a>$</a> y) <a>&lt;*&gt;</a> u</pre></li>
--   </ul>
--   
--   The other methods have the following default definitions, which may be
--   overridden with equivalent specialized implementations:
--   
--   <ul>
--   <li><pre>u <a>*&gt;</a> v = (<a>id</a> <a>&lt;$</a> u)
--   <a>&lt;*&gt;</a> v</pre></li>
--   <li><pre>u <a>&lt;*</a> v = <a>liftA2</a> <a>const</a> u v</pre></li>
--   </ul>
--   
--   As a consequence of these laws, the <a>Functor</a> instance for
--   <tt>f</tt> will satisfy
--   
--   <ul>
--   <li><pre><a>fmap</a> f x = <a>pure</a> f <a>&lt;*&gt;</a> x</pre></li>
--   </ul>
--   
--   It may be useful to note that supposing
--   
--   <pre>
--   forall x y. p (q x y) = f x . g y
--   </pre>
--   
--   it follows from the above that
--   
--   <pre>
--   <a>liftA2</a> p (<a>liftA2</a> q u v) = <a>liftA2</a> f u . <a>liftA2</a> g v
--   </pre>
--   
--   If <tt>f</tt> is also a <a>Monad</a>, it should satisfy
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>(<a>&lt;*&gt;</a>) = <a>ap</a></pre></li>
--   <li><pre>(<a>*&gt;</a>) = (<a>&gt;&gt;</a>)</pre></li>
--   </ul>
--   
--   (which implies that <a>pure</a> and <a>&lt;*&gt;</a> satisfy the
--   applicative functor laws).
class Functor f => Applicative (f :: Type -> Type)

-- | Lift a value.
pure :: Applicative f => a -> f a

-- | Sequential application.
--   
--   A few functors support an implementation of <a>&lt;*&gt;</a> that is
--   more efficient than the default one.
(<*>) :: Applicative f => f (a -> b) -> f a -> f b

-- | Lift a binary function to actions.
--   
--   Some functors support an implementation of <a>liftA2</a> that is more
--   efficient than the default one. In particular, if <a>fmap</a> is an
--   expensive operation, it is likely better to use <a>liftA2</a> than to
--   <a>fmap</a> over the structure and then use <a>&lt;*&gt;</a>.
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

-- | Sequence actions, discarding the value of the first argument.
(*>) :: Applicative f => f a -> f b -> f b

-- | Sequence actions, discarding the value of the second argument.
(<*) :: Applicative f => f a -> f b -> f a
infixl 4 <*>
infixl 4 *>
infixl 4 <*

-- | Right-associative fold of a structure.
--   
--   In the case of lists, <a>foldr</a>, when applied to a binary operator,
--   a starting value (typically the right-identity of the operator), and a
--   list, reduces the list using the binary operator, from right to left:
--   
--   <pre>
--   foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
--   </pre>
--   
--   Note that, since the head of the resulting expression is produced by
--   an application of the operator to the first element of the list,
--   <a>foldr</a> can produce a terminating expression from an infinite
--   list.
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldr f z = <a>foldr</a> f z . <a>toList</a>
--   </pre>
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

-- | Returns the size/length of a finite structure as an <a>Int</a>. The
--   default implementation is optimized for structures that are similar to
--   cons-lists, because there is no general way to do better.
length :: Foldable t => t a -> Int

-- | Test whether the structure is empty. The default implementation is
--   optimized for structures that are similar to cons-lists, because there
--   is no general way to do better.
null :: Foldable t => t a -> Bool

-- | Left-associative fold of a structure.
--   
--   In the case of lists, <a>foldl</a>, when applied to a binary operator,
--   a starting value (typically the left-identity of the operator), and a
--   list, reduces the list using the binary operator, from left to right:
--   
--   <pre>
--   foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
--   </pre>
--   
--   Note that to produce the outermost application of the operator the
--   entire input list must be traversed. This means that <a>foldl'</a>
--   will diverge if given an infinite list.
--   
--   Also note that if you want an efficient left-fold, you probably want
--   to use <a>foldl'</a> instead of <a>foldl</a>. The reason for this is
--   that latter does not force the "inner" results (e.g. <tt>z <tt>f</tt>
--   x1</tt> in the above example) before applying them to the operator
--   (e.g. to <tt>(<tt>f</tt> x2)</tt>). This results in a thunk chain
--   <tt>O(n)</tt> elements long, which then must be evaluated from the
--   outside-in.
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldl f z = <a>foldl</a> f z . <a>toList</a>
--   </pre>
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

-- | Left-associative fold of a structure but with strict application of
--   the operator.
--   
--   This ensures that each step of the fold is forced to weak head normal
--   form before being applied, avoiding the collection of thunks that
--   would otherwise occur. This is often what you want to strictly reduce
--   a finite list to a single, monolithic result (e.g. <a>length</a>).
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldl f z = <a>foldl'</a> f z . <a>toList</a>
--   </pre>
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b

-- | A variant of <a>foldl</a> that has no base case, and thus may only be
--   applied to non-empty structures.
--   
--   <pre>
--   <a>foldl1</a> f = <a>foldl1</a> f . <a>toList</a>
--   </pre>
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a

-- | The <a>sum</a> function computes the sum of the numbers of a
--   structure.
sum :: (Foldable t, Num a) => t a -> a

-- | The <a>product</a> function computes the product of the numbers of a
--   structure.
product :: (Foldable t, Num a) => t a -> a

-- | A variant of <a>foldr</a> that has no base case, and thus may only be
--   applied to non-empty structures.
--   
--   <pre>
--   <a>foldr1</a> f = <a>foldr1</a> f . <a>toList</a>
--   </pre>
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a

-- | The largest element of a non-empty structure.
maximum :: (Foldable t, Ord a) => t a -> a

-- | The least element of a non-empty structure.
minimum :: (Foldable t, Ord a) => t a -> a

-- | Does the element occur in the structure?
elem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `elem`

-- | Map each element of a structure to a monadic action, evaluate these
--   actions from left to right, and collect the results. For a version
--   that ignores the results see <a>mapM_</a>.
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

-- | Evaluate each monadic action in the structure from left to right, and
--   collect the results. For a version that ignores the results see
--   <a>sequence_</a>.
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

-- | An associative operation.
(<>) :: Semigroup a => a -> a -> a
infixr 6 <>

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following laws:
--   
--   <ul>
--   <li><pre>x <a>&lt;&gt;</a> <a>mempty</a> = x</pre></li>
--   <li><pre><a>mempty</a> <a>&lt;&gt;</a> x = x</pre></li>
--   <li><tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) = (x <a>&lt;&gt;</a>
--   y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a> law)</li>
--   <li><pre><a>mconcat</a> = <a>foldr</a> '(&lt;&gt;)'
--   <a>mempty</a></pre></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <tt>Sum</tt> and <tt>Product</tt>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = '(&lt;&gt;)'</tt> since
--   <i>base-4.11.0.0</i>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
mconcat :: Monoid a => [a] -> a

-- | The <a>Maybe</a> type encapsulates an optional value. A value of type
--   <tt><a>Maybe</a> a</tt> either contains a value of type <tt>a</tt>
--   (represented as <tt><a>Just</a> a</tt>), or it is empty (represented
--   as <a>Nothing</a>). Using <a>Maybe</a> is a good way to deal with
--   errors or exceptional cases without resorting to drastic measures such
--   as <tt>error</tt>.
--   
--   The <a>Maybe</a> type is also a monad. It is a simple kind of error
--   monad, where all errors are represented by <a>Nothing</a>. A richer
--   error monad can be built using the <a>Either</a> type.
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a

-- | <a>unlines</a> is an inverse operation to <a>lines</a>. It joins
--   lines, after appending a terminating newline to each.
--   
--   <pre>
--   &gt;&gt;&gt; unlines ["Hello", "World", "!"]
--   "Hello\nWorld\n!\n"
--   </pre>
unlines :: [String] -> String

-- | <a>lines</a> breaks a string up into a list of strings at newline
--   characters. The resulting strings do not contain newlines.
--   
--   Note that after splitting the string at newline characters, the last
--   part of the string is considered a line even if it doesn't end with a
--   newline. For example,
--   
--   <pre>
--   &gt;&gt;&gt; lines ""
--   []
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "\n"
--   [""]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one"
--   ["one"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\n"
--   ["one"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\n\n"
--   ["one",""]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\ntwo"
--   ["one","two"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\ntwo\n"
--   ["one","two"]
--   </pre>
--   
--   Thus <tt><a>lines</a> s</tt> contains at least as many elements as
--   newlines in <tt>s</tt>.
lines :: String -> [String]

-- | The <a>isInfixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is contained, wholly and intact, anywhere within
--   the second.
--   
--   <pre>
--   &gt;&gt;&gt; isInfixOf "Haskell" "I really like Haskell."
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; isInfixOf "Ial" "I really like Haskell."
--   False
--   </pre>
isInfixOf :: Eq a => [a] -> [a] -> Bool

-- | <a>delete</a> <tt>x</tt> removes the first occurrence of <tt>x</tt>
--   from its list argument. For example,
--   
--   <pre>
--   &gt;&gt;&gt; delete 'a' "banana"
--   "bnana"
--   </pre>
--   
--   It is a special case of <a>deleteBy</a>, which allows the programmer
--   to supply their own equality test.
delete :: Eq a => a -> [a] -> [a]

-- | A <a>Version</a> represents the version of a software entity.
--   
--   An instance of <a>Eq</a> is provided, which implements exact equality
--   modulo reordering of the tags in the <a>versionTags</a> field.
--   
--   An instance of <a>Ord</a> is also provided, which gives lexicographic
--   ordering on the <a>versionBranch</a> fields (i.e. 2.1 &gt; 2.0, 1.2.3
--   &gt; 1.2.2, etc.). This is expected to be sufficient for many uses,
--   but note that you may need to use a more specific ordering for your
--   versioning scheme. For example, some versioning schemes may include
--   pre-releases which have tags <tt>"pre1"</tt>, <tt>"pre2"</tt>, and so
--   on, and these would need to be taken into account when determining
--   ordering. In some cases, date ordering may be more appropriate, so the
--   application would have to look for <tt>date</tt> tags in the
--   <a>versionTags</a> field and compare those. The bottom line is, don't
--   always assume that <a>compare</a> and other <a>Ord</a> operations are
--   the right thing for every <a>Version</a>.
--   
--   Similarly, concrete representations of versions may differ. One
--   possible concrete representation is provided (see <a>showVersion</a>
--   and <a>parseVersion</a>), but depending on the application a different
--   concrete representation may be more appropriate.
data Version
Version :: [Int] -> [String] -> Version

-- | The numeric branch for this version. This reflects the fact that most
--   software versions are tree-structured; there is a main trunk which is
--   tagged with versions at various points (1,2,3...), and the first
--   branch off the trunk after version 3 is 3.1, the second branch off the
--   trunk after version 3 is 3.2, and so on. The tree can be branched
--   arbitrarily, just by adding more digits.
--   
--   We represent the branch as a list of <a>Int</a>, so version 3.2.1
--   becomes [3,2,1]. Lexicographic ordering (i.e. the default instance of
--   <a>Ord</a> for <tt>[Int]</tt>) gives the natural ordering of branches.
[versionBranch] :: Version -> [Int]

-- | A version can be tagged with an arbitrary list of strings. The
--   interpretation of the list of tags is entirely dependent on the entity
--   that this version applies to.
[versionTags] :: Version -> [String]

-- | Promote a function to a monad.
liftM :: Monad m => (a1 -> r) -> m a1 -> m r

-- | Executes a computation in a modified environment.
local :: MonadReader r m => (r -> r) -> m a -> m a

-- | Retrieves the monad environment.
ask :: MonadReader r m => m r

-- | A space-efficient representation of a <a>Word8</a> vector, supporting
--   many efficient operations.
--   
--   A <a>ByteString</a> contains 8-bit bytes, or by using the operations
--   from <a>Data.ByteString.Char8</a> it can be interpreted as containing
--   8-bit characters.
data ByteString

-- | An infix synonym for <a>fmap</a>.
--   
--   The name of this operator is an allusion to <tt>$</tt>. Note the
--   similarities between their types:
--   
--   <pre>
--    ($)  ::              (a -&gt; b) -&gt;   a -&gt;   b
--   (&lt;$&gt;) :: Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
--   </pre>
--   
--   Whereas <tt>$</tt> is function application, <a>&lt;$&gt;</a> is
--   function application lifted over a <a>Functor</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Convert from a <tt><tt>Maybe</tt> <tt>Int</tt></tt> to a
--   <tt><tt>Maybe</tt> <tt>String</tt></tt> using <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Nothing
--   Nothing
--   
--   &gt;&gt;&gt; show &lt;$&gt; Just 3
--   Just "3"
--   </pre>
--   
--   Convert from an <tt><tt>Either</tt> <tt>Int</tt> <tt>Int</tt></tt> to
--   an <tt><tt>Either</tt> <tt>Int</tt></tt> <tt>String</tt> using
--   <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Left 17
--   Left 17
--   
--   &gt;&gt;&gt; show &lt;$&gt; Right 17
--   Right "17"
--   </pre>
--   
--   Double each element of a list:
--   
--   <pre>
--   &gt;&gt;&gt; (*2) &lt;$&gt; [1,2,3]
--   [2,4,6]
--   </pre>
--   
--   Apply <tt>even</tt> to the second element of a pair:
--   
--   <pre>
--   &gt;&gt;&gt; even &lt;$&gt; (2,2)
--   (2,True)
--   </pre>
(<$>) :: Functor f => (a -> b) -> f a -> f b
infixl 4 <$>

-- | A space efficient, packed, unboxed Unicode text type.
data Text

-- | A monoid on applicative functors.
--   
--   If defined, <a>some</a> and <a>many</a> should be the least solutions
--   of the equations:
--   
--   <ul>
--   <li><pre><a>some</a> v = (:) <tt>&lt;$&gt;</tt> v <a>&lt;*&gt;</a>
--   <a>many</a> v</pre></li>
--   <li><pre><a>many</a> v = <a>some</a> v <a>&lt;|&gt;</a> <a>pure</a>
--   []</pre></li>
--   </ul>
class Applicative f => Alternative (f :: Type -> Type)

-- | The identity of <a>&lt;|&gt;</a>
empty :: Alternative f => f a

-- | An associative binary operation
(<|>) :: Alternative f => f a -> f a -> f a

-- | One or more.
some :: Alternative f => f a -> f [a]

-- | Zero or more.
many :: Alternative f => f a -> f [a]
infixl 3 <|>

-- | Monads that also support choice and failure.
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)

-- | The identity of <a>mplus</a>. It should also satisfy the equations
--   
--   <pre>
--   mzero &gt;&gt;= f  =  mzero
--   v &gt;&gt; mzero   =  mzero
--   </pre>
--   
--   The default definition is
--   
--   <pre>
--   mzero = <a>empty</a>
--   </pre>
mzero :: MonadPlus m => m a

-- | An associative operation. The default definition is
--   
--   <pre>
--   mplus = (<a>&lt;|&gt;</a>)
--   </pre>
mplus :: MonadPlus m => m a -> m a -> m a

-- | Monads in which <a>IO</a> computations may be embedded. Any monad
--   built by applying a sequence of monad transformers to the <a>IO</a>
--   monad will be an instance of this class.
--   
--   Instances should satisfy the following laws, which state that
--   <a>liftIO</a> is a transformer of monads:
--   
--   <ul>
--   <li><pre><a>liftIO</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>liftIO</a> (m &gt;&gt;= f) = <a>liftIO</a> m &gt;&gt;=
--   (<a>liftIO</a> . f)</pre></li>
--   </ul>
class Monad m => MonadIO (m :: Type -> Type)

-- | Lift a computation from the <a>IO</a> monad.
liftIO :: MonadIO m => IO a -> m a

-- | Computation <a>exitWith</a> <tt>code</tt> throws <a>ExitCode</a>
--   <tt>code</tt>. Normally this terminates the program, returning
--   <tt>code</tt> to the program's caller.
--   
--   On program termination, the standard <a>Handle</a>s <a>stdout</a> and
--   <a>stderr</a> are flushed automatically; any other buffered
--   <a>Handle</a>s need to be flushed manually, otherwise the buffered
--   data will be discarded.
--   
--   A program that fails in any other way is treated as if it had called
--   <a>exitFailure</a>. A program that terminates successfully without
--   calling <a>exitWith</a> explicitly is treated as if it had called
--   <a>exitWith</a> <a>ExitSuccess</a>.
--   
--   As an <a>ExitCode</a> is not an <a>IOException</a>, <a>exitWith</a>
--   bypasses the error handling in the <a>IO</a> monad and cannot be
--   intercepted by <a>catch</a> from the <a>Prelude</a>. However it is a
--   <tt>SomeException</tt>, and can be caught using the functions of
--   <a>Control.Exception</a>. This means that cleanup computations added
--   with <a>bracket</a> (from <a>Control.Exception</a>) are also executed
--   properly on <a>exitWith</a>.
--   
--   Note: in GHC, <a>exitWith</a> should be called from the main program
--   thread in order to exit the process. When called from another thread,
--   <a>exitWith</a> will throw an <tt>ExitException</tt> as normal, but
--   the exception will not cause the process itself to exit.
exitWith :: () => ExitCode -> IO a

-- | Format a variable number of arguments with the C-style formatting
--   string.
--   
--   <pre>
--   &gt;&gt;&gt; printf "%s, %d, %.4f" "hello" 123 pi
--   hello, 123, 3.1416
--   </pre>
--   
--   The return value is either <a>String</a> or <tt>(<a>IO</a> a)</tt>
--   (which should be <tt>(<a>IO</a> '()')</tt>, but Haskell's type system
--   makes this hard).
--   
--   The format string consists of ordinary characters and <i>conversion
--   specifications</i>, which specify how to format one of the arguments
--   to <a>printf</a> in the output string. A format specification is
--   introduced by the <tt>%</tt> character; this character can be
--   self-escaped into the format string using <tt>%%</tt>. A format
--   specification ends with a /format character/ that provides the primary
--   information about how to format the value. The rest of the conversion
--   specification is optional. In order, one may have flag characters, a
--   width specifier, a precision specifier, and type-specific modifier
--   characters.
--   
--   Unlike C <tt>printf(3)</tt>, the formatting of this <a>printf</a> is
--   driven by the argument type; formatting is type specific. The types
--   formatted by <a>printf</a> "out of the box" are:
--   
--   <ul>
--   <li><a>Integral</a> types, including <a>Char</a></li>
--   <li><a>String</a></li>
--   <li><a>RealFloat</a> types</li>
--   </ul>
--   
--   <a>printf</a> is also extensible to support other types: see below.
--   
--   A conversion specification begins with the character <tt>%</tt>,
--   followed by zero or more of the following flags:
--   
--   <pre>
--   -      left adjust (default is right adjust)
--   +      always use a sign (+ or -) for signed conversions
--   space  leading space for positive numbers in signed conversions
--   0      pad with zeros rather than spaces
--   #      use an \"alternate form\": see below
--   </pre>
--   
--   When both flags are given, <tt>-</tt> overrides <tt>0</tt> and
--   <tt>+</tt> overrides space. A negative width specifier in a <tt>*</tt>
--   conversion is treated as positive but implies the left adjust flag.
--   
--   The "alternate form" for unsigned radix conversions is as in C
--   <tt>printf(3)</tt>:
--   
--   <pre>
--   %o           prefix with a leading 0 if needed
--   %x           prefix with a leading 0x if nonzero
--   %X           prefix with a leading 0X if nonzero
--   %b           prefix with a leading 0b if nonzero
--   %[eEfFgG]    ensure that the number contains a decimal point
--   </pre>
--   
--   Any flags are followed optionally by a field width:
--   
--   <pre>
--   num    field width
--   *      as num, but taken from argument list
--   </pre>
--   
--   The field width is a minimum, not a maximum: it will be expanded as
--   needed to avoid mutilating a value.
--   
--   Any field width is followed optionally by a precision:
--   
--   <pre>
--   .num   precision
--   .      same as .0
--   .*     as num, but taken from argument list
--   </pre>
--   
--   Negative precision is taken as 0. The meaning of the precision depends
--   on the conversion type.
--   
--   <pre>
--   Integral    minimum number of digits to show
--   RealFloat   number of digits after the decimal point
--   String      maximum number of characters
--   </pre>
--   
--   The precision for Integral types is accomplished by zero-padding. If
--   both precision and zero-pad are given for an Integral field, the
--   zero-pad is ignored.
--   
--   Any precision is followed optionally for Integral types by a width
--   modifier; the only use of this modifier being to set the implicit size
--   of the operand for conversion of a negative operand to unsigned:
--   
--   <pre>
--   hh     Int8
--   h      Int16
--   l      Int32
--   ll     Int64
--   L      Int64
--   </pre>
--   
--   The specification ends with a format character:
--   
--   <pre>
--   c      character               Integral
--   d      decimal                 Integral
--   o      octal                   Integral
--   x      hexadecimal             Integral
--   X      hexadecimal             Integral
--   b      binary                  Integral
--   u      unsigned decimal        Integral
--   f      floating point          RealFloat
--   F      floating point          RealFloat
--   g      general format float    RealFloat
--   G      general format float    RealFloat
--   e      exponent format float   RealFloat
--   E      exponent format float   RealFloat
--   s      string                  String
--   v      default format          any type
--   </pre>
--   
--   The "%v" specifier is provided for all built-in types, and should be
--   provided for user-defined type formatters as well. It picks a "best"
--   representation for the given type. For the built-in types the "%v"
--   specifier is converted as follows:
--   
--   <pre>
--   c      Char
--   u      other unsigned Integral
--   d      other signed Integral
--   g      RealFloat
--   s      String
--   </pre>
--   
--   Mismatch between the argument types and the format string, as well as
--   any other syntactic or semantic errors in the format string, will
--   cause an exception to be thrown at runtime.
--   
--   Note that the formatting for <a>RealFloat</a> types is currently a bit
--   different from that of C <tt>printf(3)</tt>, conforming instead to
--   <a>showEFloat</a>, <a>showFFloat</a> and <a>showGFloat</a> (and their
--   alternate versions <a>showFFloatAlt</a> and <a>showGFloatAlt</a>).
--   This is hard to fix: the fixed versions would format in a
--   backward-incompatible way. In any case the Haskell behavior is
--   generally more sensible than the C behavior. A brief summary of some
--   key differences:
--   
--   <ul>
--   <li>Haskell <a>printf</a> never uses the default "6-digit" precision
--   used by C printf.</li>
--   <li>Haskell <a>printf</a> treats the "precision" specifier as
--   indicating the number of digits after the decimal point.</li>
--   <li>Haskell <a>printf</a> prints the exponent of e-format numbers
--   without a gratuitous plus sign, and with the minimum possible number
--   of digits.</li>
--   <li>Haskell <a>printf</a> will place a zero after a decimal point when
--   possible.</li>
--   </ul>
printf :: PrintfType r => String -> r

-- | Direct <a>MonadPlus</a> equivalent of <a>filter</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   The <a>filter</a> function is just <a>mfilter</a> specialized to the
--   list monad:
--   
--   <pre>
--   <a>filter</a> = ( <a>mfilter</a> :: (a -&gt; Bool) -&gt; [a] -&gt; [a] )
--   </pre>
--   
--   An example using <a>mfilter</a> with the <a>Maybe</a> monad:
--   
--   <pre>
--   &gt;&gt;&gt; mfilter odd (Just 1)
--   Just 1
--   &gt;&gt;&gt; mfilter odd (Just 2)
--   Nothing
--   </pre>
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a

-- | Strict version of <a>&lt;$&gt;</a>.
(<$!>) :: Monad m => (a -> b) -> m a -> m b
infixl 4 <$!>

-- | The reverse of <a>when</a>.
unless :: Applicative f => Bool -> f () -> f ()

-- | Like <a>replicateM</a>, but discards the result.
replicateM_ :: Applicative m => Int -> m a -> m ()

-- | <tt><a>replicateM</a> n act</tt> performs the action <tt>n</tt> times,
--   gathering the results.
replicateM :: Applicative m => Int -> m a -> m [a]

-- | Like <a>foldM</a>, but discards the result.
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()

-- | The <a>foldM</a> function is analogous to <tt>foldl</tt>, except that
--   its result is encapsulated in a monad. Note that <a>foldM</a> works
--   from left-to-right over the list arguments. This could be an issue
--   where <tt>(<a>&gt;&gt;</a>)</tt> and the `folded function' are not
--   commutative.
--   
--   <pre>
--   foldM f a1 [x1, x2, ..., xm]
--   
--   ==
--   
--   do
--     a2 &lt;- f a1 x1
--     a3 &lt;- f a2 x2
--     ...
--     f am xm
--   </pre>
--   
--   If right-to-left evaluation is required, the input list should be
--   reversed.
--   
--   Note: <a>foldM</a> is the same as <a>foldlM</a>
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b

-- | <a>zipWithM_</a> is the extension of <a>zipWithM</a> which ignores the
--   final result.
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()

-- | The <a>zipWithM</a> function generalizes <a>zipWith</a> to arbitrary
--   applicative functors.
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]

-- | The <a>mapAndUnzipM</a> function maps its first argument over a list,
--   returning the result as a pair of lists. This function is mainly used
--   with complicated data structures or a state-transforming monad.
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])

-- | Repeat an action indefinitely.
--   
--   <h4><b>Examples</b></h4>
--   
--   A common use of <a>forever</a> is to process input from network
--   sockets, <a>Handle</a>s, and channels (e.g. <a>MVar</a> and
--   <a>Chan</a>).
--   
--   For example, here is how we might implement an <a>echo server</a>,
--   using <a>forever</a> both to listen for client connections on a
--   network socket and to echo client input on client connection handles:
--   
--   <pre>
--   echoServer :: Socket -&gt; IO ()
--   echoServer socket = <a>forever</a> $ do
--     client &lt;- accept socket
--     <a>forkFinally</a> (echo client) (\_ -&gt; hClose client)
--     where
--       echo :: Handle -&gt; IO ()
--       echo client = <a>forever</a> $
--         hGetLine client &gt;&gt;= hPutStrLn client
--   </pre>
forever :: Applicative f => f a -> f b

-- | Right-to-left composition of Kleisli arrows.
--   <tt>(<a>&gt;=&gt;</a>)</tt>, with the arguments flipped.
--   
--   Note how this operator resembles function composition
--   <tt>(<a>.</a>)</tt>:
--   
--   <pre>
--   (.)   ::            (b -&gt;   c) -&gt; (a -&gt;   b) -&gt; a -&gt;   c
--   (&lt;=&lt;) :: Monad m =&gt; (b -&gt; m c) -&gt; (a -&gt; m b) -&gt; a -&gt; m c
--   </pre>
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
infixr 1 <=<

-- | Left-to-right composition of Kleisli arrows.
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
infixr 1 >=>

-- | This generalizes the list-based <tt>filter</tt> function.
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]

-- | Construct tag-less <a>Version</a>
makeVersion :: [Int] -> Version

-- | A parser for versions in the format produced by <a>showVersion</a>.
parseVersion :: ReadP Version

-- | Provides one possible concrete representation for <a>Version</a>. For
--   a version with <a>versionBranch</a> <tt>= [1,2,3]</tt> and
--   <a>versionTags</a> <tt>= ["tag1","tag2"]</tt>, the output will be
--   <tt>1.2.3-tag1-tag2</tt>.
showVersion :: Version -> String

-- | The <a>isSubsequenceOf</a> function takes two lists and returns
--   <a>True</a> if all the elements of the first list occur, in order, in
--   the second. The elements do not have to occur consecutively.
--   
--   <tt><a>isSubsequenceOf</a> x y</tt> is equivalent to <tt><a>elem</a> x
--   (<a>subsequences</a> y)</tt>.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; isSubsequenceOf "GHC" "The Glorious Haskell Compiler"
--   True
--   
--   &gt;&gt;&gt; isSubsequenceOf ['a','d'..'z'] ['a'..'z']
--   True
--   
--   &gt;&gt;&gt; isSubsequenceOf [1..10] [10,9..0]
--   False
--   </pre>
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>mapAccumR</a> function behaves like a combination of
--   <a>fmap</a> and <tt>foldr</tt>; it applies a function to each element
--   of a structure, passing an accumulating parameter from right to left,
--   and returning a final value of this accumulator together with the new
--   structure.
mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)

-- | The <a>mapAccumL</a> function behaves like a combination of
--   <a>fmap</a> and <tt>foldl</tt>; it applies a function to each element
--   of a structure, passing an accumulating parameter from left to right,
--   and returning a final value of this accumulator together with the new
--   structure.
mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)

-- | <a>forM</a> is <a>mapM</a> with its arguments flipped. For a version
--   that ignores the results see <a>forM_</a>.
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)

-- | One or none.
optional :: Alternative f => f a -> f (Maybe a)
newtype WrappedMonad (m :: Type -> Type) a
WrapMonad :: m a -> WrappedMonad a
[unwrapMonad] :: WrappedMonad a -> m a
newtype WrappedArrow (a :: Type -> Type -> Type) b c
WrapArrow :: a b c -> WrappedArrow b c
[unwrapArrow] :: WrappedArrow b c -> a b c

-- | Lists, but with an <a>Applicative</a> functor based on zipping.
newtype ZipList a
ZipList :: [a] -> ZipList a
[getZipList] :: ZipList a -> [a]

-- | Defines the exit codes that a program can return.
data ExitCode

-- | indicates successful termination;
ExitSuccess :: ExitCode

-- | indicates program failure with an exit code. The exact interpretation
--   of the code is operating-system dependent. In particular, some values
--   may be prohibited (e.g. 0 on a POSIX-compliant system).
ExitFailure :: Int -> ExitCode

-- | The <a>Const</a> functor.
newtype Const a (b :: k) :: forall k. () => Type -> k -> Type
Const :: a -> Const a
[getConst] :: Const a -> a

-- | The <a>find</a> function takes a predicate and a structure and returns
--   the leftmost element of the structure matching the predicate, or
--   <a>Nothing</a> if there is no such element.
find :: Foldable t => (a -> Bool) -> t a -> Maybe a

-- | <a>notElem</a> is the negation of <a>elem</a>.
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `notElem`

-- | The least element of a non-empty structure with respect to the given
--   comparison function.
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a

-- | The largest element of a non-empty structure with respect to the given
--   comparison function.
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a

-- | Determines whether all elements of the structure satisfy the
--   predicate.
all :: Foldable t => (a -> Bool) -> t a -> Bool

-- | Determines whether any element of the structure satisfies the
--   predicate.
any :: Foldable t => (a -> Bool) -> t a -> Bool

-- | <a>or</a> returns the disjunction of a container of Bools. For the
--   result to be <a>False</a>, the container must be finite; <a>True</a>,
--   however, results from a <a>True</a> value finitely far from the left
--   end.
or :: Foldable t => t Bool -> Bool

-- | <a>and</a> returns the conjunction of a container of Bools. For the
--   result to be <a>True</a>, the container must be finite; <a>False</a>,
--   however, results from a <a>False</a> value finitely far from the left
--   end.
and :: Foldable t => t Bool -> Bool

-- | Map a function over all the elements of a container and concatenate
--   the resulting lists.
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]

-- | The concatenation of all the elements of a container of lists.
concat :: Foldable t => t [a] -> [a]

-- | The sum of a collection of actions, generalizing <a>concat</a>. As of
--   base 4.8.0.0, <a>msum</a> is just <a>asum</a>, specialized to
--   <a>MonadPlus</a>.
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a

-- | Evaluate each monadic action in the structure from left to right, and
--   ignore the results. For a version that doesn't ignore the results see
--   <a>sequence</a>.
--   
--   As of base 4.8.0.0, <a>sequence_</a> is just <a>sequenceA_</a>,
--   specialized to <a>Monad</a>.
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

-- | <a>forM_</a> is <a>mapM_</a> with its arguments flipped. For a version
--   that doesn't ignore the results see <a>forM</a>.
--   
--   As of base 4.8.0.0, <a>forM_</a> is just <a>for_</a>, specialized to
--   <a>Monad</a>.
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()

-- | Map each element of a structure to a monadic action, evaluate these
--   actions from left to right, and ignore the results. For a version that
--   doesn't ignore the results see <a>mapM</a>.
--   
--   As of base 4.8.0.0, <a>mapM_</a> is just <a>traverse_</a>, specialized
--   to <a>Monad</a>.
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

-- | Maybe monoid returning the leftmost non-Nothing value.
--   
--   <tt><a>First</a> a</tt> is isomorphic to <tt><a>Alt</a> <a>Maybe</a>
--   a</tt>, but precedes it historically.
--   
--   <pre>
--   &gt;&gt;&gt; getFirst (First (Just "hello") &lt;&gt; First Nothing &lt;&gt; First (Just "world"))
--   Just "hello"
--   </pre>
--   
--   Use of this type is discouraged. Note the following equivalence:
--   
--   <pre>
--   Data.Monoid.First x === Maybe (Data.Semigroup.First x)
--   </pre>
--   
--   In addition to being equivalent in the structural sense, the two also
--   have <a>Monoid</a> instances that behave the same. This type will be
--   marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are
--   advised to use the variant from <a>Data.Semigroup</a> and wrap it in
--   <a>Maybe</a>.
newtype First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a

-- | Maybe monoid returning the rightmost non-Nothing value.
--   
--   <tt><a>Last</a> a</tt> is isomorphic to <tt><a>Dual</a> (<a>First</a>
--   a)</tt>, and thus to <tt><a>Dual</a> (<a>Alt</a> <a>Maybe</a> a)</tt>
--   
--   <pre>
--   &gt;&gt;&gt; getLast (Last (Just "hello") &lt;&gt; Last Nothing &lt;&gt; Last (Just "world"))
--   Just "world"
--   </pre>
--   
--   Use of this type is discouraged. Note the following equivalence:
--   
--   <pre>
--   Data.Monoid.Last x === Maybe (Data.Semigroup.Last x)
--   </pre>
--   
--   In addition to being equivalent in the structural sense, the two also
--   have <a>Monoid</a> instances that behave the same. This type will be
--   marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are
--   advised to use the variant from <a>Data.Semigroup</a> and wrap it in
--   <a>Maybe</a>.
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a

-- | This data type witnesses the lifting of a <a>Monoid</a> into an
--   <a>Applicative</a> pointwise.
newtype Ap (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
Ap :: f a -> Ap
[getAp] :: Ap -> f a

-- | The dual of a <a>Monoid</a>, obtained by swapping the arguments of
--   <a>mappend</a>.
--   
--   <pre>
--   &gt;&gt;&gt; getDual (mappend (Dual "Hello") (Dual "World"))
--   "WorldHello"
--   </pre>
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a

-- | The monoid of endomorphisms under composition.
--   
--   <pre>
--   &gt;&gt;&gt; let computation = Endo ("Hello, " ++) &lt;&gt; Endo (++ "!")
--   
--   &gt;&gt;&gt; appEndo computation "Haskell"
--   "Hello, Haskell!"
--   </pre>
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a

-- | Boolean monoid under conjunction (<a>&amp;&amp;</a>).
--   
--   <pre>
--   &gt;&gt;&gt; getAll (All True &lt;&gt; mempty &lt;&gt; All False)
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAll (mconcat (map (\x -&gt; All (even x)) [2,4,6,7,8]))
--   False
--   </pre>
newtype All
All :: Bool -> All
[getAll] :: All -> Bool

-- | Boolean monoid under disjunction (<a>||</a>).
--   
--   <pre>
--   &gt;&gt;&gt; getAny (Any True &lt;&gt; mempty &lt;&gt; Any False)
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAny (mconcat (map (\x -&gt; Any (even x)) [2,4,6,7,8]))
--   True
--   </pre>
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool

-- | Monoid under addition.
--   
--   <pre>
--   &gt;&gt;&gt; getSum (Sum 1 &lt;&gt; Sum 2 &lt;&gt; mempty)
--   3
--   </pre>
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a

-- | Monoid under multiplication.
--   
--   <pre>
--   &gt;&gt;&gt; getProduct (Product 3 &lt;&gt; Product 4 &lt;&gt; mempty)
--   12
--   </pre>
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a

-- | Monoid under <a>&lt;|&gt;</a>.
newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
Alt :: f a -> Alt
[getAlt] :: Alt -> f a

-- | <a>unwords</a> is an inverse operation to <a>words</a>. It joins words
--   with separating spaces.
--   
--   <pre>
--   &gt;&gt;&gt; unwords ["Lorem", "ipsum", "dolor"]
--   "Lorem ipsum dolor"
--   </pre>
unwords :: [String] -> String

-- | <a>words</a> breaks a string up into a list of words, which were
--   delimited by white space.
--   
--   <pre>
--   &gt;&gt;&gt; words "Lorem ipsum\ndolor"
--   ["Lorem","ipsum","dolor"]
--   </pre>
words :: String -> [String]

-- | The <a>unfoldr</a> function is a `dual' to <a>foldr</a>: while
--   <a>foldr</a> reduces a list to a summary value, <a>unfoldr</a> builds
--   a list from a seed value. The function takes the element and returns
--   <a>Nothing</a> if it is done producing the list or returns <a>Just</a>
--   <tt>(a,b)</tt>, in which case, <tt>a</tt> is a prepended to the list
--   and <tt>b</tt> is used as the next element in a recursive call. For
--   example,
--   
--   <pre>
--   iterate f == unfoldr (\x -&gt; Just (x, f x))
--   </pre>
--   
--   In some cases, <a>unfoldr</a> can undo a <a>foldr</a> operation:
--   
--   <pre>
--   unfoldr f' (foldr f z xs) == xs
--   </pre>
--   
--   if the following holds:
--   
--   <pre>
--   f' (f x y) = Just (x,y)
--   f' z       = Nothing
--   </pre>
--   
--   A simple use of unfoldr:
--   
--   <pre>
--   &gt;&gt;&gt; unfoldr (\b -&gt; if b == 0 then Nothing else Just (b, b-1)) 10
--   [10,9,8,7,6,5,4,3,2,1]
--   </pre>
unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]

-- | Sort a list by comparing the results of a key function applied to each
--   element. <tt>sortOn f</tt> is equivalent to <tt>sortBy (comparing
--   f)</tt>, but has the performance advantage of only evaluating
--   <tt>f</tt> once for each element in the input list. This is called the
--   decorate-sort-undecorate paradigm, or Schwartzian transform.
--   
--   Elements are arranged from from lowest to highest, keeping duplicates
--   in the order they appeared in the input.
--   
--   <pre>
--   &gt;&gt;&gt; sortOn fst [(2, "world"), (4, "!"), (1, "Hello")]
--   [(1,"Hello"),(2,"world"),(4,"!")]
--   </pre>
sortOn :: Ord b => (a -> b) -> [a] -> [a]

-- | The <a>sortBy</a> function is the non-overloaded version of
--   <a>sort</a>.
--   
--   <pre>
--   &gt;&gt;&gt; sortBy (\(a,_) (b,_) -&gt; compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
--   [(1,"Hello"),(2,"world"),(4,"!")]
--   </pre>
sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]

-- | The <a>sort</a> function implements a stable sorting algorithm. It is
--   a special case of <a>sortBy</a>, which allows the programmer to supply
--   their own comparison function.
--   
--   Elements are arranged from from lowest to highest, keeping duplicates
--   in the order they appeared in the input.
--   
--   <pre>
--   &gt;&gt;&gt; sort [1,6,4,3,2,5]
--   [1,2,3,4,5,6]
--   </pre>
sort :: Ord a => [a] -> [a]

-- | The <a>permutations</a> function returns the list of all permutations
--   of the argument.
--   
--   <pre>
--   &gt;&gt;&gt; permutations "abc"
--   ["abc","bac","cba","bca","cab","acb"]
--   </pre>
permutations :: () => [a] -> [[a]]

-- | The <a>subsequences</a> function returns the list of all subsequences
--   of the argument.
--   
--   <pre>
--   &gt;&gt;&gt; subsequences "abc"
--   ["","a","b","ab","c","ac","bc","abc"]
--   </pre>
subsequences :: () => [a] -> [[a]]

-- | The <a>tails</a> function returns all final segments of the argument,
--   longest first. For example,
--   
--   <pre>
--   &gt;&gt;&gt; tails "abc"
--   ["abc","bc","c",""]
--   </pre>
--   
--   Note that <a>tails</a> has the following strictness property:
--   <tt>tails _|_ = _|_ : _|_</tt>
tails :: () => [a] -> [[a]]

-- | The <a>inits</a> function returns all initial segments of the
--   argument, shortest first. For example,
--   
--   <pre>
--   &gt;&gt;&gt; inits "abc"
--   ["","a","ab","abc"]
--   </pre>
--   
--   Note that <a>inits</a> has the following strictness property:
--   <tt>inits (xs ++ _|_) = inits xs ++ _|_</tt>
--   
--   In particular, <tt>inits _|_ = [] : _|_</tt>
inits :: () => [a] -> [[a]]

-- | The <a>groupBy</a> function is the non-overloaded version of
--   <a>group</a>.
groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]

-- | The <a>group</a> function takes a list and returns a list of lists
--   such that the concatenation of the result is equal to the argument.
--   Moreover, each sublist in the result contains only equal elements. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; group "Mississippi"
--   ["M","i","ss","i","ss","i","pp","i"]
--   </pre>
--   
--   It is a special case of <a>groupBy</a>, which allows the programmer to
--   supply their own equality test.
group :: Eq a => [a] -> [[a]]

-- | The <a>deleteFirstsBy</a> function takes a predicate and two lists and
--   returns the first list with the first occurrence of each element of
--   the second list removed.
deleteFirstsBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]

-- | The <a>unzip7</a> function takes a list of seven-tuples and returns
--   seven lists, analogous to <a>unzip</a>.
unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])

-- | The <a>unzip6</a> function takes a list of six-tuples and returns six
--   lists, analogous to <a>unzip</a>.
unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])

-- | The <a>unzip5</a> function takes a list of five-tuples and returns
--   five lists, analogous to <a>unzip</a>.
unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])

-- | The <a>unzip4</a> function takes a list of quadruples and returns four
--   lists, analogous to <a>unzip</a>.
unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])

-- | The <a>zipWith7</a> function takes a function which combines seven
--   elements, as well as seven lists and returns a list of their
--   point-wise combination, analogous to <a>zipWith</a>.
zipWith7 :: () => (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

-- | The <a>zipWith6</a> function takes a function which combines six
--   elements, as well as six lists and returns a list of their point-wise
--   combination, analogous to <a>zipWith</a>.
zipWith6 :: () => (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]

-- | The <a>zipWith5</a> function takes a function which combines five
--   elements, as well as five lists and returns a list of their point-wise
--   combination, analogous to <a>zipWith</a>.
zipWith5 :: () => (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]

-- | The <a>zipWith4</a> function takes a function which combines four
--   elements, as well as four lists and returns a list of their point-wise
--   combination, analogous to <a>zipWith</a>.
zipWith4 :: () => (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]

-- | The <a>zip7</a> function takes seven lists and returns a list of
--   seven-tuples, analogous to <a>zip</a>.
zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]

-- | The <a>zip6</a> function takes six lists and returns a list of
--   six-tuples, analogous to <a>zip</a>.
zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]

-- | The <a>zip5</a> function takes five lists and returns a list of
--   five-tuples, analogous to <a>zip</a>.
zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]

-- | The <a>zip4</a> function takes four lists and returns a list of
--   quadruples, analogous to <a>zip</a>.
zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]

-- | The <a>genericReplicate</a> function is an overloaded version of
--   <a>replicate</a>, which accepts any <a>Integral</a> value as the
--   number of repetitions to make.
genericReplicate :: Integral i => i -> a -> [a]

-- | The <a>genericIndex</a> function is an overloaded version of
--   <a>!!</a>, which accepts any <a>Integral</a> value as the index.
genericIndex :: Integral i => [a] -> i -> a

-- | The <a>genericSplitAt</a> function is an overloaded version of
--   <a>splitAt</a>, which accepts any <a>Integral</a> value as the
--   position at which to split.
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])

-- | The <a>genericDrop</a> function is an overloaded version of
--   <a>drop</a>, which accepts any <a>Integral</a> value as the number of
--   elements to drop.
genericDrop :: Integral i => i -> [a] -> [a]

-- | The <a>genericTake</a> function is an overloaded version of
--   <a>take</a>, which accepts any <a>Integral</a> value as the number of
--   elements to take.
genericTake :: Integral i => i -> [a] -> [a]

-- | The <a>genericLength</a> function is an overloaded version of
--   <a>length</a>. In particular, instead of returning an <a>Int</a>, it
--   returns any type which is an instance of <a>Num</a>. It is, however,
--   less efficient than <a>length</a>.
genericLength :: Num i => [a] -> i

-- | The non-overloaded version of <a>insert</a>.
insertBy :: () => (a -> a -> Ordering) -> a -> [a] -> [a]

-- | The <a>insert</a> function takes an element and a list and inserts the
--   element into the list at the first position where it is less than or
--   equal to the next element. In particular, if the list is sorted before
--   the call, the result will also be sorted. It is a special case of
--   <a>insertBy</a>, which allows the programmer to supply their own
--   comparison function.
--   
--   <pre>
--   &gt;&gt;&gt; insert 4 [1,2,3,5,6,7]
--   [1,2,3,4,5,6,7]
--   </pre>
insert :: Ord a => a -> [a] -> [a]

-- | The <a>partition</a> function takes a predicate a list and returns the
--   pair of lists of elements which do and do not satisfy the predicate,
--   respectively; i.e.,
--   
--   <pre>
--   partition p xs == (filter p xs, filter (not . p) xs)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; partition (`elem` "aeiou") "Hello World!"
--   ("eoo","Hll Wrld!")
--   </pre>
partition :: () => (a -> Bool) -> [a] -> ([a], [a])

-- | The <a>transpose</a> function transposes the rows and columns of its
--   argument. For example,
--   
--   <pre>
--   &gt;&gt;&gt; transpose [[1,2,3],[4,5,6]]
--   [[1,4],[2,5],[3,6]]
--   </pre>
--   
--   If some of the rows are shorter than the following rows, their
--   elements are skipped:
--   
--   <pre>
--   &gt;&gt;&gt; transpose [[10,11],[20],[],[30,31,32]]
--   [[10,20,30],[11,31],[32]]
--   </pre>
transpose :: () => [[a]] -> [[a]]

-- | <a>intercalate</a> <tt>xs xss</tt> is equivalent to <tt>(<a>concat</a>
--   (<a>intersperse</a> xs xss))</tt>. It inserts the list <tt>xs</tt> in
--   between the lists in <tt>xss</tt> and concatenates the result.
--   
--   <pre>
--   &gt;&gt;&gt; intercalate ", " ["Lorem", "ipsum", "dolor"]
--   "Lorem, ipsum, dolor"
--   </pre>
intercalate :: () => [a] -> [[a]] -> [a]

-- | The <a>intersperse</a> function takes an element and a list and
--   `intersperses' that element between the elements of the list. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; intersperse ',' "abcde"
--   "a,b,c,d,e"
--   </pre>
intersperse :: () => a -> [a] -> [a]

-- | The <a>intersectBy</a> function is the non-overloaded version of
--   <a>intersect</a>.
intersectBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]

-- | The <a>intersect</a> function takes the list intersection of two
--   lists. For example,
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3,4] `intersect` [2,4,6,8]
--   [2,4]
--   </pre>
--   
--   If the first list contains duplicates, so will the result.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,2,3,4] `intersect` [6,4,4,2]
--   [2,2,4]
--   </pre>
--   
--   It is a special case of <a>intersectBy</a>, which allows the
--   programmer to supply their own equality test. If the element is found
--   in both the first and the second list, the element from the first list
--   will be used.
intersect :: Eq a => [a] -> [a] -> [a]

-- | The <a>unionBy</a> function is the non-overloaded version of
--   <a>union</a>.
unionBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]

-- | The <a>union</a> function returns the list union of the two lists. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; "dog" `union` "cow"
--   "dogcw"
--   </pre>
--   
--   Duplicates, and elements of the first list, are removed from the the
--   second list, but if the first list contains duplicates, so will the
--   result. It is a special case of <a>unionBy</a>, which allows the
--   programmer to supply their own equality test.
union :: Eq a => [a] -> [a] -> [a]

-- | The <a>\\</a> function is list difference (non-associative). In the
--   result of <tt>xs</tt> <a>\\</a> <tt>ys</tt>, the first occurrence of
--   each element of <tt>ys</tt> in turn (if any) has been removed from
--   <tt>xs</tt>. Thus
--   
--   <pre>
--   (xs ++ ys) \\ xs == ys.
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello World!" \\ "ell W"
--   "Hoorld!"
--   </pre>
--   
--   It is a special case of <a>deleteFirstsBy</a>, which allows the
--   programmer to supply their own equality test.
(\\) :: Eq a => [a] -> [a] -> [a]
infix 5 \\

-- | The <a>deleteBy</a> function behaves like <a>delete</a>, but takes a
--   user-supplied equality predicate.
--   
--   <pre>
--   &gt;&gt;&gt; deleteBy (&lt;=) 4 [1..10]
--   [1,2,3,5,6,7,8,9,10]
--   </pre>
deleteBy :: () => (a -> a -> Bool) -> a -> [a] -> [a]

-- | The <a>nubBy</a> function behaves just like <a>nub</a>, except it uses
--   a user-supplied equality predicate instead of the overloaded <a>==</a>
--   function.
--   
--   <pre>
--   &gt;&gt;&gt; nubBy (\x y -&gt; mod x 3 == mod y 3) [1,2,4,5,6]
--   [1,2,6]
--   </pre>
nubBy :: () => (a -> a -> Bool) -> [a] -> [a]

-- | <i>O(n^2)</i>. The <a>nub</a> function removes duplicate elements from
--   a list. In particular, it keeps only the first occurrence of each
--   element. (The name <a>nub</a> means `essence'.) It is a special case
--   of <a>nubBy</a>, which allows the programmer to supply their own
--   equality test.
--   
--   <pre>
--   &gt;&gt;&gt; nub [1,2,3,4,3,2,1,2,4,3,5]
--   [1,2,3,4,5]
--   </pre>
nub :: Eq a => [a] -> [a]

-- | The <a>isSuffixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is a suffix of the second. The second list must be
--   finite.
--   
--   <pre>
--   &gt;&gt;&gt; "ld!" `isSuffixOf` "Hello World!"
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "World" `isSuffixOf` "Hello World!"
--   False
--   </pre>
isSuffixOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>isPrefixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is a prefix of the second.
--   
--   <pre>
--   &gt;&gt;&gt; "Hello" `isPrefixOf` "Hello World!"
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello" `isPrefixOf` "Wello Horld!"
--   False
--   </pre>
isPrefixOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>findIndices</a> function extends <a>findIndex</a>, by returning
--   the indices of all elements satisfying the predicate, in ascending
--   order.
--   
--   <pre>
--   &gt;&gt;&gt; findIndices (`elem` "aeiou") "Hello World!"
--   [1,4,7]
--   </pre>
findIndices :: () => (a -> Bool) -> [a] -> [Int]

-- | The <a>findIndex</a> function takes a predicate and a list and returns
--   the index of the first element in the list satisfying the predicate,
--   or <a>Nothing</a> if there is no such element.
--   
--   <pre>
--   &gt;&gt;&gt; findIndex isSpace "Hello World!"
--   Just 5
--   </pre>
findIndex :: () => (a -> Bool) -> [a] -> Maybe Int

-- | The <a>elemIndices</a> function extends <a>elemIndex</a>, by returning
--   the indices of all elements equal to the query element, in ascending
--   order.
--   
--   <pre>
--   &gt;&gt;&gt; elemIndices 'o' "Hello World"
--   [4,7]
--   </pre>
elemIndices :: Eq a => a -> [a] -> [Int]

-- | The <a>elemIndex</a> function returns the index of the first element
--   in the given list which is equal (by <a>==</a>) to the query element,
--   or <a>Nothing</a> if there is no such element.
--   
--   <pre>
--   &gt;&gt;&gt; elemIndex 4 [0..]
--   Just 4
--   </pre>
elemIndex :: Eq a => a -> [a] -> Maybe Int

-- | The <a>stripPrefix</a> function drops the given prefix from a list. It
--   returns <a>Nothing</a> if the list did not start with the prefix
--   given, or <a>Just</a> the list after the prefix, if it does.
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "foobar"
--   Just "bar"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "foo"
--   Just ""
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "barfoo"
--   Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "barfoobaz"
--   Nothing
--   </pre>
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]

-- | The <a>dropWhileEnd</a> function drops the largest suffix of a list in
--   which the given predicate holds for all elements. For example:
--   
--   <pre>
--   &gt;&gt;&gt; dropWhileEnd isSpace "foo\n"
--   "foo"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; dropWhileEnd isSpace "foo bar"
--   "foo bar"
--   </pre>
--   
--   <pre>
--   dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined
--   </pre>
dropWhileEnd :: () => (a -> Bool) -> [a] -> [a]

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
--   
--   <pre>
--   &gt;&gt;&gt; 5 &amp; (+1) &amp; show
--   "6"
--   </pre>
(&) :: () => a -> (a -> b) -> b
infixl 1 &

-- | <tt><a>void</a> value</tt> discards or ignores the result of
--   evaluation, such as the return value of an <a>IO</a> action.
--   
--   <h4><b>Examples</b></h4>
--   
--   Replace the contents of a <tt><tt>Maybe</tt> <tt>Int</tt></tt> with
--   unit:
--   
--   <pre>
--   &gt;&gt;&gt; void Nothing
--   Nothing
--   
--   &gt;&gt;&gt; void (Just 3)
--   Just ()
--   </pre>
--   
--   Replace the contents of an <tt><tt>Either</tt> <tt>Int</tt>
--   <tt>Int</tt></tt> with unit, resulting in an <tt><tt>Either</tt>
--   <tt>Int</tt> '()'</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; void (Left 8675309)
--   Left 8675309
--   
--   &gt;&gt;&gt; void (Right 8675309)
--   Right ()
--   </pre>
--   
--   Replace every element of a list with unit:
--   
--   <pre>
--   &gt;&gt;&gt; void [1,2,3]
--   [(),(),()]
--   </pre>
--   
--   Replace the second element of a pair with unit:
--   
--   <pre>
--   &gt;&gt;&gt; void (1,2)
--   (1,())
--   </pre>
--   
--   Discard the result of an <a>IO</a> action:
--   
--   <pre>
--   &gt;&gt;&gt; mapM print [1,2]
--   1
--   2
--   [(),()]
--   
--   &gt;&gt;&gt; void $ mapM print [1,2]
--   1
--   2
--   </pre>
void :: Functor f => f a -> f ()

-- | The <a>unzip3</a> function takes a list of triples and returns three
--   lists, analogous to <a>unzip</a>.
unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])

-- | <a>unzip</a> transforms a list of pairs into a list of first
--   components and a list of second components.
unzip :: () => [(a, b)] -> ([a], [b])

-- | The <a>zipWith3</a> function takes a function which combines three
--   elements, as well as three lists and returns a list of their
--   point-wise combination, analogous to <a>zipWith</a>.
zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

-- | <a>zipWith</a> generalises <a>zip</a> by zipping with the function
--   given as the first argument, instead of a tupling function. For
--   example, <tt><a>zipWith</a> (+)</tt> is applied to two lists to
--   produce the list of corresponding sums.
--   
--   <a>zipWith</a> is right-lazy:
--   
--   <pre>
--   zipWith f [] _|_ = []
--   </pre>
zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]

-- | <a>zip3</a> takes three lists and returns a list of triples, analogous
--   to <a>zip</a>.
zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]

-- | List index (subscript) operator, starting from 0. It is an instance of
--   the more general <a>genericIndex</a>, which takes an index of any
--   integral type.
(!!) :: () => [a] -> Int -> a
infixl 9 !!

-- | <a>lookup</a> <tt>key assocs</tt> looks up a key in an association
--   list.
lookup :: Eq a => a -> [(a, b)] -> Maybe b

-- | <a>reverse</a> <tt>xs</tt> returns the elements of <tt>xs</tt> in
--   reverse order. <tt>xs</tt> must be finite.
reverse :: () => [a] -> [a]

-- | <a>break</a>, applied to a predicate <tt>p</tt> and a list
--   <tt>xs</tt>, returns a tuple where first element is longest prefix
--   (possibly empty) of <tt>xs</tt> of elements that <i>do not satisfy</i>
--   <tt>p</tt> and second element is the remainder of the list:
--   
--   <pre>
--   break (&gt; 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
--   break (&lt; 9) [1,2,3] == ([],[1,2,3])
--   break (&gt; 9) [1,2,3] == ([1,2,3],[])
--   </pre>
--   
--   <a>break</a> <tt>p</tt> is equivalent to <tt><a>span</a> (<a>not</a> .
--   p)</tt>.
break :: () => (a -> Bool) -> [a] -> ([a], [a])

-- | <a>span</a>, applied to a predicate <tt>p</tt> and a list <tt>xs</tt>,
--   returns a tuple where first element is longest prefix (possibly empty)
--   of <tt>xs</tt> of elements that satisfy <tt>p</tt> and second element
--   is the remainder of the list:
--   
--   <pre>
--   span (&lt; 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
--   span (&lt; 9) [1,2,3] == ([1,2,3],[])
--   span (&lt; 0) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   <a>span</a> <tt>p xs</tt> is equivalent to <tt>(<a>takeWhile</a> p xs,
--   <a>dropWhile</a> p xs)</tt>
span :: () => (a -> Bool) -> [a] -> ([a], [a])

-- | <a>splitAt</a> <tt>n xs</tt> returns a tuple where first element is
--   <tt>xs</tt> prefix of length <tt>n</tt> and second element is the
--   remainder of the list:
--   
--   <pre>
--   splitAt 6 "Hello World!" == ("Hello ","World!")
--   splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
--   splitAt 1 [1,2,3] == ([1],[2,3])
--   splitAt 3 [1,2,3] == ([1,2,3],[])
--   splitAt 4 [1,2,3] == ([1,2,3],[])
--   splitAt 0 [1,2,3] == ([],[1,2,3])
--   splitAt (-1) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   It is equivalent to <tt>(<a>take</a> n xs, <a>drop</a> n xs)</tt> when
--   <tt>n</tt> is not <tt>_|_</tt> (<tt>splitAt _|_ xs = _|_</tt>).
--   <a>splitAt</a> is an instance of the more general
--   <a>genericSplitAt</a>, in which <tt>n</tt> may be of any integral
--   type.
splitAt :: () => Int -> [a] -> ([a], [a])

-- | <a>drop</a> <tt>n xs</tt> returns the suffix of <tt>xs</tt> after the
--   first <tt>n</tt> elements, or <tt>[]</tt> if <tt>n &gt; <a>length</a>
--   xs</tt>:
--   
--   <pre>
--   drop 6 "Hello World!" == "World!"
--   drop 3 [1,2,3,4,5] == [4,5]
--   drop 3 [1,2] == []
--   drop 3 [] == []
--   drop (-1) [1,2] == [1,2]
--   drop 0 [1,2] == [1,2]
--   </pre>
--   
--   It is an instance of the more general <a>genericDrop</a>, in which
--   <tt>n</tt> may be of any integral type.
drop :: () => Int -> [a] -> [a]

-- | <a>take</a> <tt>n</tt>, applied to a list <tt>xs</tt>, returns the
--   prefix of <tt>xs</tt> of length <tt>n</tt>, or <tt>xs</tt> itself if
--   <tt>n &gt; <a>length</a> xs</tt>:
--   
--   <pre>
--   take 5 "Hello World!" == "Hello"
--   take 3 [1,2,3,4,5] == [1,2,3]
--   take 3 [1,2] == [1,2]
--   take 3 [] == []
--   take (-1) [1,2] == []
--   take 0 [1,2] == []
--   </pre>
--   
--   It is an instance of the more general <a>genericTake</a>, in which
--   <tt>n</tt> may be of any integral type.
take :: () => Int -> [a] -> [a]

-- | <a>dropWhile</a> <tt>p xs</tt> returns the suffix remaining after
--   <a>takeWhile</a> <tt>p xs</tt>:
--   
--   <pre>
--   dropWhile (&lt; 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
--   dropWhile (&lt; 9) [1,2,3] == []
--   dropWhile (&lt; 0) [1,2,3] == [1,2,3]
--   </pre>
dropWhile :: () => (a -> Bool) -> [a] -> [a]

-- | <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a list
--   <tt>xs</tt>, returns the longest prefix (possibly empty) of
--   <tt>xs</tt> of elements that satisfy <tt>p</tt>:
--   
--   <pre>
--   takeWhile (&lt; 3) [1,2,3,4,1,2,3,4] == [1,2]
--   takeWhile (&lt; 9) [1,2,3] == [1,2,3]
--   takeWhile (&lt; 0) [1,2,3] == []
--   </pre>
takeWhile :: () => (a -> Bool) -> [a] -> [a]

-- | <a>cycle</a> ties a finite list into a circular one, or equivalently,
--   the infinite repetition of the original list. It is the identity on
--   infinite lists.
cycle :: () => [a] -> [a]

-- | <a>replicate</a> <tt>n x</tt> is a list of length <tt>n</tt> with
--   <tt>x</tt> the value of every element. It is an instance of the more
--   general <a>genericReplicate</a>, in which <tt>n</tt> may be of any
--   integral type.
replicate :: () => Int -> a -> [a]

-- | <a>repeat</a> <tt>x</tt> is an infinite list, with <tt>x</tt> the
--   value of every element.
repeat :: () => a -> [a]

-- | 'iterate\'' is the strict version of <a>iterate</a>.
--   
--   It ensures that the result of each application of force to weak head
--   normal form before proceeding.
iterate' :: () => (a -> a) -> a -> [a]

-- | <a>iterate</a> <tt>f x</tt> returns an infinite list of repeated
--   applications of <tt>f</tt> to <tt>x</tt>:
--   
--   <pre>
--   iterate f x == [x, f x, f (f x), ...]
--   </pre>
--   
--   Note that <a>iterate</a> is lazy, potentially leading to thunk
--   build-up if the consumer doesn't force each iterate. See 'iterate\''
--   for a strict variant of this function.
iterate :: () => (a -> a) -> a -> [a]

-- | <a>scanr1</a> is a variant of <a>scanr</a> that has no starting value
--   argument.
scanr1 :: () => (a -> a -> a) -> [a] -> [a]

-- | <a>scanr</a> is the right-to-left dual of <a>scanl</a>. Note that
--   
--   <pre>
--   head (scanr f z xs) == foldr f z xs.
--   </pre>
scanr :: () => (a -> b -> b) -> b -> [a] -> [b]

-- | A strictly accumulating version of <a>scanl</a>
scanl' :: () => (b -> a -> b) -> b -> [a] -> [b]

-- | <a>scanl1</a> is a variant of <a>scanl</a> that has no starting value
--   argument:
--   
--   <pre>
--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--   </pre>
scanl1 :: () => (a -> a -> a) -> [a] -> [a]

-- | <a>scanl</a> is similar to <a>foldl</a>, but returns a list of
--   successive reduced values from the left:
--   
--   <pre>
--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--   </pre>
--   
--   Note that
--   
--   <pre>
--   last (scanl f z xs) == foldl f z xs.
--   </pre>
scanl :: () => (b -> a -> b) -> b -> [a] -> [b]

-- | A strict version of <a>foldl1</a>
foldl1' :: () => (a -> a -> a) -> [a] -> a

-- | Return all the elements of a list except the last one. The list must
--   be non-empty.
init :: () => [a] -> [a]

-- | Extract the last element of a list, which must be finite and
--   non-empty.
last :: () => [a] -> a

-- | Extract the elements after the head of a list, which must be
--   non-empty.
tail :: () => [a] -> [a]

-- | Decompose a list into its head and tail. If the list is empty, returns
--   <a>Nothing</a>. If the list is non-empty, returns <tt><a>Just</a> (x,
--   xs)</tt>, where <tt>x</tt> is the head of the list and <tt>xs</tt> its
--   tail.
uncons :: () => [a] -> Maybe (a, [a])

-- | Extract the first element of a list, which must be non-empty.
head :: () => [a] -> a

-- | The <a>mapMaybe</a> function is a version of <a>map</a> which can
--   throw out elements. In particular, the functional argument returns
--   something of type <tt><a>Maybe</a> b</tt>. If this is <a>Nothing</a>,
--   no element is added on to the result list. If it is <tt><a>Just</a>
--   b</tt>, then <tt>b</tt> is included in the result list.
--   
--   <h4><b>Examples</b></h4>
--   
--   Using <tt><a>mapMaybe</a> f x</tt> is a shortcut for
--   <tt><a>catMaybes</a> $ <a>map</a> f x</tt> in most cases:
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; let readMaybeInt = readMaybe :: String -&gt; Maybe Int
--   
--   &gt;&gt;&gt; mapMaybe readMaybeInt ["1", "Foo", "3"]
--   [1,3]
--   
--   &gt;&gt;&gt; catMaybes $ map readMaybeInt ["1", "Foo", "3"]
--   [1,3]
--   </pre>
--   
--   If we map the <a>Just</a> constructor, the entire list should be
--   returned:
--   
--   <pre>
--   &gt;&gt;&gt; mapMaybe Just [1,2,3]
--   [1,2,3]
--   </pre>
mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]

-- | The <a>catMaybes</a> function takes a list of <a>Maybe</a>s and
--   returns a list of all the <a>Just</a> values.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; catMaybes [Just 1, Nothing, Just 3]
--   [1,3]
--   </pre>
--   
--   When constructing a list of <a>Maybe</a> values, <a>catMaybes</a> can
--   be used to return all of the "success" results (if the list is the
--   result of a <a>map</a>, then <a>mapMaybe</a> would be more
--   appropriate):
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; [readMaybe x :: Maybe Int | x &lt;- ["1", "Foo", "3"] ]
--   [Just 1,Nothing,Just 3]
--   
--   &gt;&gt;&gt; catMaybes $ [readMaybe x :: Maybe Int | x &lt;- ["1", "Foo", "3"] ]
--   [1,3]
--   </pre>
catMaybes :: () => [Maybe a] -> [a]

-- | The <a>listToMaybe</a> function returns <a>Nothing</a> on an empty
--   list or <tt><a>Just</a> a</tt> where <tt>a</tt> is the first element
--   of the list.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; listToMaybe []
--   Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listToMaybe [9]
--   Just 9
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listToMaybe [1,2,3]
--   Just 1
--   </pre>
--   
--   Composing <a>maybeToList</a> with <a>listToMaybe</a> should be the
--   identity on singleton/empty lists:
--   
--   <pre>
--   &gt;&gt;&gt; maybeToList $ listToMaybe [5]
--   [5]
--   
--   &gt;&gt;&gt; maybeToList $ listToMaybe []
--   []
--   </pre>
--   
--   But not on lists with more than one element:
--   
--   <pre>
--   &gt;&gt;&gt; maybeToList $ listToMaybe [1,2,3]
--   [1]
--   </pre>
listToMaybe :: () => [a] -> Maybe a

-- | The <a>maybeToList</a> function returns an empty list when given
--   <a>Nothing</a> or a singleton list when not given <a>Nothing</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; maybeToList (Just 7)
--   [7]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; maybeToList Nothing
--   []
--   </pre>
--   
--   One can use <a>maybeToList</a> to avoid pattern matching when combined
--   with a function that (safely) works on lists:
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; sum $ maybeToList (readMaybe "3")
--   3
--   
--   &gt;&gt;&gt; sum $ maybeToList (readMaybe "")
--   0
--   </pre>
maybeToList :: () => Maybe a -> [a]

-- | The <a>fromMaybe</a> function takes a default value and and
--   <a>Maybe</a> value. If the <a>Maybe</a> is <a>Nothing</a>, it returns
--   the default values; otherwise, it returns the value contained in the
--   <a>Maybe</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; fromMaybe "" (Just "Hello, World!")
--   "Hello, World!"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fromMaybe "" Nothing
--   ""
--   </pre>
--   
--   Read an integer from a string using <tt>readMaybe</tt>. If we fail to
--   parse an integer, we want to return <tt>0</tt> by default:
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; fromMaybe 0 (readMaybe "5")
--   5
--   
--   &gt;&gt;&gt; fromMaybe 0 (readMaybe "")
--   0
--   </pre>
fromMaybe :: () => a -> Maybe a -> a

-- | The <a>fromJust</a> function extracts the element out of a <a>Just</a>
--   and throws an error if its argument is <a>Nothing</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; fromJust (Just 1)
--   1
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 2 * (fromJust (Just 10))
--   20
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 2 * (fromJust Nothing)
--   *** Exception: Maybe.fromJust: Nothing
--   </pre>
fromJust :: () => Maybe a -> a

-- | The <a>isNothing</a> function returns <a>True</a> iff its argument is
--   <a>Nothing</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; isNothing (Just 3)
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; isNothing (Just ())
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; isNothing Nothing
--   True
--   </pre>
--   
--   Only the outer constructor is taken into consideration:
--   
--   <pre>
--   &gt;&gt;&gt; isNothing (Just Nothing)
--   False
--   </pre>
isNothing :: () => Maybe a -> Bool

-- | The <a>isJust</a> function returns <a>True</a> iff its argument is of
--   the form <tt>Just _</tt>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; isJust (Just 3)
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; isJust (Just ())
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; isJust Nothing
--   False
--   </pre>
--   
--   Only the outer constructor is taken into consideration:
--   
--   <pre>
--   &gt;&gt;&gt; isJust (Just Nothing)
--   True
--   </pre>
isJust :: () => Maybe a -> Bool

-- | The <a>maybe</a> function takes a default value, a function, and a
--   <a>Maybe</a> value. If the <a>Maybe</a> value is <a>Nothing</a>, the
--   function returns the default value. Otherwise, it applies the function
--   to the value inside the <a>Just</a> and returns the result.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; maybe False odd (Just 3)
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; maybe False odd Nothing
--   False
--   </pre>
--   
--   Read an integer from a string using <tt>readMaybe</tt>. If we succeed,
--   return twice the integer; that is, apply <tt>(*2)</tt> to it. If
--   instead we fail to parse an integer, return <tt>0</tt> by default:
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; maybe 0 (*2) (readMaybe "5")
--   10
--   
--   &gt;&gt;&gt; maybe 0 (*2) (readMaybe "")
--   0
--   </pre>
--   
--   Apply <tt>show</tt> to a <tt>Maybe Int</tt>. If we have <tt>Just
--   n</tt>, we want to show the underlying <a>Int</a> <tt>n</tt>. But if
--   we have <a>Nothing</a>, we return the empty string instead of (for
--   example) "Nothing":
--   
--   <pre>
--   &gt;&gt;&gt; maybe "" show (Just 5)
--   "5"
--   
--   &gt;&gt;&gt; maybe "" show Nothing
--   ""
--   </pre>
maybe :: () => b -> (a -> b) -> Maybe a -> b

-- | In many situations, the <a>liftM</a> operations can be replaced by
--   uses of <a>ap</a>, which promotes function application.
--   
--   <pre>
--   return f `ap` x1 `ap` ... `ap` xn
--   </pre>
--   
--   is equivalent to
--   
--   <pre>
--   liftMn f x1 x2 ... xn
--   </pre>
ap :: Monad m => m (a -> b) -> m a -> m b

-- | Promote a function to a monad, scanning the monadic arguments from
--   left to right (cf. <a>liftM2</a>).
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r

-- | Promote a function to a monad, scanning the monadic arguments from
--   left to right (cf. <a>liftM2</a>).
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r

-- | Promote a function to a monad, scanning the monadic arguments from
--   left to right (cf. <a>liftM2</a>).
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r

-- | Promote a function to a monad, scanning the monadic arguments from
--   left to right. For example,
--   
--   <pre>
--   liftM2 (+) [0,1] [0,2] = [0,2,1,3]
--   liftM2 (+) (Just 1) Nothing = Nothing
--   </pre>
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r

-- | Conditional execution of <a>Applicative</a> expressions. For example,
--   
--   <pre>
--   when debug (putStrLn "Debugging")
--   </pre>
--   
--   will output the string <tt>Debugging</tt> if the Boolean value
--   <tt>debug</tt> is <a>True</a>, and otherwise do nothing.
when :: Applicative f => Bool -> f () -> f ()

-- | Same as <a>&gt;&gt;=</a>, but with the arguments interchanged.
(=<<) :: Monad m => (a -> m b) -> m a -> m b
infixr 1 =<<

-- | Lift a ternary function to actions.
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

-- | Lift a function to actions. This function may be used as a value for
--   <a>fmap</a> in a <a>Functor</a> instance.
liftA :: Applicative f => (a -> b) -> f a -> f b

-- | A variant of <a>&lt;*&gt;</a> with the arguments reversed.
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
infixl 4 <**>

-- | The reader monad transformer, which adds a read-only environment to
--   the given monad.
--   
--   The <a>return</a> function ignores the environment, while
--   <tt>&gt;&gt;=</tt> passes the inherited environment to both
--   subcomputations.
data ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type

-- | Combine two paths with a path separator. If the second path starts
--   with a path separator or a drive letter, then it returns the second.
--   The intention is that <tt>readFile (dir <a>&lt;/&gt;</a> file)</tt>
--   will access the same file as <tt>setCurrentDirectory dir; readFile
--   file</tt>.
--   
--   <pre>
--   Posix:   "/directory" &lt;/&gt; "file.ext" == "/directory/file.ext"
--   Windows: "/directory" &lt;/&gt; "file.ext" == "/directory\\file.ext"
--            "directory" &lt;/&gt; "/file.ext" == "/file.ext"
--   Valid x =&gt; (takeDirectory x &lt;/&gt; takeFileName x) `equalFilePath` x
--   </pre>
--   
--   Combined:
--   
--   <pre>
--   Posix:   "/" &lt;/&gt; "test" == "/test"
--   Posix:   "home" &lt;/&gt; "bob" == "home/bob"
--   Posix:   "x:" &lt;/&gt; "foo" == "x:/foo"
--   Windows: "C:\\foo" &lt;/&gt; "bar" == "C:\\foo\\bar"
--   Windows: "home" &lt;/&gt; "bob" == "home\\bob"
--   </pre>
--   
--   Not combined:
--   
--   <pre>
--   Posix:   "home" &lt;/&gt; "/bob" == "/bob"
--   Windows: "home" &lt;/&gt; "C:\\bob" == "C:\\bob"
--   </pre>
--   
--   Not combined (tricky):
--   
--   On Windows, if a filepath starts with a single slash, it is relative
--   to the root of the current drive. In [1], this is (confusingly)
--   referred to as an absolute path. The current behavior of
--   <a>&lt;/&gt;</a> is to never combine these forms.
--   
--   <pre>
--   Windows: "home" &lt;/&gt; "/bob" == "/bob"
--   Windows: "home" &lt;/&gt; "\\bob" == "\\bob"
--   Windows: "C:\\home" &lt;/&gt; "\\bob" == "\\bob"
--   </pre>
--   
--   On Windows, from [1]: "If a file name begins with only a disk
--   designator but not the backslash after the colon, it is interpreted as
--   a relative path to the current directory on the drive with the
--   specified letter." The current behavior of <a>&lt;/&gt;</a> is to
--   never combine these forms.
--   
--   <pre>
--   Windows: "D:\\foo" &lt;/&gt; "C:bar" == "C:bar"
--   Windows: "C:\\foo" &lt;/&gt; "C:bar" == "C:bar"
--   </pre>
(</>) :: FilePath -> FilePath -> FilePath
infixr 5 </>

-- | Get the directory name, move up one level.
--   
--   <pre>
--             takeDirectory "/directory/other.ext" == "/directory"
--             takeDirectory x `isPrefixOf` x || takeDirectory x == "."
--             takeDirectory "foo" == "."
--             takeDirectory "/" == "/"
--             takeDirectory "/foo" == "/"
--             takeDirectory "/foo/bar/baz" == "/foo/bar"
--             takeDirectory "/foo/bar/baz/" == "/foo/bar/baz"
--             takeDirectory "foo/bar/baz" == "foo/bar"
--   Windows:  takeDirectory "foo\\bar" == "foo"
--   Windows:  takeDirectory "foo\\bar\\\\" == "foo\\bar"
--   Windows:  takeDirectory "C:\\" == "C:\\"
--   </pre>
takeDirectory :: FilePath -> FilePath

-- | Get the file name.
--   
--   <pre>
--   takeFileName "/directory/file.ext" == "file.ext"
--   takeFileName "test/" == ""
--   takeFileName x `isSuffixOf` x
--   takeFileName x == snd (splitFileName x)
--   Valid x =&gt; takeFileName (replaceFileName x "fred") == "fred"
--   Valid x =&gt; takeFileName (x &lt;/&gt; "fred") == "fred"
--   Valid x =&gt; isRelative (takeFileName x)
--   </pre>
takeFileName :: FilePath -> FilePath

-- | Add an extension, even if there is already one there, equivalent to
--   <a>addExtension</a>.
--   
--   <pre>
--   "/directory/path" &lt;.&gt; "ext" == "/directory/path.ext"
--   "/directory/path" &lt;.&gt; ".ext" == "/directory/path.ext"
--   </pre>
(<.>) :: FilePath -> String -> FilePath
infixr 7 <.>

-- | Set the extension of a file, overwriting one if already present,
--   equivalent to <a>-&lt;.&gt;</a>.
--   
--   <pre>
--   replaceExtension "/directory/path.txt" "ext" == "/directory/path.ext"
--   replaceExtension "/directory/path.txt" ".ext" == "/directory/path.ext"
--   replaceExtension "file.txt" ".bob" == "file.bob"
--   replaceExtension "file.txt" "bob" == "file.bob"
--   replaceExtension "file" ".bob" == "file.bob"
--   replaceExtension "file.txt" "" == "file"
--   replaceExtension "file.fred.bob" "txt" == "file.fred.txt"
--   replaceExtension x y == addExtension (dropExtension x) y
--   </pre>
replaceExtension :: FilePath -> String -> FilePath

-- | View the value pointed to by a <a>Getter</a> or <a>Lens</a> or the
--   result of folding over all the results of a <a>Fold</a> or
--   <a>Traversal</a> that points at a monoidal values.
--   
--   This is the same operation as <a>view</a> with the arguments flipped.
--   
--   The fixity and semantics are such that subsequent field accesses can
--   be performed with (<a>.</a>).
--   
--   <pre>
--   &gt;&gt;&gt; (a,b)^._2
--   b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ("hello","world")^._2
--   "world"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Complex
--   
--   &gt;&gt;&gt; ((0, 1 :+ 2), 3)^._1._2.to magnitude
--   2.23606797749979
--   </pre>
--   
--   <pre>
--   (<a>^.</a>) ::             s -&gt; <a>Getter</a> s a     -&gt; a
--   (<a>^.</a>) :: <a>Monoid</a> m =&gt; s -&gt; <a>Fold</a> s m       -&gt; m
--   (<a>^.</a>) ::             s -&gt; <a>Iso'</a> s a       -&gt; a
--   (<a>^.</a>) ::             s -&gt; <a>Lens'</a> s a      -&gt; a
--   (<a>^.</a>) :: <a>Monoid</a> m =&gt; s -&gt; <a>Traversal'</a> s m -&gt; m
--   </pre>
(^.) :: () => s -> Getting a s a -> a
infixl 8 ^.

-- | Replace the target of a <a>Lens</a> or all of the targets of a
--   <a>Setter</a> or <a>Traversal</a> with a constant value.
--   
--   This is an infix version of <a>set</a>, provided for consistency with
--   (<a>.=</a>).
--   
--   <pre>
--   f <a>&lt;$</a> a ≡ <a>mapped</a> <a>.~</a> f <a>$</a> a
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; (a,b,c,d) &amp; _4 .~ e
--   (a,b,c,e)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; (42,"world") &amp; _1 .~ "hello"
--   ("hello","world")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; (a,b) &amp; both .~ c
--   (c,c)
--   </pre>
--   
--   <pre>
--   (<a>.~</a>) :: <a>Setter</a> s t a b    -&gt; b -&gt; s -&gt; t
--   (<a>.~</a>) :: <a>Iso</a> s t a b       -&gt; b -&gt; s -&gt; t
--   (<a>.~</a>) :: <a>Lens</a> s t a b      -&gt; b -&gt; s -&gt; t
--   (<a>.~</a>) :: <a>Traversal</a> s t a b -&gt; b -&gt; s -&gt; t
--   </pre>
(.~) :: () => ASetter s t a b -> b -> s -> t
infixr 4 .~

-- | Modifies the target of a <a>Lens</a> or all of the targets of a
--   <a>Setter</a> or <a>Traversal</a> with a user supplied function.
--   
--   This is an infix version of <a>over</a>.
--   
--   <pre>
--   <a>fmap</a> f ≡ <a>mapped</a> <a>%~</a> f
--   <a>fmapDefault</a> f ≡ <a>traverse</a> <a>%~</a> f
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; (a,b,c) &amp; _3 %~ f
--   (a,b,f c)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; (a,b) &amp; both %~ f
--   (f a,f b)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; _2 %~ length $ (1,"hello")
--   (1,5)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; traverse %~ f $ [a,b,c]
--   [f a,f b,f c]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; traverse %~ even $ [1,2,3]
--   [False,True,False]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; traverse.traverse %~ length $ [["hello","world"],["!!!"]]
--   [[5,5],[3]]
--   </pre>
--   
--   <pre>
--   (<a>%~</a>) :: <a>Setter</a> s t a b    -&gt; (a -&gt; b) -&gt; s -&gt; t
--   (<a>%~</a>) :: <a>Iso</a> s t a b       -&gt; (a -&gt; b) -&gt; s -&gt; t
--   (<a>%~</a>) :: <a>Lens</a> s t a b      -&gt; (a -&gt; b) -&gt; s -&gt; t
--   (<a>%~</a>) :: <a>Traversal</a> s t a b -&gt; (a -&gt; b) -&gt; s -&gt; t
--   </pre>
(%~) :: () => ASetter s t a b -> (a -> b) -> s -> t
infixr 4 %~

-- | A <a>Lens</a> is actually a lens family as described in
--   <a>http://comonad.com/reader/2012/mirrored-lenses/</a>.
--   
--   With great power comes great responsibility and a <a>Lens</a> is
--   subject to the three common sense <a>Lens</a> laws:
--   
--   1) You get back what you put in:
--   
--   <pre>
--   <a>view</a> l (<a>set</a> l v s)  ≡ v
--   </pre>
--   
--   2) Putting back what you got doesn't change anything:
--   
--   <pre>
--   <a>set</a> l (<a>view</a> l s) s  ≡ s
--   </pre>
--   
--   3) Setting twice is the same as setting once:
--   
--   <pre>
--   <a>set</a> l v' (<a>set</a> l v s) ≡ <a>set</a> l v' s
--   </pre>
--   
--   These laws are strong enough that the 4 type parameters of a
--   <a>Lens</a> cannot vary fully independently. For more on how they
--   interact, read the "Why is it a Lens Family?" section of
--   <a>http://comonad.com/reader/2012/mirrored-lenses/</a>.
--   
--   There are some emergent properties of these laws:
--   
--   1) <tt><a>set</a> l s</tt> must be injective for every <tt>s</tt> This
--   is a consequence of law #1
--   
--   2) <tt><a>set</a> l</tt> must be surjective, because of law #2, which
--   indicates that it is possible to obtain any <tt>v</tt> from some
--   <tt>s</tt> such that <tt><a>set</a> s v = s</tt>
--   
--   3) Given just the first two laws you can prove a weaker form of law #3
--   where the values <tt>v</tt> that you are setting match:
--   
--   <pre>
--   <a>set</a> l v (<a>set</a> l v s) ≡ <a>set</a> l v s
--   </pre>
--   
--   Every <a>Lens</a> can be used directly as a <a>Setter</a> or
--   <a>Traversal</a>.
--   
--   You can also use a <a>Lens</a> for <a>Getting</a> as if it were a
--   <a>Fold</a> or <a>Getter</a>.
--   
--   Since every <a>Lens</a> is a valid <a>Traversal</a>, the
--   <a>Traversal</a> laws are required of any <a>Lens</a> you create:
--   
--   <pre>
--   l <a>pure</a> ≡ <a>pure</a>
--   <a>fmap</a> (l f) <a>.</a> l g ≡ <a>getCompose</a> <a>.</a> l (<a>Compose</a> <a>.</a> <a>fmap</a> f <a>.</a> g)
--   </pre>
--   
--   <pre>
--   type <a>Lens</a> s t a b = forall f. <a>Functor</a> f =&gt; <a>LensLike</a> f s t a b
--   </pre>
type Lens s t a b = forall (f :: Type -> Type). Functor f => a -> f b -> s -> f t

-- | Convert a generic value into a pretty <a>Value</a>, if possible.
ppShow :: Show a => a -> String

-- | This is a simple runtime exception to indicate that B9 code
--   encountered some exceptional event.
newtype B9Error
MkB9Error :: String -> B9Error
[fromB9Error] :: B9Error -> String

-- | Constraint alias for the exception effect that allows to throw
--   <a>SomeException</a>.
type WithIoExceptions e = SetMember Exc (Exc SomeException) e

-- | The exception effect used in most places in B9. This is <a>Exc</a>
--   specialized with <a>SomeException</a>.
type ExcB9 = Exc SomeException

-- | Run an <a>ExcB9</a>.
runExcB9 :: Eff (ExcB9 : e) a -> Eff e (Either SomeException a)

-- | Run an <a>ExcB9</a> and rethrow the exception with <a>error</a>.
errorOnException :: Lifted IO e => Eff (ExcB9 : e) a -> Eff e a

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwSomeException :: (Member ExcB9 e, Exception x) => x -> Eff e a

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwSomeException_ :: (Member ExcB9 e, Exception x) => x -> Eff e ()

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwB9Error :: Member ExcB9 e => String -> Eff e a

-- | <a>SomeException</a> wrapped into <a>Exc</a>ecption <a>Eff</a>ects
throwB9Error_ :: Member ExcB9 e => String -> Eff e ()

-- | Catch exceptions.
catchB9Error :: Member ExcB9 e => Eff e a -> (SomeException -> Eff e a) -> Eff e a

-- | Catch exceptions and return them via <a>Either</a>.
catchB9ErrorAsEither :: Member ExcB9 e => Eff e a -> Eff e (Either SomeException a)

-- | Always execute an action and rethrow any exceptions caught.
finallyB9 :: Member ExcB9 e => Eff e a -> Eff e () -> Eff e a
arbitraryEnv :: Arbitrary a => Gen [(String, a)]
halfSize :: Gen a -> Gen a
smaller :: Gen a -> Gen a
arbitraryFilePath :: Gen FilePath
arbitraryLetter :: Gen Char
arbitraryLetterUpper :: Gen Char
arbitraryLetterLower :: Gen Char
arbitraryDigit :: Gen Char

-- | Every B9 build running in a <tt>B9Monad</tt> contains a random unique
--   id that is generated once per build (no matter how many artifacts are
--   created in that build) This field contains the build id of the build
--   that created the shared image instance. This is A wrapper around a
--   string contains the build id of a <a>SharedImage</a>; this is purely
--   additional convenience and typesafety
newtype SharedImageBuildId
SharedImageBuildId :: String -> SharedImageBuildId

-- | The exact time that build job <b>started</b>. This is a wrapper around
--   a string contains the build date of a <a>SharedImage</a>; this is
--   purely additional convenience and typesafety
newtype SharedImageDate
SharedImageDate :: String -> SharedImageDate

-- | The name of the image is the de-facto identifier for push, pull,
--   <a>From</a> and <a>Share</a>. B9 always selects the newest version the
--   shared image identified by that name when using a shared image as an
--   <a>ImageSource</a>. This is a wrapper around a string that identifies
--   a <a>SharedImage</a>
newtype SharedImageName
SharedImageName :: String -> SharedImageName

-- | <a>SharedImage</a> holds all data necessary to describe an
--   <b>instance</b> of a shared image identified by a
--   <a>SharedImageName</a>. Shared images are stored in
--   <a>Repository</a>s.
data SharedImage
SharedImage :: SharedImageName -> SharedImageDate -> SharedImageBuildId -> ImageType -> FileSystem -> SharedImage

-- | A type alias that indicates that something of type <tt>a</tt> is mount
--   at a <a>MountPoint</a>
type Mounted a = (a, MountPoint)

-- | How to resize an image file.
data ImageResize

-- | Resize the image <b>but not the file system</b>. Note that a file
--   system contained in the image file might be corrupted by this
--   operation. To not only resize the image file but also the fil system
--   contained in it, use <a>Resize</a>.
ResizeImage :: ImageSize -> ImageResize

-- | Resize an image and the contained file system.
Resize :: ImageSize -> ImageResize

-- | Shrink to minimum size needed and increase by the amount given.
ShrinkToMinimumAndIncrease :: ImageSize -> ImageResize

-- | Resize an image and the contained file system to the smallest size to
--   fit the contents of the file system.
ShrinkToMinimum :: ImageResize

-- | Do not change the image size.
KeepSize :: ImageResize

-- | Enumeration of size multipliers. The exact semantics may vary
--   depending on what external tools look at these. E.g. the size unit is
--   convert to a size parameter of the <tt>qemu-img</tt> command line
--   tool.
data SizeUnit
KB :: SizeUnit
MB :: SizeUnit
GB :: SizeUnit

-- | A data type for image file or file system size; instead of passing
--   <a>Int</a>s around this also captures a size unit so that the
--   <a>Int</a> can be kept small
data ImageSize
ImageSize :: Int -> SizeUnit -> ImageSize

-- | The file systems that b9 can use and convert.
data FileSystem
NoFileSystem :: FileSystem
Ext4 :: FileSystem
Ext4_64 :: FileSystem
ISO9660 :: FileSystem
VFAT :: FileSystem

-- | An image type defines the actual <i>file format</i> of a file
--   containing file systems. These are like <i>virtual harddrives</i>
data ImageType
Raw :: ImageType
QCow2 :: ImageType
Vmdk :: ImageType

-- | A vm disk image file consisting of a path to the image file, and the
--   type and file system.
data Image
Image :: FilePath -> ImageType -> FileSystem -> Image

-- | The partition to extract.
data Partition

-- | There is no partition table on the image
NoPT :: Partition

-- | Extract partition <tt>n</tt> <tt>n</tt> must be in <tt>0..3</tt>
Partition :: Int -> Partition

-- | Specification of how the image to build is obtained.
data ImageSource

-- | Create an empty image file having a file system label (first
--   parameter), a file system type (e.g. <a>Ext4</a>) and an
--   <a>ImageSize</a>
EmptyImage :: String -> FileSystem -> ImageType -> ImageSize -> ImageSource

-- | <b>DEPRECATED</b>
CopyOnWrite :: Image -> ImageSource

-- | Clone an existing image file; if the image file contains partitions,
--   select the partition to use, b9 will extract that partition by reading
--   the offset of the partition from the partition table and extract it
--   using <tt>dd</tt>.
SourceImage :: Image -> Partition -> ImageResize -> ImageSource

-- | Use an image previously shared by via <a>Share</a>.
From :: String -> ImageResize -> ImageSource

-- | The destination of an image.
data ImageDestination

-- | Create the image and some meta data so that other builds can use them
--   as <a>ImageSource</a>s via <a>From</a>.
Share :: String -> ImageType -> ImageResize -> ImageDestination

-- | <b>DEPRECATED</b> Export a raw image that can directly be booted.
LiveInstallerImage :: String -> FilePath -> ImageResize -> ImageDestination

-- | Write an image file to the path in the first argument., possible
--   resizing it,
LocalFile :: Image -> ImageResize -> ImageDestination

-- | Do not export the image. Usefule if the main objective of the b9 build
--   is not an image file, but rather some artifact produced by executing
--   by a containerize build.
Transient :: ImageDestination

-- | A mount point or <a>NotMounted</a>
data MountPoint
MountPoint :: FilePath -> MountPoint
NotMounted :: MountPoint

-- | Build target for disk images; the destination, format and size of the
--   image to generate, as well as how to create or obtain the image before
--   a <a>VmScript</a> is executed with the image mounted at a
--   <a>MountPoint</a>.
data ImageTarget
ImageTarget :: ImageDestination -> ImageSource -> MountPoint -> ImageTarget

-- | Convert a size in bytes to an <a>ImageSize</a>
bytesToKiloBytes :: Int -> ImageSize

-- | Convert an <a>ImageSize</a> to kibi bytes.
imageSizeToKiB :: ImageSize -> Int

-- | Convert a <a>SizeUnit</a> to the number of kibi bytes one element
--   represents.
sizeUnitKiB :: SizeUnit -> Int

-- | Choose the greatest unit possible to exactly represent an
--   <a>ImageSize</a>.
normalizeSize :: ImageSize -> ImageSize

-- | Return the sum of two <tt><a>ImageSize</a>s</tt>.
addImageSize :: ImageSize -> ImageSize -> ImageSize

-- | Get the String representation of a <a>SharedImageName</a>.
fromSharedImageName :: SharedImageName -> String

-- | Get the String representation of a <a>SharedImageBuildId</a>.
fromSharedImageBuildId :: SharedImageBuildId -> String

-- | Transform a list of <a>SharedImage</a> values into a <a>Map</a> that
--   associates each <a>SharedImageName</a> with a <a>Set</a> of the actual
--   images with that name.
--   
--   The <a>Set</a> contains values of type <tt><a>SharedImage</a></tt>.
--   
--   The <a>Ord</a> instance of <a>SharedImage</a> sorts by name first and
--   then by <a>sharedImageDate</a>, since the values in a <a>Set</a> share
--   the same <a>sharedImageName</a>, they are effectively orderd by build
--   date, which is useful the shared image cleanup.
sharedImagesToMap :: [SharedImage] -> Map SharedImageName (Set SharedImage)

-- | Return the <a>SharedImage</a> with the highest <a>sharedImageDate</a>.
takeLatestSharedImage :: [SharedImage] -> Maybe SharedImage

-- | Return the name of the file corresponding to an <a>Image</a>
imageFileName :: Image -> FilePath

-- | Return the <a>ImageType</a> of an <a>Image</a>
imageImageType :: Image -> ImageType

-- | Return the files generated for a <a>LocalFile</a> or a
--   <a>LiveInstallerImage</a>; <a>SharedImage</a> and <a>Transient</a> are
--   treated like they have no output files because the output files are
--   manged by B9.
getImageDestinationOutputFiles :: ImageTarget -> [FilePath]

-- | Return the name of a shared image, if the <a>ImageDestination</a> is a
--   <a>Share</a> destination
imageDestinationSharedImageName :: ImageDestination -> Maybe SharedImageName

-- | Return the name of a shared source image, if the <a>ImageSource</a> is
--   a <a>From</a> source
imageSourceSharedImageName :: ImageSource -> Maybe SharedImageName

-- | Get the <a>ImageDestination</a> of an <a>ImageTarget</a>
itImageDestination :: ImageTarget -> ImageDestination

-- | Get the <a>ImageSource</a> of an <a>ImageTarget</a>
itImageSource :: ImageTarget -> ImageSource

-- | Get the <a>MountPoint</a> of an <a>ImageTarget</a>
itImageMountPoint :: ImageTarget -> MountPoint

-- | Return true if a <a>Partition</a> parameter is actually referring to a
--   partition, false if it is <a>NoPT</a>
isPartitioned :: Partition -> Bool

-- | Return the <a>Partition</a> index or throw a runtime error if applied
--   to <a>NoPT</a>
getPartition :: Partition -> Int

-- | Return the file name extension of an image file with a specific image
--   format.
imageFileExtension :: ImageType -> String

-- | Change the image file format and also rename the image file name to
--   have the appropriate file name extension. See
--   <a>imageFileExtension</a> and <a>replaceExtension</a>
changeImageFormat :: ImageType -> Image -> Image
changeImageDirectory :: FilePath -> Image -> Image
getImageSourceImageType :: ImageSource -> Maybe ImageType

-- | Return the name of a shared image.
sharedImageName :: SharedImage -> SharedImageName

-- | Return the build date of a shared image.
sharedImageDate :: SharedImage -> SharedImageDate

-- | Return the build id of a shared image.
sharedImageBuildId :: SharedImage -> SharedImageBuildId

-- | Print the contents of the shared image in one line
prettyPrintSharedImages :: Set SharedImage -> String

-- | Return the disk image of an sharedImage
sharedImageImage :: SharedImage -> Image

-- | Calculate the path to the text file holding the serialized
--   <a>SharedImage</a> relative to the directory of shared images in a
--   repository.
sharedImageFileName :: SharedImage -> FilePath
sharedImagesRootDirectory :: FilePath
sharedImageFileExtension :: String

-- | The internal image type to use as best guess when dealing with a
--   <a>From</a> value.
sharedImageDefaultImageType :: ImageType

-- | Use a <a>QCow2</a> image with an <a>Ext4</a> file system
transientCOWImage :: FilePath -> FilePath -> ImageTarget

-- | Use a shared image
transientSharedImage :: SharedImageName -> FilePath -> ImageTarget

-- | Use a shared image
transientLocalImage :: FilePath -> FilePath -> ImageTarget

-- | Share a <a>QCow2</a> image with <a>Ext4</a> fs
shareCOWImage :: FilePath -> SharedImageName -> FilePath -> ImageTarget

-- | Share an image based on a shared image
shareSharedImage :: SharedImageName -> SharedImageName -> FilePath -> ImageTarget

-- | Share a <a>QCow2</a> image with <a>Ext4</a> fs
shareLocalImage :: FilePath -> SharedImageName -> FilePath -> ImageTarget

-- | Export a <a>QCow2</a> image with <a>Ext4</a> fs
cowToliveInstallerImage :: String -> FilePath -> FilePath -> FilePath -> ImageTarget

-- | Export a <a>QCow2</a> image file with <a>Ext4</a> fs as a local file
cowToLocalImage :: FilePath -> FilePath -> FilePath -> ImageTarget

-- | Export a <a>QCow2</a> image file with <a>Ext4</a> fs as a local file
localToLocalImage :: FilePath -> FilePath -> FilePath -> ImageTarget

-- | Create a local image file from the contents of the first partition of
--   a local <a>QCow2</a> image.
partition1ToLocalImage :: FilePath -> FilePath -> FilePath -> ImageTarget

-- | Split any image target into two image targets, one for creating an
--   intermediate shared image and one from the intermediate shared image
--   to the output image.
splitToIntermediateSharedImage :: ImageTarget -> SharedImageName -> (ImageTarget, ImageTarget)
arbitrarySharedImageName :: Gen String
unitTests :: Spec
data RamSize
RamSize :: Int -> SizeUnit -> RamSize
AutomaticRamSize :: RamSize
data CPUArch
X86_64 :: CPUArch
I386 :: CPUArch
data Resources
Resources :: RamSize -> Int -> CPUArch -> Resources
[maxMemory] :: Resources -> RamSize
[cpuCount] :: Resources -> Int
[cpuArch] :: Resources -> CPUArch
data SharedDirectory
SharedDirectory :: FilePath -> MountPoint -> SharedDirectory
SharedDirectoryRO :: FilePath -> MountPoint -> SharedDirectory
SharedSources :: MountPoint -> SharedDirectory

-- | The environment for the execution of <tt>Script</tt>s inside a
--   <tt>Container</tt>
data ExecEnv
ExecEnv :: String -> [Mounted Image] -> [SharedDirectory] -> Resources -> ExecEnv
[envName] :: ExecEnv -> String
[envImageMounts] :: ExecEnv -> [Mounted Image]
[envSharedDirectories] :: ExecEnv -> [SharedDirectory]
[envResources] :: ExecEnv -> Resources
noResources :: Resources
data User
User :: String -> User
NoUser :: User
data Cwd
Cwd :: FilePath -> Cwd
NoCwd :: Cwd
data CmdVerbosity
Debug :: CmdVerbosity
Verbose :: CmdVerbosity
OnlyStdErr :: CmdVerbosity
Quiet :: CmdVerbosity
data Script
In :: FilePath -> [Script] -> Script
As :: String -> [Script] -> Script
IgnoreErrors :: Bool -> [Script] -> Script
Verbosity :: CmdVerbosity -> [Script] -> Script
Begin :: [Script] -> Script
Run :: FilePath -> [String] -> Script
NoOP :: Script

-- | Convert <tt>script</tt> to bash-shell-script written to <tt>file</tt>
--   and make <tt>file</tt> executable.
writeSh :: FilePath -> Script -> IO ()

-- | Check if a script has the same effect as <a>NoOP</a>
emptyScript :: Script -> Bool
renderScript :: Script -> String

-- | A class for values that can be converted to/from <a>Text</a>.
class Textual a

-- | Convert a <a>String</a> to <a>Text</a> If an error occured, return
--   <a>Left</a> with the error message.
renderToText :: (Textual a, HasCallStack) => a -> Either String Text

-- | Convert a <a>Text</a> to <a>String</a>
parseFromText :: (Textual a, HasCallStack) => Text -> Either String a

-- | Lazy texts.
--   
--   A type alias to <a>Text</a> that can be used everywhere such that
--   references don't need to be qualified with the complete module name
--   everywere.
type LazyText = Text

-- | Lazy byte strings.
--   
--   A type alias to <a>ByteString</a> that can be used everywhere such
--   that references don't need to be qualified with the complete module
--   name everywere.
type LazyByteString = ByteString

-- | Render a <a>Text</a> to a file.
writeTextFile :: (HasCallStack, MonadIO m) => FilePath -> Text -> m ()

-- | Render a <a>Text</a> via <a>renderToText</a> and throw a runtime
--   exception when rendering fails.
unsafeRenderToText :: (Textual a, HasCallStack) => a -> Text

-- | Parse a <a>Text</a> via <a>parseFromText</a> and throw a runtime
--   exception when parsing fails.
unsafeParseFromText :: (Textual a, HasCallStack) => Text -> a

-- | Encode a <a>String</a> as UTF-8 encoded into a <a>LazyByteString</a>.
encodeAsUtf8LazyByteString :: HasCallStack => String -> LazyByteString

-- | Parse the given <a>Text</a>. -- Return <tt>Left errorMessage</tt> or
--   <tt>Right a</tt>.
parseFromTextWithErrorMessage :: (HasCallStack, Textual a) => String -> Text -> Either String a

-- | An <a>Exception</a> thrown by <a>lookupOrThrow</a> indicating that a
--   key does not exist.
--   
--   @Since 0.5.62
data KeyNotFound
MkKeyNotFound :: Text -> Environment -> KeyNotFound

-- | An <a>Exception</a> thrown by <a>addBinding</a> indicating that a key
--   already exists.
--   
--   @Since 0.5.62
data DuplicateKey
MkDuplicateKey :: Text -> Text -> Text -> DuplicateKey
[duplicateKey] :: DuplicateKey -> Text
[duplicateKeyOldValue] :: DuplicateKey -> Text
[duplicateKeyNewValue] :: DuplicateKey -> Text

-- | A monad transformer providing a <tt>MonadReader</tt> instance for
--   <a>Environment</a>
type EnvironmentReader = Reader Environment

-- | A map of textual keys to textual values.
data Environment

-- | If environment variables <tt>arg_1 .. arg_n</tt> are bound and a list
--   of <tt>k</tt> additional values are passed to this function, store
--   them with keys <tt>arg_(n+1) .. arg_(n+k)</tt>.
--   
--   Note that the Environment contains an index of the next position.
addPositionalArguments :: [Text] -> Environment -> Environment

-- | Convenient wrapper around <a>addPositionalArguments</a> and
--   <a>localEnvironment</a>.
addLocalPositionalArguments :: Member EnvironmentReader e => [String] -> Eff e a -> Eff e a

-- | Create an <a>Environment</a> from a list of pairs (<a>String</a>s).
--   Duplicated entries are ignored.
fromStringPairs :: [(String, String)] -> Environment

-- | Insert a key value binding to the <a>Environment</a>.
--   
--   Throw <a>DuplicateKey</a> if the key already exists, but the value is
--   not equal to the given value.
addBinding :: Member ExcB9 e => (Text, Text) -> Environment -> Eff e Environment

-- | Insert <a>String</a>s into the <a>Environment</a>, see
--   <a>addBinding</a>.
addStringBinding :: Member ExcB9 e => (String, String) -> Environment -> Eff e Environment

-- | Insert a value into an <a>Environment</a> like
--   <a>addStringBinding</a>, but add it to the environment of the given
--   effect, as in <a>localEnvironment</a>.
addLocalStringBinding :: (Member EnvironmentReader e, Member ExcB9 e) => (String, String) -> Eff e a -> Eff e a

-- | Run a <tt>ReaderT</tt> of <a>Environment</a>.
runEnvironmentReader :: Environment -> Eff (EnvironmentReader : e) a -> Eff e a

-- | Get the current <a>Environment</a>
askEnvironment :: Member EnvironmentReader e => Eff e Environment

-- | Run a computation with a modified <a>Environment</a>
localEnvironment :: Member EnvironmentReader e => (Environment -> Environment) -> Eff e a -> Eff e a

-- | Lookup a key for a value.
--   
--   <tt>throwM</tt> a <a>KeyNotFound</a> <a>Exception</a> if no value with
--   the given key exists in the <a>Environment</a>.
--   
--   @Since 0.5.62
lookupOrThrow :: '[ExcB9, EnvironmentReader] <:: e => Text -> Eff e Text

-- | Lookup a key for a value.
--   
--   Return <a>Either</a> <a>Left</a> <a>KeyNotFound</a>, if no value with
--   the given key exists in the <a>Environment</a>, or <a>Right</a> the
--   value.
--   
--   @Since 0.5.62
lookupEither :: Member EnvironmentReader e => Text -> Eff e (Either KeyNotFound Text)

-- | A predicate that is satisfied when a key exists in the environment.
hasKey :: Member EnvironmentReader e => Text -> Eff e Bool

-- | Simplified Erlang term representation.
data SimpleErlangTerm
ErlString :: String -> SimpleErlangTerm
ErlFloat :: Double -> SimpleErlangTerm
ErlNatural :: Integer -> SimpleErlangTerm
ErlAtom :: String -> SimpleErlangTerm
ErlChar :: Char -> SimpleErlangTerm
ErlBinary :: String -> SimpleErlangTerm
ErlList :: [SimpleErlangTerm] -> SimpleErlangTerm
ErlTuple :: [SimpleErlangTerm] -> SimpleErlangTerm

-- | Parse a subset of valid Erlang terms. It parses no maps and binaries
--   are restricted to either empty binaries or binaries with a string. The
--   input encoding must be restricted to ascii compatible 8-bit characters
--   (e.g. latin-1 or UTF8).
parseErlTerm :: String -> Text -> Either String SimpleErlangTerm

-- | Convert an abstract Erlang term to a pretty byte string preserving the
--   encoding.
renderErlTerm :: SimpleErlangTerm -> Text
erlTermParser :: Parser SimpleErlangTerm
arbitraryErlSimpleAtom :: Gen SimpleErlangTerm
arbitraryErlString :: Gen SimpleErlangTerm
arbitraryErlNumber :: Gen SimpleErlangTerm
arbitraryErlNatural :: Gen SimpleErlangTerm
arbitraryErlFloat :: Gen SimpleErlangTerm
arbitraryErlNameChar :: Gen Char

-- | A bunch of numbers, enough to make globally unique IDs. Create one of
--   these using <a>randomUUID</a>.
data UUID

-- | An <a>Exception</a> thrown by <a>consult</a> to indicate the file does
--   not contain a <a>read</a>able String
data ConsultException
ConsultException :: FilePath -> String -> ConsultException

-- | A data type encapsulating different kinds of relative or absolute
--   paths.
data SystemPath

-- | A path that will just be passed through
Path :: FilePath -> SystemPath

-- | A OS specific path relative to the home directory of a user.
InHomeDir :: FilePath -> SystemPath

-- | A path relative to the <tt>b9</tt> sub of the users application
--   configuration directory <a>getAppUserDataDirectory</a>
InB9UserDir :: FilePath -> SystemPath

-- | A path relative to the systems temporary directory.
InTempDir :: FilePath -> SystemPath

-- | Transform a <a>SystemPath</a>
overSystemPath :: (FilePath -> FilePath) -> SystemPath -> SystemPath

-- | Convert a <a>SystemPath</a> to a <a>FilePath</a>.
resolve :: MonadIO m => SystemPath -> m FilePath

-- | Get all files from <tt>dir</tt> that is get ONLY files not directories
getDirectoryFiles :: MonadIO m => FilePath -> m [FilePath]

-- | Create all missing parent directories of a file path.
ensureSystemPath :: MonadIO m => SystemPath -> m ()

-- | Create all missing parent directories of a file path. Note that the
--   file path is assumed to be of a regular file, and <a>takeDirectory</a>
--   is applied before creating the directory.
ensureDir :: MonadIO m => FilePath -> m ()

-- | Write a value of a type that is an instance of <a>Show</a> to file.
--   This function uses <a>ppShow</a> instead of the given <a>Show</a>
--   instance.
prettyPrintToFile :: (MonadIO m, Show a) => FilePath -> a -> m ()

-- | Read a value of a type that is an instance of <a>Read</a> from a file.
--   This function throws a <a>ConsultException</a> when the read the file
--   failed.
consult :: (MonadIO m, Read a) => FilePath -> m a

-- | Generate a random <a>UUID</a>.
randomUUID :: MonadIO m => m UUID
removeIfExists :: FilePath -> IO ()
newtype SshRemoteUser
SshRemoteUser :: String -> SshRemoteUser
newtype SshRemoteHost
SshRemoteHost :: (String, Int) -> SshRemoteHost
newtype SshPrivKey
SshPrivKey :: FilePath -> SshPrivKey
data RemoteRepo
RemoteRepo :: String -> FilePath -> SshPrivKey -> SshRemoteHost -> SshRemoteUser -> RemoteRepo
newtype RepoCache
RepoCache :: FilePath -> RepoCache
remoteRepoRepoId :: RemoteRepo -> String

-- | Persist a repo to a configuration file.
remoteRepoToCPDocument :: RemoteRepo -> CPDocument -> Either CPError CPDocument

-- | Load a repository from a configuration file that has been written by
--   <tt>writeRepositoryToB9Config</tt>.
parseRemoteRepos :: CPDocument -> Either CPError [RemoteRepo]

-- | Available capabilities for Linux containers. This maps directly to the
--   capabilities defined in 'man 7 capabilities'.
data ContainerCapability
CAP_MKNOD :: ContainerCapability
CAP_AUDIT_CONTROL :: ContainerCapability
CAP_AUDIT_READ :: ContainerCapability
CAP_AUDIT_WRITE :: ContainerCapability
CAP_BLOCK_SUSPEND :: ContainerCapability
CAP_CHOWN :: ContainerCapability
CAP_DAC_OVERRIDE :: ContainerCapability
CAP_DAC_READ_SEARCH :: ContainerCapability
CAP_FOWNER :: ContainerCapability
CAP_FSETID :: ContainerCapability
CAP_IPC_LOCK :: ContainerCapability
CAP_IPC_OWNER :: ContainerCapability
CAP_KILL :: ContainerCapability
CAP_LEASE :: ContainerCapability
CAP_LINUX_IMMUTABLE :: ContainerCapability
CAP_MAC_ADMIN :: ContainerCapability
CAP_MAC_OVERRIDE :: ContainerCapability
CAP_NET_ADMIN :: ContainerCapability
CAP_NET_BIND_SERVICE :: ContainerCapability
CAP_NET_BROADCAST :: ContainerCapability
CAP_NET_RAW :: ContainerCapability
CAP_SETGID :: ContainerCapability
CAP_SETFCAP :: ContainerCapability
CAP_SETPCAP :: ContainerCapability
CAP_SETUID :: ContainerCapability
CAP_SYS_ADMIN :: ContainerCapability
CAP_SYS_BOOT :: ContainerCapability
CAP_SYS_CHROOT :: ContainerCapability
CAP_SYS_MODULE :: ContainerCapability
CAP_SYS_NICE :: ContainerCapability
CAP_SYS_PACCT :: ContainerCapability
CAP_SYS_PTRACE :: ContainerCapability
CAP_SYS_RAWIO :: ContainerCapability
CAP_SYS_RESOURCE :: ContainerCapability
CAP_SYS_TIME :: ContainerCapability
CAP_SYS_TTY_CONFIG :: ContainerCapability
CAP_SYSLOG :: ContainerCapability
CAP_WAKE_ALARM :: ContainerCapability
containerCapsToCPDocument :: CPDocument -> CPSectionSpec -> [ContainerCapability] -> Either CPError CPDocument
parseContainerCapabilities :: CPDocument -> CPSectionSpec -> Either CPError [ContainerCapability]
data SystemdNspawnConsole
SystemdNspawnInteractive :: SystemdNspawnConsole
SystemdNspawnReadOnly :: SystemdNspawnConsole
SystemdNspawnPassive :: SystemdNspawnConsole
SystemdNspawnPipe :: SystemdNspawnConsole
data SystemdNspawnConfig
SystemdNspawnConfig :: [ContainerCapability] -> Bool -> Maybe Int -> Maybe String -> Maybe FilePath -> SystemdNspawnConsole -> SystemdNspawnConfig
[_systemdNspawnCapabilities] :: SystemdNspawnConfig -> [ContainerCapability]
[_systemdNspawnUseSudo] :: SystemdNspawnConfig -> Bool
[_systemdNspawnMaxLifetimeSeconds] :: SystemdNspawnConfig -> Maybe Int
[_systemdNspawnExtraArgs] :: SystemdNspawnConfig -> Maybe String
[_systemdNspawnExecutable] :: SystemdNspawnConfig -> Maybe FilePath
[_systemdNspawnConsole] :: SystemdNspawnConfig -> SystemdNspawnConsole
systemdNspawnCapabilities :: Lens' SystemdNspawnConfig [ContainerCapability]
systemdNspawnConsole :: Lens' SystemdNspawnConfig SystemdNspawnConsole
systemdNspawnExecutable :: Lens' SystemdNspawnConfig (Maybe FilePath)
systemdNspawnExtraArgs :: Lens' SystemdNspawnConfig (Maybe String)
systemdNspawnMaxLifetimeSeconds :: Lens' SystemdNspawnConfig (Maybe Int)
systemdNspawnUseSudo :: Lens' SystemdNspawnConfig Bool
defaultSystemdNspawnConfig :: SystemdNspawnConfig
systemdNspawnConfigToCPDocument :: SystemdNspawnConfig -> CPDocument -> Either CPError CPDocument
parseSystemdNspawnConfig :: CPDocument -> Either CPError SystemdNspawnConfig
data PodmanConfig
PodmanConfig :: Maybe String -> [ContainerCapability] -> PodmanConfig
[_podmanNetworkId] :: PodmanConfig -> Maybe String
[_podmanCapabilities] :: PodmanConfig -> [ContainerCapability]
podmanCapabilities :: Lens' PodmanConfig [ContainerCapability]
podmanNetworkId :: Lens' PodmanConfig (Maybe String)
defaultPodmanConfig :: PodmanConfig
podmanConfigToCPDocument :: PodmanConfig -> CPDocument -> Either CPError CPDocument
parsePodmanConfig :: CPDocument -> Either CPError PodmanConfig
data LibVirtLXCConfig
LibVirtLXCConfig :: Bool -> Maybe FilePath -> FilePath -> Maybe String -> [ContainerCapability] -> RamSize -> LibVirtLXCConfig
[useSudo] :: LibVirtLXCConfig -> Bool
[emulator] :: LibVirtLXCConfig -> Maybe FilePath
[virshURI] :: LibVirtLXCConfig -> FilePath
[_networkId] :: LibVirtLXCConfig -> Maybe String
[guestCapabilities] :: LibVirtLXCConfig -> [ContainerCapability]
[guestRamSize] :: LibVirtLXCConfig -> RamSize
networkId :: Lens' LibVirtLXCConfig (Maybe String)
defaultLibVirtLXCConfig :: LibVirtLXCConfig
libVirtLXCConfigToCPDocument :: LibVirtLXCConfig -> CPDocument -> Either CPError CPDocument
parseLibVirtLXCConfig :: CPDocument -> Either CPError LibVirtLXCConfig

-- | Return the path to
--   <tt><i>usr</i>lib<i>libvirt</i>libexec/libvirt_lxc</tt> the
--   <a>emulatorK</a> field from the config file, or set the path in the
--   environment variable named like the value in <a>emulatorEnvVar</a>
--   dictates.
getEmulatorPath :: MonadIO m => LibVirtLXCConfig -> m FilePath
data DockerConfig
DockerConfig :: Maybe String -> [ContainerCapability] -> DockerConfig
[_dockerNetworkId] :: DockerConfig -> Maybe String
[_dockerCapabilities] :: DockerConfig -> [ContainerCapability]
dockerCapabilities :: Lens' DockerConfig [ContainerCapability]
dockerNetworkId :: Lens' DockerConfig (Maybe String)
defaultDockerConfig :: DockerConfig
dockerConfigToCPDocument :: DockerConfig -> CPDocument -> Either CPError CPDocument
parseDockerConfig :: CPDocument -> Either CPError DockerConfig

-- | Override b9 configuration items and/or the path of the b9
--   configuration file. This is useful, i.e. when dealing with command
--   line parameters.
data B9ConfigOverride
B9ConfigOverride :: [SystemPath] -> Endo B9Config -> Environment -> Maybe SystemPath -> B9ConfigOverride
[_customB9ConfigPath] :: B9ConfigOverride -> [SystemPath]
[_customB9Config] :: B9ConfigOverride -> Endo B9Config
[_customEnvironment] :: B9ConfigOverride -> Environment
[_customDefaulB9ConfigPath] :: B9ConfigOverride -> Maybe SystemPath

-- | Reader for <a>B9Config</a>. See <a>getB9Config</a> and
--   <a>localB9Config</a>.
type B9ConfigReader = Reader B9Config
data B9Config
B9Config :: Maybe LogLevel -> Maybe FilePath -> Maybe FilePath -> Bool -> Bool -> Maybe SystemPath -> Maybe String -> Maybe Int -> Maybe SystemdNspawnConfig -> Maybe PodmanConfig -> Maybe DockerConfig -> Maybe LibVirtLXCConfig -> Set RemoteRepo -> Maybe Timeout -> Maybe Int -> [String] -> B9Config
[_verbosity] :: B9Config -> Maybe LogLevel
[_logFile] :: B9Config -> Maybe FilePath
[_projectRoot] :: B9Config -> Maybe FilePath
[_keepTempDirs] :: B9Config -> Bool
[_uniqueBuildDirs] :: B9Config -> Bool
[_repositoryCache] :: B9Config -> Maybe SystemPath
[_repository] :: B9Config -> Maybe String
[_maxLocalSharedImageRevisions] :: B9Config -> Maybe Int
[_systemdNspawnConfigs] :: B9Config -> Maybe SystemdNspawnConfig
[_podmanConfigs] :: B9Config -> Maybe PodmanConfig
[_dockerConfigs] :: B9Config -> Maybe DockerConfig
[_libVirtLXCConfigs] :: B9Config -> Maybe LibVirtLXCConfig
[_remoteRepos] :: B9Config -> Set RemoteRepo
[_defaultTimeout] :: B9Config -> Maybe Timeout
[_timeoutFactor] :: B9Config -> Maybe Int
[_ext4Attributes] :: B9Config -> [String]
data LogLevel
LogTrace :: LogLevel
LogDebug :: LogLevel
LogInfo :: LogLevel
LogError :: LogLevel
LogNothing :: LogLevel

-- | A way to specify a time intervall for example for the timeouts of
--   system commands.
newtype Timeout
TimeoutMicros :: Int -> Timeout

-- | Run a <a>B9ConfigReader</a>.
runB9ConfigReader :: HasCallStack => B9Config -> Eff (B9ConfigReader : e) a -> Eff e a

-- | Return the runtime configuration, that should be the configuration
--   merged from all configuration sources. This is the configuration to be
--   used during a VM image build.
getB9Config :: Member B9ConfigReader e => Eff e B9Config

-- | Run an action with an updated runtime configuration.
localB9Config :: Member B9ConfigReader e => (B9Config -> B9Config) -> Eff e a -> Eff e a

-- | An alias for <a>getB9Config</a>.
--   
--   @deprecated
getConfig :: Member B9ConfigReader e => Eff e B9Config

-- | Ask for the <a>RemoteRepo</a>s.
getRemoteRepos :: Member B9ConfigReader e => Eff e (Set RemoteRepo)

-- | Ask for the <a>LogLevel</a>.
getLogVerbosity :: Member B9ConfigReader e => Eff e (Maybe LogLevel)

-- | Ask for the project root directory.
getProjectRoot :: Member B9ConfigReader e => Eff e FilePath

-- | An empty default <a>B9ConfigOverride</a> value, that will neither
--   apply any additional <a>B9Config</a> nor change the path of the
--   configuration file.
noB9ConfigOverride :: B9ConfigOverride
defaultTimeout :: Lens' B9Config (Maybe Timeout)
dockerConfigs :: Lens' B9Config (Maybe DockerConfig)
ext4Attributes :: Lens' B9Config [String]
keepTempDirs :: Lens' B9Config Bool
libVirtLXCConfigs :: Lens' B9Config (Maybe LibVirtLXCConfig)
logFile :: Lens' B9Config (Maybe FilePath)
maxLocalSharedImageRevisions :: Lens' B9Config (Maybe Int)
podmanConfigs :: Lens' B9Config (Maybe PodmanConfig)
projectRoot :: Lens' B9Config (Maybe FilePath)
remoteRepos :: Lens' B9Config (Set RemoteRepo)
repository :: Lens' B9Config (Maybe String)
repositoryCache :: Lens' B9Config (Maybe SystemPath)
systemdNspawnConfigs :: Lens' B9Config (Maybe SystemdNspawnConfig)
timeoutFactor :: Lens' B9Config (Maybe Int)
uniqueBuildDirs :: Lens' B9Config Bool
verbosity :: Lens' B9Config (Maybe LogLevel)

-- | Accumulate <a>B9Config</a> changes that go back to the config file.
--   See <a>B9ConfigAction</a> and <a>modifyPermanentConfig</a>.
type B9ConfigWriter = Writer (Endo B9Config)

-- | A monad that gives access to the (transient) <a>B9Config</a> to be
--   used at _runtime_ with <a>getB9Config</a> or <a>localB9Config</a>, and
--   that allows to write permanent <a>B9Config</a> changes back to the
--   configuration file using <a>modifyPermanentConfig</a>. This is the
--   amalgamation of <a>B9ConfigWriter</a> <a>B9ConfigReader</a> and
--   <a>IO</a>.
type B9ConfigAction a = Eff '[B9ConfigWriter, B9ConfigReader, EnvironmentReader, Lift IO] a
customB9Config :: Lens' B9ConfigOverride (Endo B9Config)
customB9ConfigPath :: Lens' B9ConfigOverride [SystemPath]
customDefaulB9ConfigPath :: Lens' B9ConfigOverride (Maybe SystemPath)
customEnvironment :: Lens' B9ConfigOverride Environment

-- | Convenience utility to override the B9 configuration file path.
overrideB9ConfigPath :: SystemPath -> B9ConfigOverride -> B9ConfigOverride

-- | Modify the runtime configuration.
overrideB9Config :: (B9Config -> B9Config) -> B9ConfigOverride -> B9ConfigOverride

-- | Convenience utility to override the *default* B9 configuration file
--   path.
overrideDefaultB9ConfigPath :: SystemPath -> B9ConfigOverride -> B9ConfigOverride

-- | Define the current working directory to be used when building.
overrideWorkingDirectory :: FilePath -> B9ConfigOverride -> B9ConfigOverride

-- | Define the default timeout for external commands.
overrideDefaultTimeout :: Maybe Timeout -> B9ConfigOverride -> B9ConfigOverride

-- | Define the timeout factor for external commands.
overrideTimeoutFactor :: Maybe Int -> B9ConfigOverride -> B9ConfigOverride

-- | Overwrite the <a>verbosity</a> settings in the configuration with
--   those given.
overrideVerbosity :: LogLevel -> B9ConfigOverride -> B9ConfigOverride

-- | Overwrite the <a>keepTempDirs</a> flag in the configuration with those
--   given.
overrideKeepBuildDirs :: Bool -> B9ConfigOverride -> B9ConfigOverride

-- | Overwrite the <a>ext4Attributes</a>
overrideExt4Attributes :: [String] -> B9ConfigOverride -> B9ConfigOverride

-- | Add a modification to the permanent configuration file.
modifyPermanentConfig :: (HasCallStack, Member B9ConfigWriter e) => Endo B9Config -> Eff e ()

-- | Execute a <a>B9ConfigAction</a>. It will take a
--   <a>B9ConfigOverride</a> as input. The <a>B9Config</a> in that value is
--   treated as the _runtime_ configuration, and the
--   <tt>_customConfigPath</tt> is used as the alternative location of the
--   configuration file. The configuration file is read from either the
--   path in <a>_customB9ConfigPath</a> or from <a>defaultB9ConfigFile</a>.
--   Every modification done via <a>modifyPermanentConfig</a> is applied to
--   the **contents** of the configuration file and written back to that
--   file, note that these changes are ONLY reflected in the configuration
--   file and **not** in the _runtime configuration_.
--   
--   See also <a>runB9ConfigAction</a>, which does not need the
--   <a>B9ConfigOverride</a> parameter.
runB9ConfigActionWithOverrides :: HasCallStack => B9ConfigAction a -> B9ConfigOverride -> IO a

-- | Run a <a>B9ConfigAction</a> using <a>noB9ConfigOverride</a>. See
--   <a>runB9ConfigActionWithOverrides</a> for more details.
runB9ConfigAction :: HasCallStack => B9ConfigAction a -> IO a

-- | Open the configuration file that contains the <a>B9Config</a>. If the
--   configuration does not exist, write a default configuration file, and
--   create a all missing directories.
openOrCreateB9Config :: (HasCallStack, MonadIO m) => FilePath -> m CPDocument

-- | Write the configuration in the <a>CPDocument</a> to either the user
--   supplied configuration file path or to <a>defaultB9ConfigFile</a>.
--   Create all missing (parent) directories.
writeB9CPDocument :: (HasCallStack, MonadIO m) => Maybe SystemPath -> CPDocument -> m ()
defaultB9Config :: B9Config
defaultRepositoryCache :: SystemPath
defaultB9ConfigFile :: SystemPath
maxLocalSharedImageRevisionsK :: String

-- | Parse a <a>B9Config</a>, modify it, and merge it back to the given
--   <a>CPDocument</a>.
modifyCPDocument :: CPDocument -> Endo B9Config -> Either CPError CPDocument

-- | Append a config file section for the <a>B9Config</a> to an empty
--   <a>CPDocument</a>.
b9ConfigToCPDocument :: HasCallStack => B9Config -> Either CPError CPDocument
readB9Config :: (HasCallStack, MonadIO m) => Maybe SystemPath -> m CPDocument
parseB9Config :: HasCallStack => CPDocument -> Either CPError B9Config

-- | A <a>Map</a> that maps <a>Repository</a>s to the <a>SharedImage</a>s
--   they hold.
type RepoImagesMap = Map Repository (Set SharedImage)

-- | Alias for a <a>Reader</a> <a>Eff</a>ect that reads the
--   <a>RemoteRepo</a> selected by the <a>B9Config</a> value
--   <a>_repository</a>. See <a>withSelectedRemoteRepo</a>.
type SelectedRemoteRepoReader = Reader SelectedRemoteRepo

-- | Contains the <a>Just</a> the <a>RemoteRepo</a> selected by the
--   <a>B9Config</a> value <a>_repository</a>, or <a>Nothing</a> of no
--   <a>RemoteRepo</a> was selected in the <a>B9Config</a>.
newtype SelectedRemoteRepo
MkSelectedRemoteRepo :: Maybe RemoteRepo -> SelectedRemoteRepo
[fromSelectedRemoteRepo] :: SelectedRemoteRepo -> Maybe RemoteRepo

-- | Alias for a <a>Reader</a> <a>Eff</a>ect that reads a list of
--   <a>RemoteRepo</a>s.
type RepoCacheReader = Reader RepoCache
data Repository
Cache :: Repository
Remote :: String -> Repository

-- | Convert a <a>RemoteRepo</a> down to a mere <a>Repository</a>
toRemoteRepository :: RemoteRepo -> Repository

-- | Ask for the <a>RepoCache</a> initialized by <tt>withRemoteRepos</tt>.
getRepoCache :: Member RepoCacheReader e => Eff e RepoCache

-- | Run a <a>SelectedRemoteRepoReader</a> with the
--   <a>SelectedRemoteRepo</a> selected in the <a>B9Config</a>.
--   
--   If the selected repo does not exist, and exception is thrown.
withSelectedRemoteRepo :: (Member B9ConfigReader e, Member ExcB9 e) => Eff (SelectedRemoteRepoReader : e) a -> Eff e a

-- | Ask for the <a>RemoteRepo</a> selected by the <a>B9Config</a> value
--   <a>_repository</a>. See <a>withSelectedRemoteRepo</a>.
getSelectedRemoteRepo :: Member SelectedRemoteRepoReader e => Eff e SelectedRemoteRepo

-- | Return the cache directory for a remote repository relative to the
--   root cache dir.
remoteRepoCacheDir :: RepoCache -> String -> FilePath

-- | Return the local repository directory.
localRepoDir :: RepoCache -> FilePath

-- | Select the first <a>RemoteRepo</a> with a given <tt>repoId</tt>.
lookupRemoteRepo :: Set RemoteRepo -> String -> Maybe RemoteRepo

-- | Filter the <a>SharedImage</a>s returned by <tt>getSharedImages</tt>
--   using a <a>Repository</a>-, and a <a>SharedImage</a> predicate.
filterRepoImagesMap :: (Repository -> Bool) -> (SharedImage -> Bool) -> RepoImagesMap -> RepoImagesMap

-- | Return the versions of a shared image named <tt>name</tt> from the
--   local cache.
lookupCachedImages :: SharedImageName -> RepoImagesMap -> Set SharedImage

-- | Return a <a>Set</a> of <a>Repository</a> names from a
--   <a>RepoImagesMap</a>
allRepositories :: RepoImagesMap -> Set Repository

-- | Get a <a>Set</a> of all <a>SharedImage</a>s in all <a>Repository</a>s.
allSharedImages :: RepoImagesMap -> Set SharedImage

-- | Fetch all <a>SharedImage</a>s like <a>allSharedImages</a> but attach
--   the <a>Repository</a> that the image belongs to.
--   
--   Usage example: In combination with <a>filterRepoImagesMap</a> to find
--   the latest version of a certain image in all known repositories.
allSharedImagesWithRepo :: RepoImagesMap -> Set (SharedImage, Repository)

-- | Return the maximum with regard to the <a>Ord</a> instance of
--   <a>SharedImage</a> from an <a>RepoImagesMap</a>
maxSharedImageOfAllRepos :: RepoImagesMap -> Maybe (SharedImage, Repository)

-- | Return the <a>SharedImage</a>s, that are contained in a
--   <a>Repository</a>.
allSharedImagesInRepo :: Repository -> RepoImagesMap -> Set SharedImage

-- | Keep <a>SharedImage</a>s that are in the <a>Cache</a>
--   <a>Repository</a>.
allCachedSharedImages :: RepoImagesMap -> Set SharedImage

-- | Take a subset that contains the <tt>n</tt> latest versions of
--   <a>SharedImage</a>s with the same name.
--   
--   For example, if the input contains:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:31" ,
--   SharedImage "foo" "2020-07-07 13:34:32" , SharedImage "foo"
--   "2020-07-07 13:34:33" , SharedImage "bar" "2020-07-07 13:34:34" ,
--   SharedImage "bar" "2020-07-07 13:34:35" , SharedImage "bar"
--   "2020-07-07 13:34:36" ] </tt>@@
--   
--   The output of <tt>keepNLatestSharedImages 2</tt> will be:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:32" ,
--   SharedImage "foo" "2020-07-07 13:34:33" , SharedImage "bar"
--   "2020-07-07 13:34:35" , SharedImage "bar" "2020-07-07 13:34:36" ]
--   </tt>@@
keepNLatestSharedImages :: Int -> Set SharedImage -> Set SharedImage

-- | Take a subset that contains obsolete images.
--   
--   Do the opposite of <a>keepNLatestSharedImages</a>, and return all
--   **but** the <tt>n</tt> latest versions of <a>SharedImage</a>s with the
--   same name.
--   
--   For example, if the input contains:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:31" ,
--   SharedImage "foo" "2020-07-07 13:34:32" , SharedImage "foo"
--   "2020-07-07 13:34:33" , SharedImage "bar" "2020-07-07 13:34:34" ,
--   SharedImage "bar" "2020-07-07 13:34:35" , SharedImage "bar"
--   "2020-07-07 13:34:36" ] </tt>@@
--   
--   The output of <tt>keepNLatestSharedImages 2</tt> will be:
--   
--   @@<tt> fromList [ SharedImage "foo" "2020-07-07 13:34:31" ,
--   SharedImage "bar" "2020-07-07 13:34:34" ] </tt>@@
dropAllButNLatestSharedImages :: Int -> Set SharedImage -> Set SharedImage

-- | Group by <a>SharedImageName</a>.
groupBySharedImageName :: Set SharedImage -> Map SharedImageName (Set SharedImage)

-- | Convenience type alias for <a>Eff</a>ects that have a <a>B9Config</a>,
--   a <a>Logger</a>, <a>MonadIO</a> and <a>MonadBaseControl</a>.
type CommandIO e = (MonadBaseControl IO (Eff e), MonadIO (Eff e), Member LoggerReader e, Member B9ConfigReader e)

-- | Effect that reads a <a>Logger</a>.
type LoggerReader = Reader Logger

-- | The logger to write log messages to.
newtype Logger
MkLogger :: Maybe Handle -> Logger
[logFileHandle] :: Logger -> Maybe Handle

-- | Lookup the selected <a>getLogVerbosity</a> and <a>_logFile</a> from
--   the <a>B9Config</a> and open it.
--   
--   Then run the given action; if the action crashes, the log file will be
--   closed.
withLogger :: (MonadBaseControl IO (Eff e), MonadIO (Eff e), Member B9ConfigReader e) => Eff (LoggerReader : e) a -> Eff e a
traceL :: CommandIO e => String -> Eff e ()
dbgL :: CommandIO e => String -> Eff e ()
infoL :: CommandIO e => String -> Eff e ()
errorL :: CommandIO e => String -> Eff e ()
errorExitL :: (CommandIO e, Member ExcB9 e) => String -> Eff e a
b9Log :: CommandIO e => LogLevel -> String -> Eff e ()
printHash :: Hashable a => a -> String

-- | Type alias for a <a>BuildInfo</a> <a>Reader</a>
type BuildInfoReader = Reader BuildInfo

-- | Create the build directories, generate (hash) the build-id and execute
--   the given action.
--   
--   Bindings added to the text template parameter environment:
--   
--   <ul>
--   <li><tt>projectRoot</tt> the directory that contains the sources of
--   the project to build</li>
--   <li><tt>buildDir</tt> the temporary directory used store the build
--   artifacts passed into- or outof the build</li>
--   </ul>
--   
--   Unless <a>_keepTempDirs</a> is <tt>True</tt> clean up the build
--   directories after the actions returns - even if the action throws a
--   runtime exception.
withBuildInfo :: (Lifted IO e, MonadBaseControl IO (Eff e), Member B9ConfigReader e, Member ExcB9 e, Member EnvironmentReader e, Member LoggerReader e, HasCallStack) => Bool -> Eff (BuildInfoReader : e) a -> Eff e a
getBuildId :: Member BuildInfoReader e => Eff e String
getBuildDate :: Member BuildInfoReader e => Eff e String
getBuildDir :: Member BuildInfoReader e => Eff e FilePath

-- | Ask whether <tt>stdin</tt> of the <tt>B9</tt> process should be
--   redirected to the external commands executed during the build.
isInteractive :: Member BuildInfoReader e => Eff e Bool

-- | Ways to process std-output.
data HostCommandStdout a

-- | Write std-out to the log sink.
[HostCommandStdoutLog] :: HostCommandStdout ExitCode

-- | Write std-out to the log sink, additionally collect and return it.
[HostCommandStdoutLogAndCapture] :: HostCommandStdout (ByteString, ExitCode)

-- | Ways to process std-input.
data HostCommandStdin

-- | Disbale std-in
HostCommandNoStdin :: HostCommandStdin

-- | Inherit std-in
HostCommandInheritStdin :: HostCommandStdin

-- | Produce std-in
HostCommandStdInConduit :: ConduitT () ByteString IO () -> HostCommandStdin

-- | Execute the given shell command.
--   
--   If <a>isInteractive</a> is true, the standard-in will be passed to the
--   external command, and all output of the program will be directed to
--   standard-out.
--   
--   The command and the output is either logged to the logfile with
--   <a>traceL</a> or <a>errorL</a> or written to stdout.
--   
--   If the command exists with non-zero exit code, the current process
--   exists with the same exit code.
cmdInteractive :: (HasCallStack, Member ExcB9 e, Member BuildInfoReader e, CommandIO e) => String -> Eff e ()

-- | Execute the given shell command.
--   
--   The command and the output is either logged to the logfile with
--   <a>traceL</a> or <a>errorL</a> or written to stdout.
--   
--   If the command exists with non-zero exit code, the current process
--   exists with the same exit code.
cmd :: (HasCallStack, Member ExcB9 e, CommandIO e) => String -> Eff e ()

-- | Execute the given shell command and collect its standard output.
--   
--   The command and the output is additionally either logged to the
--   logfile with <a>traceL</a> or <a>errorL</a> or written to stdout.
--   
--   If the command exists with non-zero exit code, the current process
--   exists with the same exit code.
cmdStdout :: (HasCallStack, Member ExcB9 e, CommandIO e) => String -> Eff e ByteString

-- | Run a shell command defined by a string and optionally interrupt the
--   command after a given time has elapsed. If the shell command did not
--   exit with <a>ExitSuccess</a>, or the timer elapsed, a <a>B9Error</a>
--   is thrown.
--   
--   This is only useful for non-interactive commands.
hostCmd :: (CommandIO e, Member ExcB9 e) => String -> Maybe Timeout -> Eff e Bool

-- | Like <a>hostCmd</a> but with std-input attached.
hostCmdStdIn :: (CommandIO e, Member ExcB9 e) => HostCommandStdin -> String -> Maybe Timeout -> Eff e Bool

-- | Run a shell command defined by a string and optionally interrupt the
--   command after a given time has elapsed. This is only useful for
--   non-interactive commands.
hostCmdEither :: forall e. CommandIO e => HostCommandStdin -> String -> Maybe Timeout -> Eff e (Either Timeout ExitCode)

-- | Run a shell command defined by a string and optionally interrupt the
--   command after a given time has elapsed. This is only useful for
--   non-interactive commands.
--   
--   Also provide the possibility to receive the stdout of the command. It
--   of course be collected in ram, so be sure the command doesn't have to
--   much output.
hostCmdStdoutEither :: forall e a. CommandIO e => HostCommandStdin -> HostCommandStdout a -> String -> Maybe Timeout -> Eff e (Either Timeout a)

-- | Execute the given shell command in a newly created pseudo terminal, if
--   necessary.
ptyCmdInteractive :: (HasCallStack, Member ExcB9 e, Member BuildInfoReader e, CommandIO e) => Maybe Timeout -> String -> [String] -> Eff e ()

-- | Express a pattern for file paths, used when searching repositories.
newtype FilePathGlob
FileExtension :: String -> FilePathGlob

-- | Initialize the local repository cache directory and the
--   <a>RemoteRepo</a>s. Run the given action with a <a>B9Config</a> that
--   contains the initialized repositories in <a>_remoteRepos</a>.
withRemoteRepos :: (Member B9ConfigReader e, Lifted IO e) => Eff (RepoCacheReader : e) a -> Eff e a

-- | Check for existance of priv-key and make it an absolute path.
remoteRepoCheckSshPrivKey :: MonadIO m => RemoteRepo -> m RemoteRepo

-- | Empty the repository; load the corresponding settings from the config
--   file, check that the priv key exists and create the correspondig cache
--   directory.
cleanRemoteRepo :: MonadIO m => RepoCache -> RemoteRepo -> m ()

-- | Find files which are in <tt>subDir</tt> and match <tt>glob</tt> in the
--   repository cache. NOTE: This operates on the repository cache, but
--   does not enforce a repository cache update.
repoSearch :: forall e. (CommandIO e, Member RepoCacheReader e) => FilePath -> FilePathGlob -> Eff e [(Repository, [FilePath])]

-- | Push a file from the cache to a remote repository
pushToRepo :: (Member ExcB9 e, CommandIO e) => RemoteRepo -> FilePath -> FilePath -> Eff e ()

-- | Pull a file from a remote repository to cache
pullFromRepo :: (Member ExcB9 e, CommandIO e) => RemoteRepo -> FilePath -> FilePath -> Eff e ()

-- | Push a file from the cache to a remote repository
pullGlob :: (Member ExcB9 e, CommandIO e, Member RepoCacheReader e) => FilePath -> FilePathGlob -> RemoteRepo -> Eff e ()

-- | Return a list of all existing sharedImages from cached repositories.
getSharedImages :: (HasCallStack, CommandIO e, Lifted IO e, Member RepoCacheReader e) => Eff e (Map Repository (Set SharedImage))

-- | Pull metadata files from all remote repositories.
pullRemoteRepos :: (HasCallStack, Member ExcB9 e, Lifted IO e, CommandIO e, '[SelectedRemoteRepoReader, RepoCacheReader] <:: e) => Eff e ()

-- | Pull the latest version of an image, either from the selected remote
--   repo or from the repo that has the latest version.
pullLatestImage :: (HasCallStack, Lifted IO e, CommandIO e, '[ExcB9, RepoCacheReader, SelectedRemoteRepoReader] <:: e) => SharedImageName -> Eff e (Maybe SharedImageBuildId)

-- | Return the <a>Image</a> of the latest version of a shared image named
--   <tt>name</tt> from the local cache.
getLatestImageByName :: (HasCallStack, Lifted IO e, CommandIO e, Member RepoCacheReader e) => SharedImageName -> Eff e (Maybe Image)

-- | Depending on the <a>maxLocalSharedImageRevisions</a> <a>B9Config</a>
--   settings either do nothing or delete all but the configured number of
--   most recent shared images with the given name from the local cache.
cleanOldSharedImageRevisionsFromCache :: ('[RepoCacheReader, ExcB9] <:: e, Lifted IO e, CommandIO e) => SharedImageName -> Eff e ()

-- | Clean all obsolete images in the local image cache.
cleanLocalRepoCache :: ('[RepoCacheReader, ExcB9] <:: e, Lifted IO e, CommandIO e) => Eff e ()

-- | Publish the latest version of a shared image identified by name to the
--   selected repository from the cache.
pushSharedImageLatestVersion :: (Lifted IO e, CommandIO e, '[SelectedRemoteRepoReader, RepoCacheReader, ExcB9] <:: e) => SharedImageName -> Eff e ()

-- | Upload a shared image from the cache to a selected remote repository
pushToSelectedRepo :: (Member ExcB9 e, Lifted IO e, CommandIO e, '[RepoCacheReader, SelectedRemoteRepoReader] <:: e) => SharedImage -> Eff e ()

-- | Return either all remote repos or just the single selected repo.
getSelectedRepos :: '[B9ConfigReader, SelectedRemoteRepoReader] <:: e => Eff e (Set RemoteRepo)

-- | Return the path to the sub directory in the cache that contains files
--   of shared images.
getSharedImagesCacheDir :: '[RepoCacheReader] <:: e => Eff e FilePath

-- | A constraint that contains all effects of <a>B9Eff</a>
type IsB9 e = (HasCallStack, Lifted IO e, CommandIO e, B9Eff <:: e)

-- | Definition of the B9 effect list. It encapsulates logging, a reader
--   for the <a>B9.B9Config</a> and access to the current build id, the
--   current build directory and the artifact to build.
--   
--   This monad is used by the _effectful_ functions in this library.
type B9Eff = '[SelectedRemoteRepoReader, RepoCacheReader, BuildInfoReader, LoggerReader, B9ConfigReader, EnvironmentReader, ExcB9, Lift IO]

-- | Definition of the B9 monad. See <a>B9Eff</a>.
--   
--   This module is used by the _effectful_ functions in this library.
type B9 a = Eff B9Eff a

-- | Execute a <a>B9</a> effect and return an action that needs the
--   <a>B9Config</a>.
runB9 :: HasCallStack => B9 a -> B9ConfigAction a

-- | Execute a <a>B9</a> effect like <a>runB9</a> but run external
--   commands, such as `systemd-nspawn`, <i>interactively</i>.
--   
--   When run <i>interactively</i>, the stdin/stdout of certain commands is
--   inherited from the main process.
runB9Interactive :: HasCallStack => B9 a -> B9ConfigAction a

-- | Types whose values can be turned into an <a>Eff</a>ect that produces
--   <a>Text</a>, e.g. <a>ContentGenerator</a>
class ToContentGenerator c
toContentGenerator :: (ToContentGenerator c, HasCallStack, IsB9 e) => c -> Eff e Text

-- | A <a>B9</a> action that procuces a <a>Text</a>.
type ContentGenerator = B9 Text
data SourceFileConversion
NoConversion :: SourceFileConversion
ExpandVariables :: SourceFileConversion

-- | A wrapper around a file path and a flag indicating if template
--   variable expansion should be performed when reading the file contents.
data SourceFile
Source :: SourceFileConversion -> FilePath -> SourceFile
readTemplateFile :: (MonadIO (Eff e), '[ExcB9, EnvironmentReader] <:: e) => SourceFile -> Eff e Text

-- | <a>Text</a> template substitution.
subst :: (Member ExcB9 e, Member EnvironmentReader e) => Text -> Eff e Text

-- | <a>String</a> template substitution
substStr :: (Member ExcB9 e, Member EnvironmentReader e) => String -> Eff e String
substFile :: (Member EnvironmentReader e, Member ExcB9 e, MonadIO (Eff e)) => FilePath -> FilePath -> Eff e ()
substPath :: (Member EnvironmentReader e, Member ExcB9 e) => SystemPath -> Eff e SystemPath

-- | Extend an <a>Environment</a> with new bindings, where each value may
--   contain string templates with like <tt>"Hello $name, how is life on
--   $planet these days?"</tt>.
withSubstitutedStringBindings :: (Member EnvironmentReader e, Member ExcB9 e) => [(String, String)] -> Eff e s -> Eff e s

-- | Describe a virtual machine, i.e. a set up disk images to create and a
--   shell script to put things together.
data VmScript
VmScript :: CPUArch -> [SharedDirectory] -> Script -> VmScript
NoVmScript :: VmScript
substVmScript :: forall e. (Member EnvironmentReader e, Member ExcB9 e) => VmScript -> Eff e VmScript

-- | Replace $... variables inside an <a>ImageTarget</a>
substImageTarget :: forall e. (HasCallStack, Member EnvironmentReader e, Member ExcB9 e) => ImageTarget -> Eff e ImageTarget

-- | Resolve an ImageSource to an <a>Image</a>. The ImageSource might not
--   exist, as is the case for <a>EmptyImage</a>.
resolveImageSource :: IsB9 e => ImageSource -> Eff e Image

-- | Return all valid image types sorted by preference.
preferredDestImageTypes :: IsB9 e => ImageSource -> Eff e [ImageType]

-- | Return all supported source <a>ImageType</a>s compatible to a
--   <tt>ImageDestinaion</tt> in the preferred order.
preferredSourceImageTypes :: HasCallStack => ImageDestination -> [ImageType]

-- | Create the parent directories for the file that contains the
--   <a>Image</a>. If the path to the image file is relative, prepend
--   <a>_projectRoot</a> from the <a>B9Config</a>.
ensureAbsoluteImageDirExists :: IsB9 e => Image -> Eff e Image

-- | Create an image from an image source. The destination image must have
--   a compatible image type and filesystem. The directory of the image
--   MUST be present and the image file itself MUST NOT alredy exist.
materializeImageSource :: IsB9 e => ImageSource -> Image -> Eff e ()

-- | Convert some <a>Image</a>, e.g. a temporary image used during the
--   build phase to the final destination.
createDestinationImage :: IsB9 e => Image -> ImageDestination -> Eff e ()

-- | Determine the virtual size of a raw image
getVirtualSizeForRawImage :: IsB9 e => FilePath -> Eff e (Either String Integer)

-- | Resize an image, including the file system inside the image.
resizeImage :: IsB9 e => ImageResize -> Image -> Eff e ()

-- | Import a disk image from some external source into the build directory
--   if necessary convert the image.
importImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Export a disk image from the build directory; if necessary convert the
--   image.
exportImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Export a disk image from the build directory; if necessary convert the
--   image.
exportAndRemoveImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Convert an image in the build directory to another format and return
--   the new image.
convertImage :: IsB9 e => Image -> Image -> Eff e ()

-- | Publish an sharedImage made from an image and image meta data to the
--   configured repository
shareImage :: IsB9 e => Image -> SharedImageName -> Eff e SharedImage

-- | Types of values that describe content, that can be created from an
--   <a>AST</a>.
class FromAST a
fromAST :: (FromAST a, IsB9 e, ToContentGenerator c) => AST c a -> Eff e a

-- | Describe how to create structured content that has a tree-like
--   syntactic structure, e.g. yaml, JSON and erlang-proplists. The first
--   parameter defines a <i>context</i> into which the <a>AST</a> is
--   embedded, e.g. B9.Artifact.Content'. The second parameter defines a
--   specifix syntax, e.g <a>ErlangPropList</a> that the <a>AST</a> value
--   generates.
data AST c a

-- | Create an object similar to a Json object.
ASTObj :: [(String, AST c a)] -> AST c a

-- | An array.
ASTArr :: [AST c a] -> AST c a

-- | Merge the nested elements, this is a very powerful tool that allows to
--   combine
ASTMerge :: [AST c a] -> AST c a
ASTEmbed :: c -> AST c a
ASTString :: String -> AST c a
ASTInt :: Int -> AST c a
ASTParse :: SourceFile -> AST c a
AST :: a -> AST c a

-- | A wrapper type around yaml values with a Semigroup instance useful for
--   combining yaml documents describing system configuration like e.g.
--   user-data.
newtype YamlObject
YamlObject :: Value -> YamlObject
[_fromYamlObject] :: YamlObject -> Value

-- | A wrapper type around erlang terms with a Semigroup instance useful
--   for combining sys.config files with OTP-application configurations in
--   a list of the form of a proplist.
newtype ErlangPropList
ErlangPropList :: SimpleErlangTerm -> ErlangPropList

-- | Parse a text containing an <tt>Erlang</tt> expression ending with a
--   <tt>.</tt> and Return an <a>AST</a>.
textToErlangAst :: Text -> AST c ErlangPropList

-- | Parse a string containing an <tt>Erlang</tt> expression ending with a
--   <tt>.</tt> and Return an <a>AST</a>.
stringToErlangAst :: String -> AST c ErlangPropList

-- | Cloud-init <tt>meta-data</tt> configuration Yaml.
--   
--   <tt>cloud-config</tt> yaml documents contain: <tt>#cloud-config</tt>
--   as first line.
--   
--   @Since 0.5.62
newtype CloudConfigYaml
MkCloudConfigYaml :: YamlObject -> CloudConfigYaml
[fromCloudConfigYaml] :: CloudConfigYaml -> YamlObject

-- | The header line, which must be the first line in the text file
--   containing the cloud-config Yaml document.
--   
--   @Since 0.5.62
cloudConfigFileHeader :: Text

-- | An <a>ErlangPropList</a> <a>AST</a> with <a>Content</a>
type ErlangAst = AST Content ErlangPropList

-- | This is content that can be <a>read</a> via the generated <a>Read</a>
--   instance.
data Content
RenderErlang :: AST Content ErlangPropList -> Content
RenderYamlObject :: AST Content YamlObject -> Content
RenderCloudConfig :: AST Content CloudConfigYaml -> Content

-- | This data will be passed through unaltered. This is used during the
--   transition phase from having B9 stuff read from files via <a>Read</a>
--   instances towards programatic use or the use of HOCON.
FromByteString :: ByteString -> Content

-- | Embed a literal string
FromString :: String -> Content

-- | Embed the contents of the <a>SourceFile</a> with template parameter
--   substitution.
FromTextFile :: SourceFile -> Content

-- | The data in the given file will be base64 encoded.
RenderBase64BinaryFile :: FilePath -> Content

-- | This data will be base64 encoded.
RenderBase64Binary :: ByteString -> Content

-- | Download the contents of the URL
FromURL :: String -> Content

-- | Describe how input files for artifacts to build are obtained. The
--   general structure of each constructor is <b>FromXXX</b>
--   <i>destination</i> <i>source</i>
data ArtifactSource

-- | Copy a <a>SourceFile</a> potentially replacing variable defined in
--   <tt>Let</tt>-like parent elements.
FromFile :: FilePath -> SourceFile -> ArtifactSource

-- | Create a file from some <a>Content</a>
FromContent :: FilePath -> Content -> ArtifactSource

-- | Set the unix <i>file permissions</i> to all files generated by the
--   nested list of <a>ArtifactSource</a>s.
SetPermissions :: Int -> Int -> Int -> [ArtifactSource] -> ArtifactSource

-- | Assume a local directory as starting point for all relative source
--   files in the nested <a>ArtifactSource</a>s.
FromDirectory :: FilePath -> [ArtifactSource] -> ArtifactSource

-- | Specify an output directory for all the files generated by the nested
--   <a>ArtifactSource</a>s
IntoDirectory :: FilePath -> [ArtifactSource] -> ArtifactSource

-- | Return all source files generated by an <a>ArtifactSource</a>.
getArtifactSourceFiles :: ArtifactSource -> [FilePath]

-- | The output of an <a>ArtifactAssembly</a> is either a set of generated
--   files, or it might be a directory that contains the artifacts sources.
data AssemblyOutput
AssemblyGeneratesOutputFiles :: [FilePath] -> AssemblyOutput
AssemblyCopiesSourcesToDirectory :: FilePath -> AssemblyOutput
data CloudInitType
CI_ISO :: CloudInitType
CI_VFAT :: CloudInitType
CI_DIR :: CloudInitType
data ArtifactTarget
CloudInitTarget :: CloudInitType -> FilePath -> ArtifactTarget
VmImagesTarget :: ArtifactTarget

-- | A symbolic representation of the targets assembled by <a>assemble</a>
--   from an <a>ArtifactAssembly</a>. There is a list of
--   <a>ArtifactTarget</a>s because e.g. a single <a>CloudInit</a> can
--   produce up to three output files, a directory, an ISO image and a VFAT
--   image.
data AssembledArtifact
AssembledArtifact :: InstanceId -> [ArtifactTarget] -> AssembledArtifact

-- | Define an <b>output</b> of a build. Assemblies are nested into
--   <a>ArtifactGenerator</a>s. They contain all the files defined by the
--   <a>Sources</a> they are nested into.
data ArtifactAssembly

-- | Generate a <b>cloud-init</b> compatible directory, ISO- or VFAT image,
--   as specified by the list of <a>CloudInitType</a>s. Every item will use
--   the second argument to create an appropriate <i>file name</i>, e.g.
--   for the <a>CI_ISO</a> type the output is <tt>second_param.iso</tt>.
CloudInit :: [CloudInitType] -> FilePath -> ArtifactAssembly

-- | a set of VM-images that were created by executing a build script on
--   them.
VmImages :: [ImageTarget] -> VmScript -> ArtifactAssembly

-- | Identify an artifact. <b>Deprecated</b> TODO: B9 does not check if all
--   instances IDs are unique.
newtype InstanceId
IID :: String -> InstanceId

-- | Artifacts represent the things B9 can build. A generator specifies
--   howto generate parameterized, multiple artifacts. The general
--   structure is:
--   
--   <pre>
--   Let [ ... bindings ... ]
--       [ Sources
--           [ ... list all input files ... ]
--           [ Artifact ...
--           , Artifact ...
--           , Let [ ... ] [ ... ]
--           ]
--       ]
--   </pre>
--   
--   The reasons why <a>Sources</a> takes a list of
--   <a>ArtifactGenerator</a>s is that
--   
--   <ol>
--   <li>this makes the value easier to read/write for humans</li>
--   <li>the sources are static files used in all children (e.g. company
--   logo image)</li>
--   <li>the sources are parameterized by variables that bound to different
--   values for each artifact, e.g. a template network config file which
--   contains the host IP address.</li>
--   </ol>
--   
--   To bind such variables use <a>Let</a>, <a>Each</a>, <a>LetX</a> or
--   <a>EachT</a>.
--   
--   String substitution of these variables is done by
--   <a>B9.Artifact.Content.StringTemplate</a>. These variables can be used
--   as value in nested <a>Let</a>s, in most file names/paths and in source
--   files added with <a>SourceFile</a>
--   
--   <ul>
--   <li>- @deprecated TODO remove this when switching to Dhall</li>
--   </ul>
data ArtifactGenerator

-- | Add sources available to <a>ArtifactAssembly</a>s in nested artifact
--   generators.
Sources :: [ArtifactSource] -> [ArtifactGenerator] -> ArtifactGenerator

-- | Bind variables, variables are available in nested generators.
--   @deprecated TODO remove this when switching to Dhall
Let :: [(String, String)] -> [ArtifactGenerator] -> ArtifactGenerator

-- | A <a>Let</a> where each variable is assigned to each value; the nested
--   generator is executed for each permutation.
--   
--   <pre>
--   LetX [("x", ["1","2","3"]), ("y", ["a","b"])] [..]
--   </pre>
--   
--   Is equal to:
--   
--   <pre>
--   Let [] [
--     Let [("x", "1"), ("y", "a")] [..]
--     Let [("x", "1"), ("y", "b")] [..]
--     Let [("x", "2"), ("y", "a")] [..]
--     Let [("x", "2"), ("y", "b")] [..]
--     Let [("x", "3"), ("y", "a")] [..]
--     Let [("x", "3"), ("y", "b")] [..]
--   ]
--   </pre>
--   
--   @deprecated TODO remove this when switching to Dhall
LetX :: [(String, [String])] -> [ArtifactGenerator] -> ArtifactGenerator

-- | Bind each variable to their first value, then each variable to the
--   second value, etc ... and execute the nested generator in every step.
--   <a>LetX</a> represents a product of all variables, whereas <a>Each</a>
--   represents a sum of variable bindings - <a>Each</a> is more like a
--   <i>zip</i> whereas <a>LetX</a> is more like a list comprehension.
--   @deprecated TODO remove this when switching to Dhall
Each :: [(String, [String])] -> [ArtifactGenerator] -> ArtifactGenerator

-- | The transposed version of <a>Each</a>: Bind the variables in the first
--   list to each a set of values from the second argument; execute the
--   nested generators for each binding @deprecated TODO remove this when
--   switching to Dhall
EachT :: [String] -> [[String]] -> [ArtifactGenerator] -> ArtifactGenerator

-- | Generate an artifact defined by an <a>ArtifactAssembly</a>; the
--   assembly can access the files created from the <a>Sources</a> and
--   variables bound by <a>Let</a>ish elements. An artifact has an instance
--   id, that is a unique, human readable string describing the artifact to
--   assemble.
Artifact :: InstanceId -> ArtifactAssembly -> ArtifactGenerator
EmptyArtifact :: ArtifactGenerator

-- | The variable containing the instance id. <b>Deprecated</b>
instanceIdKey :: String

-- | The variable containing the buildId that identifies each execution of
--   B9. For more info about variable substitution in source files see
--   <a>StringTemplate</a>
buildIdKey :: String

-- | The variable containing the date and time a build was started. For
--   more info about variable substitution in source files see
--   <a>StringTemplate</a>
buildDateKey :: String

-- | Return the files that the artifact assembly consist of.
getAssemblyOutput :: ArtifactAssembly -> [AssemblyOutput]
buildWithVm :: IsB9 e => InstanceId -> [ImageTarget] -> FilePath -> VmScript -> Eff e Bool
data InstanceGenerator e
IG :: InstanceId -> e -> ArtifactAssembly -> InstanceGenerator e

-- | Internal data structure. Only exposed for unit testing.
data InstanceSources
InstanceSources :: Environment -> [ArtifactSource] -> InstanceSources
[isEnv] :: InstanceSources -> Environment
[isSources] :: InstanceSources -> [ArtifactSource]

-- | Execute an <a>ArtifactGenerator</a> and return a <tt>B9Invocation</tt>
--   that returns the build id obtained by <a>getBuildId</a>.
buildArtifacts :: ArtifactGenerator -> B9 String

-- | Return a list of relative paths for the <i>local</i> files to be
--   generated by the ArtifactGenerator. This excludes <tt>Shared</tt> and
--   Transient image targets.
getArtifactOutputFiles :: ArtifactGenerator -> Either SomeException [FilePath]

-- | Run an artifact generator to produce the artifacts.
assemble :: ArtifactGenerator -> B9 [AssembledArtifact]

-- | Interpret an <a>ArtifactGenerator</a> into a list of simple commands,
--   i.e. <a>InstanceGenerator</a>s
runArtifactGenerator :: Environment -> String -> String -> ArtifactGenerator -> Either SomeException [InstanceGenerator [TextFileWriter]]

-- | Run an
runInstanceGenerator :: IsB9 e => InstanceGenerator FilePath -> Eff e AssembledArtifact

-- | Create the <a>ArtifactTarget</a> from an <a>ArtifactAssembly</a> in
--   the directory <tt>instanceDir</tt>
runArtifactAssembly :: IsB9 e => InstanceId -> FilePath -> ArtifactAssembly -> Eff e [ArtifactTarget]


-- | A crude, unsafe and preliminary solution to building B9
--   <a>SharedImage</a>s from Shake.
module B9.Shake.SharedImageRules

-- | Specify an arbitrary action that is supposed to build the given shared
--   image identified by a <a>SharedImageName</a>. NOTE: You must call
--   <a>enableSharedImageRules</a> before this action works.
customSharedImageAction :: HasCallStack => SharedImageName -> Action () -> Rules ()

-- | Add a dependency to the creation of a <a>SharedImage</a>. The build
--   action for the shared image must have been supplied by e.g.
--   <a>customSharedImageAction</a>. NOTE: You must call
--   <a>enableSharedImageRules</a> before this action works.
needSharedImage :: HasCallStack => SharedImageName -> Action SharedImageBuildId

-- | In order to use <a>needSharedImage</a> and
--   <a>customSharedImageAction</a> you need to call this action before
--   using any of the aforementioned <a>Rules</a>.
enableSharedImageRules :: HasCallStack => B9ConfigOverride -> Rules ()


-- | Convenient Shake <a>Action</a>s for <a>B9</a> rules.
module B9.Shake.Actions

-- | Convert a <a>B9ConfigAction</a> action into a Shake <a>Action</a>.
--   This is just an alias for <a>runB9ConfigActionWithOverrides</a> since
--   <a>Action</a> is an instance of <a>MonadIO</a> and
--   <a>runB9ConfigActionWithOverrides</a> work on any .
b9InvocationAction :: HasCallStack => B9ConfigAction a -> B9ConfigOverride -> Action a

-- | An action that does the equivalent of <tt>b9c build -f <a>b9file</a>
--   -- (args !! 0) (args !! 1) ... (args !! (length args - 1))</tt> with
--   the current working directory changed to <tt>b9Root</tt>. The return
--   value is the buildid, see <a>getBuildId</a>
buildB9File :: HasCallStack => FilePath -> FilePath -> [String] -> Action String


-- | A module that re-exports all B9 Shake integration. Which by the way is
--   crude and preliminary...
module B9.Shake