Overriding type constraints further down a hierarchy

[kallekoo]

Hello

I was wondering if it's possible to have a type constraint evaluate lazily, while having a base structure where some fields of base class, or a module, are overridden further down a file hierarchy.

Here's an example which works, but the type constraint definition has to be repeated for each overriding file.

BaseClass.pkl

const hidden IsPrefixInAnotherCollection: Boolean = false
// const hidden IsPrefixInAnotherCollection = ((s) -> import("other_module.pkl").the_other_collection.toList().filter((x) -> s.startsWith(x)).length > 0)

open class BaseClassWithMultipleFieldsToOverride {
  name: String
  tags: Listing<String(IsPrefixInAnotherCollection)>?
}

OtherModule.pkl

the_other_collection: Listing<String>

overrides/other_module.pkl

amends ".../OtherModule.pkl"

the_other_collection = new {
    "a"
}

overrides/overriding_base_class.pkl

import ".../BaseClass.pkl" as BC
import "other_module.pkl" as O

hidden const IsPrefixInAnotherCollection = ((s) -> O.the_other_collection.toList().filter((x) -> s.startsWith(x)).length > 0)

class extendedClass extends BC.BaseClassWithMultipleFieldsToOverride {
    tags: Listing<String(IsPrefixInAnotherCollection)>?
}

const the_config: Listing<extendedClass> = new {
  new {
    name = "Name"
    tags {
      "a"
    }
  }
}

Which evaluates to

the_config {
  new {
    name = "Name"
    tags {
      "a"
    }
  }
}

But, I'd want to define the constraint only once, in BaseClass.pkl and then have the overriding module, here overrides/overriding_base_class.pkl, evaluate that constraint using the definition of the_other_collection, from import "other_module.pkl" as O.

Is there a language feature I'm missing? Thank you.

[bioball]

So you have two unrelated modules, but you want to express a constraint between those two?

The most straightforward solution is to define a property that you then fill in later. Then, you'd define a constraint in terms of that property, for example:

BaseClass.pkl

import "OtherModule.pkl"

hidden myOtherModule: OtherModule

class BaseClassWithMultipleFieldsToOverride {
  name: String
  tags: Listing<String>?
}

the_config: Listing<
  BaseClassWithMultipleFieldsToOverride(
    tags.every((tag) -> 
      myOtherModule
        .the_other_collection
        .any((it) -> tag.startsWith(it)
      )
    )
  )
>

Then at your usage site:

// base_class.pkl

amends ".../BaseClass.pkl"

myOtherModule = import("other_module.pkl")

the_config {
  new {
    name = "Name"
    tags {
      "a"
    }
  }
}

One restriction here is that you have to define the constraint on a module property, rather than a class property (because class properties can only see const members.

[bioball]

Note: to make this even simpler, you can derive myOtherModule with the help of a glob import. This means that you don't need to set its value later on when amending BaseClass.

Example:

import* "**/other_module.pkl" as allOtherModules

import "BaseClass.pkl" // self-import
import "OtherModule.pkl"

local path = BaseClass.relativePathTo(module).join("/")

hidden fixed myOtherModule: OtherModule = allOtherModules["\(path)/other_module.pkl"] // This will import a sibling module called "other_module.pkl"

open class BaseClassWithMultipleFieldsToOverride {
  name: String
  tags: Listing<String>?
}

the_config: Listing<
  BaseClassWithMultipleFieldsToOverride(
    tags.every((tag) -> 
      myOtherModule
        .the_other_collection
        .any((it) -> tag.startsWith(it)
      )
    )
  )
>