let Prelude =
        env:DHALL_PRELUDE
      ? https://raw.githubusercontent.com/dhall-lang/dhall-lang/v21.1.0/Prelude/package.dhall
          sha256:0fed19a88330e9a8a3fbe1e8442aa11d12e38da51eb12ba8bcb56f3c25d0854a

let FilePath = Text

let Directory = Text

let Name = Text

let Version = Text

let Revision = Text

let Subdir = Text

let Url = Text

let HaskellSource =
      < FromHackage : { name : Name, version : Version }
      | FromGit : { url : Url, revision : Revision, subdir : Optional Subdir }
      | FromTarball : Url
      >

let Modifiers =
      { Type =
          { doBenchmark : Bool
          , doCheck : Bool
          , doJailbreak : Bool
          , enableProfiling : Bool
          , includeBenchmarks : Bool
          , includeExecutables : Bool
          , includeTests : Bool
          }
      , default =
        { doBenchmark = False
        , doCheck = False
        , doJailbreak = True
        , enableProfiling = True
        , includeBenchmarks = True
        , includeExecutables = True
        , includeTests = True
        }
      }

let Attr = λ(a : Type) → { mapKey : Text, mapValue : a }

let Policy = < Keep | Pin >

let Flag
    : ∀(x : Type) → Type
    = λ(x : Type) → < Enable : x | Disable : x >

let CabalFlag = Flag Text

let HaskellPackage =
      { Type =
          { source : HaskellSource
          , modifiers : Modifiers.Type
          , policy : List Policy
          , flags : List CabalFlag
          }
      , default =
        { modifiers = Modifiers.default
        , flags = [] : List CabalFlag
        , policy = [] : List Policy
        }
      }

let Compiler = Text

let PackageEntry = Attr HaskellPackage.Type

let PackageList = List PackageEntry

let PackageSet = { compiler : Compiler, packages : PackageList }

let Overlay = PackageSet

let PackageSetExportSettings =
      { packagesDir : Directory
      , packageSetFile : FilePath
      , packageSet : PackageSet
      }

let OverlayExportSettings =
      { packagesDir : Directory, overlayFile : FilePath, overlay : Overlay }

let HorizonExport =
      < MakePackageSet : PackageSetExportSettings
      | MakeOverlay : OverlayExportSettings
      >

let callHackage
    : Name → Version → HaskellPackage.Type
    = λ(name : Name) →
      λ(version : Version) →
        HaskellPackage::{ source = HaskellSource.FromHackage { name, version } }

let callGit
    : Url → Revision → Optional Subdir → HaskellPackage.Type
    = λ(url : Url) →
      λ(revision : Revision) →
      λ(subdir : Optional Subdir) →
        HaskellPackage::{
        , source = HaskellSource.FromGit { url, revision, subdir }
        }

let callTarball
    : Url → HaskellPackage.Type
    = λ(url : Url) → HaskellPackage::{ source = HaskellSource.FromTarball url }

let modPackageList
    : Modifiers.Type → PackageList → PackageList
    = λ(xs : Modifiers.Type) →
      λ(ps : PackageList) →
        Prelude.List.map
          PackageEntry
          PackageEntry
          (λ(x : PackageEntry) → x with mapValue.modifiers = xs)
          ps

let modPackageSet
    : Modifiers.Type → PackageSet → PackageSet
    = λ(xs : Modifiers.Type) →
      λ(ps : PackageSet) →
        ps
        with packages = modPackageList xs ps.packages

in  { Attr
    , CabalFlag
    , Compiler
    , Directory
    , FilePath
    , Flag
    , HaskellSource
    , HaskellPackage
    , HorizonExport
    , Modifiers
    , Name
    , OverlayExportSettings
    , Overlay
    , PackageEntry
    , PackageList
    , PackageSetExportSettings
    , PackageSet
    , Policy
    , Revision
    , Subdir
    , Version
    , Url
    , callGit
    , callHackage
    , callTarball
    , modPackageList
    , modPackageSet
    }