Zuul job generations with dhall (WIP)

filtered-output.dhall

let List/map =
      https://prelude.dhall-lang.org/v11.1.0/List/map sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680

let List/drop =
      https://raw.githubusercontent.com/dhall-lang/dhall-lang/master/Prelude/List/drop sha256:af983ba3ead494dd72beed05c0f3a17c36a4244adedf7ced502c6512196ed0cf

let List/take =
      https://raw.githubusercontent.com/dhall-lang/dhall-lang/master/Prelude/List/take sha256:b3e08ee8c3a5bf3d8ccee6b2b2008fbb8e51e7373aef6f1af67ad10078c9fbfa

let Prelude =
      https://raw.githubusercontent.com/dhall-lang/dhall-lang/v11.1.0/Prelude/package.dhall sha256:99462c205117931c0919f155a6046aec140c70fb8876d208c7c77027ab19c2fa

let System = < el6 | el7 | el8 >

let System/show =
      \(s : System) -> merge { el6 = "el6", el7 = "el7", el8 = "el8" } s

let Version = < py27 | py38 >

let Version/show = \(v : Version) -> merge { py27 = "py27", py38 = "py38" } v

let Backend = < sqlite | posgresql >

let Backend/show =
      \(b : Backend) -> merge { sqlite = "sqlite", posgresql = "posgresql" } b

let isEl6 =
          \(system : System)
      ->  merge { el6 = True, el7 = False, el8 = False } system

let isPy3 = \(version : Version) -> merge { py27 = False, py38 = True } version

let Input
    : Type
    = { versions : List Version
      , systems : List System
      , backends : List Backend
      }

let JobVars
    : Type
    = { system : System, version : Version, backend : Backend }

let Filter
    : Type
    = forall (job : JobVars) -> Bool

let filter-jobs =
          \(filters : List Filter)
      ->  \(jobs : List JobVars)
      ->  let match =
                    \(job : JobVars)
                ->  List/fold
                      Filter
                      filters
                      Bool
                      (\(f : Filter) -> \(r : Bool) -> r && f job == False)
                      True

          in  Prelude.List.filter JobVars match jobs

let generate
    : forall (input : Input) -> List JobVars
    =     \(input : Input)
      ->  let flatten-job = Prelude.List.concat JobVars

          let combine =
                    \(a : Type)
                ->  \(l : List a)
                ->  \(f : a -> List JobVars)
                ->  flatten-job (List/map a (List JobVars) f l)

          let combine-versions = combine Version input.versions

          let combine-systems = combine System input.systems

          let combine-backends = combine Backend input.backends

          let create-variant =
                    \(v : Version)
                ->  \(s : System)
                ->  \(b : Backend)
                ->  { version = v, system = s, backend = b }

          in  combine-versions
                (     \(v : Version)
                  ->  combine-systems
                        (     \(s : System)
                          ->  combine-backends
                                (\(b : Backend) -> [ create-variant v s b ])
                        )
                )

let Job
    : Type
    = { job : { name : Text, vars : JobVars } }

let renderJob =
          \(job : JobVars)
      ->  { job =
              { name =
                  Prelude.Text.concatSep
                    "-"
                    [ "tox"
                    , Version/show job.version
                    , Backend/show job.backend
                    , System/show job.system
                    ]
              , vars = job
              }
          }

let renderJobs = List/map JobVars Job renderJob

let generateJobMatrix =
          \(filters : List Filter)
      ->  \(matrix : Input)
      ->  renderJobs (filter-jobs filters (generate matrix))

let filterPy3ForEl6 = \(job : JobVars) -> isEl6 job.system && isPy3 job.version

let my-jobs =
        { versions = [ Version.py27, Version.py38 ]
        , systems = [ System.el6, System.el7, System.el8 ]
        , backends = [ Backend.sqlite, Backend.posgresql ]
        }
      : Input

in  generateJobMatrix [ filterPy3ForEl6 ] my-jobs

structured-output.dhall

let List/map =
      https://prelude.dhall-lang.org/v11.1.0/List/map sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680

let List/drop =
      https://raw.githubusercontent.com/dhall-lang/dhall-lang/master/Prelude/List/drop sha256:af983ba3ead494dd72beed05c0f3a17c36a4244adedf7ced502c6512196ed0cf

let JobVars
    : Type
    = List { mapKey : Text, mapValue : Text }

let Job
    : Type
    = { job : { name : Text, vars : Optional JobVars } }

let get-vars =
          \(vars : Optional JobVars)
      ->  Optional/fold
            JobVars
            vars
            JobVars
            (\(x : JobVars) -> x)
            ([] : JobVars)

let {- Add job variant and expand name -}
    apply-variant =
          \(jobs : List Job)
      ->  \(variantName : Text)
      ->  \(input : Text)
      ->  List/map
            Job
            Job
            (     \(job : Job)
              ->  { job =
                      { name = job.job.name ++ "-" ++ input
                      , vars =
                          Some
                            (   [ { mapKey = variantName, mapValue = input } ]
                              # get-vars job.job.vars
                            )
                      }
                  }
            )
            jobs

let head =
          \(variant : List Text)
      ->  Optional/fold
            Text
            (List/head Text variant)
            Text
            (\(variant : Text) -> variant)
            ""

let tail = \(variant : List Text) -> List/drop 1 Text variant

let apply-variants
    : forall (input : List Text) -> forall (jobs : List Job) -> List Job
    =     \(input : List Text)
      ->  \(jobs : List Job)
      ->  let flatten-job = https://prelude.dhall-lang.org/List/concat Job

          in  flatten-job
                ( List/map
                    Text
                    (List Job)
                    (apply-variant jobs (head input))
                    (tail input)
                )

let final
    : forall (input : List (List Text)) -> List Job
    =     \(input : List (List Text))
      ->  let variants = List/reverse (List Text) input

          in  List/fold
                (List Text)
                variants
                (List Job)
                apply-variants
                ([ { job = { name = "tox", vars = None JobVars } } ] : List Job)

in  final
      [ [ "version", "py27", "py38" ]
      , [ "backend", "posgresql", "sqlite" ]
      , [ "system", "el6", "el7" ]
      ]