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

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 }
      >

let Modifiers =
      { Type = { doJailbreak : Bool, doCheck : Bool, enableProfiling : Bool }
      , default =
        { doJailbreak = True, doCheck = False, enableProfiling = True }
      }

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

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

let CabalFlag = Flag Text

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

let Compiler = Text

let PackageEntry = Attr HaskellPackage.Type

let PackageList = List PackageEntry

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

let Overlay = PackageList

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

let callCabal2nix
    : Name → Url → Revision → Optional Subdir → Attr HaskellPackage.Type
    = λ(name : Name) →
      λ(url : Url) →
      λ(revision : Revision) →
      λ(subdir : Optional Subdir) →
        { mapKey = name
        , mapValue = HaskellPackage::{
          , source = HaskellSource.FromGit { url, revision, subdir }
          }
        }

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
    , Flag
    , HaskellSource
    , HaskellPackage
    , Modifiers
    , Name
    , Overlay
    , PackageList
    , PackageSet
    , Revision
    , Subdir
    , Version
    , Url
    , callCabal2nix
    , callHackage
    , modPackageList
    , modPackageSet
    }