How to handle a composite constraint?

[lachlan-shead]

Hey all!

I'm really enjoying Pickle's templating. However, I've come across a case I'm not sure how to deal with: type constraints on multiple class properties.

Imagine I'm building a site that lists data about assorted flora:

class Flower {
  ...
}

class Plant {
  growsFlowers: Boolean = false
  flower: Flower?
  ...
}

I'd like to enforce that (plant.flowers is Null) || plant.growsFlowers is true for any instance of Plant. Since this is a logical constraint on any instance, I want to be able to check this at the template level.

In the template I can only constrain growsFlowers or flowers, not the Plant class itself.

Disclosure: in my real example the growsFlowers equivalent is a typealias for one of several strings, which are intended as a type identifier. Only one has a flower. My current solution is to create classes for each of the types - feels like overkill, since most of them don't need any fields at all. And it means I need to specify the type everywhere it occurs in my instances (I'm working in Python, so no builtin code generator for the time being). But it works.

Edit: I have since also tried creating my final result (plants: List<Plant>), then mapping them to check the condition on each one. But this means my highest-level files are severely coupled with lower-level implementation details. Also, I get a type error at the point of running the map function, which tells me nothing about which record caused the problem.

All the alternatives I've considered either don't work or seem super ugly. Here are a few examples:

1. Using a variation of when generators in a template that allows you to reference other instance data:

class Plant {
  growsFlowers: Boolean = false
  when (growsFlowers) { // not currently allowed here
    flower: Flower
  } else {
    flower: Null
  }
}

2. Defining the same shape as Plant in a different object and creating function plantFactory(rawPlant: RawPlant): Plant. This method could throw if the raw data fails the constraint, and convert it to a Plant otherwise. This would work, but introduces frustrating duplication for little benefit.

3. Defining a Mixin, and making it the only way to set growsFlowers true. Doesn't feel like a good idea, but maybe I'm wrong?

Because I'm working with a list of Plants, I also can't use Member predicates (as far as I can tell?).

I'd like to know if there's a recommended way of managing this kind of situation. Thanks!

(Some edits for clarity)

[translatenix]

This should do the trick: flower: Flower(growsFlowers)?

[lachlan-shead]

Thank you! This is almost what I want.

The problem: I can create plant: Plant = new { growsFlowers = true } (with a null Flower), since the type constraint applies only when Flower is applied. Is there a way to make this case throw an error?

[lachlan-shead]

This is the first option that comes to mind: flower: Flower(growsFlowers)?(growsFlowers.implies(this is NonNull)). But it feels a little clunky...

[translatenix]

Earlier you wanted (plant.flower is Null) || plant.growsFlowers, which is
flower: Flower(growsFlowers)?.

Now you want (plant.flower is Null).xor(plant.growsFlowers), which is
flower: Flower?(growsFlowers == (this != null)).

In the latter case, you can derive growsFlowers instead of constraining it:
fixed growsFlowers: Boolean = flower != null

[lachlan-shead]

Apologies for the confusion on my part, and thanks for the help!