Conditional contract definition

[oneingan]

Hi I'm trying to get sense of nickel and also CUE while model some IaC composition. I'm really noob in this. I'd like to model a record where properties field (commented line in below example) depends of type field value:

let Component = {
  name | Str,
  type | [| `webservice, `database |],
  #properties | webserverProperties OR databaseProperties OR .... xProperties
} in
let Application = {
  spec.components | Array Component,
} in
Application

have sense what i'm looking for? or maybe I need to model data different?

[oneingan]

Well, I've found a not scalable solution, but at least i'm starting to understand.

let webserviceProperties = {
  image | Str,
  port | Num,
} in

let Properties = fun t =>
  if t == "webservice" then webserviceProperties
  else contract.blame_with "unknown component %{t}" in

let Component = {
  name | Str,
  type | [| `webservice, `database |],
  properties | Properties type,
} in
let Application = {
  spec.components | Array Component,
} in
Application

[yannham]

Hi!

I think this is related to #459. Indeed CUE does have a specific constructs to conditionally define part of contract depending on other fields. It's not totally obvious how to implement this for Nickel, so for now, we don't have that yet.

I think your approach is actually not that bad 🙂 since you can write arbitrary expressions for contract, if you'd like, you can actually inline the condition, which in the end kinda resembles the if construct of CUE:

let Component = {
  name | Str,
  type | [| `webservice, `database |],
  properties
    | (if (type == `webservice) then
        webserviceProperties
      else
        databaseProperties),
} in

It's maybe not totally satisfying, but at least the logic is right inside the contract. Another slight variation is to define a function for that:

let If = fun exp then_body else_body => if exp then then_body else else_body in
let Component = {
  name | Str,
  type | [| `webservice, `database |],
  properties
    | If (type == `webservice)
        webserviceProperties
        databaseProperties,
} in

You can use a switch if you have more than one condition:

let Component = {
  name | Str,
  type | [| `webservice, `database, `foobar |],
  properties
    | (switch {
        `type => webserviceProperties,
        `database => databaseProperties,
        `fooobar => foobarProperties,
        } type),
} in

There are a few quirks, like if you want properties to be absent if type is `database, this is currently not entirely possible, because a contract can't "undefine" a field. But we do have optional fields in Nickel. Maybe we can use them to get the same effect in some way?

[oneingan]

Great! Switch looks what I'm looking for. Some sort of pattern matching i guess. I miss that in documentation.

[yannham]

Currently they are only available for enum tags like `` foo , but will most probably be a proper matching operator eventually. See #817.