How do I validate an Enum with a Regex?

[SublunarSage]

Hello there! I'm an aspiring game developer that's been using Pkl for a couple days now, and I'm really enjoying how it works so far! It feels a lot more versatile compared to cue, and seems very capable for what I'm using it for. Thus, I hope I'm not asking an unusual question, but I want to know if it's possible to validate an Enum's values with some Regex, and if it is possible, how to do it. To give an example of what I'm talking about, let's say I have a file like this:

typealias StatusEnum = "STATUS_BLEED" | "STATUS_COLD" | "STATUS_RAGE"
StatusRegex = Regex(#"^STATUS_([A-Z0-9_]+)$"#)

What I want to do is to use StatusRegex to constrain the values of StatusEnum so that, if someone were to accidentally add a status like "STRRATUS_Frozen", it would immediately throw an error of some kind (either in the IDE or on evaluation) saying that the malformed status isn't in the correct syntax.

To give a bit of context, I'm using the StatusEnum's as a sort of Identification system for figuring out what statuses to apply onto skills (which are also formed in Pkl), since that seems like the best way of doing it in my mind.

Thank you for your consideration!

[HT154]

Hi there! Glad to hear you're enjoying using Pkl 😁

If I'm interpreting your question correctly, you want to add some kind of assertion that the string literal types that are members of the StatusEnum union match a certain pattern. There isn't a super straightforward way to do this, but it is possible with Pkl's reflection library. Here's how:

import "pkl:reflect"

status: StatusEnum = "STATUS_BLEED"

typealias _StatusEnum = "STATUS_BLEED" | "STATUS_COLD" | "STATUS_RAGE" | "STATUS_Frozen"
hidden const statusRegex = Regex(#"^STATUS_([A-Z0-9_]+)$"#)
typealias StatusEnum =
  _StatusEnum(
    (reflect.TypeAlias(_StatusEnum).referent as reflect.UnionType).members.every((it) ->
      let (enumCase = (it as reflect.StringLiteralType).value)
        enumCase.matches(statusRegex)
          || throw(
            "StatusEnum case \(enumCase) does not match required pattern `\(statusRegex.pattern))`"
          )
    ),
  )

Attempting to evaluate this results in a helpful error:

–– Pkl Error ––
StatusEnum case STATUS_Frozen does not match required pattern `^STATUS_([A-Z0-9_]+)$)`
...

As you can see, this requires a little bit of indirection in the form of a second typealias. While this doesn't provide errors in-IDE (as the tools can only analyze simple constraints), but it does preserve the ability to autocomplete values of type StatusEnum.

[SublunarSage]

This is perfect! Thank you so, so much! I've been having a ton of trouble trying to figure this out, and you come in with a response so quickly. Now I just need to figure out how to turn this into a generic function (if I can, at least) so I can verify some other enums with similar patterns (such as FUNC_APPLY_STATUS, CHECK_VARIABLE, LOGIC_GREATER_OR_EQUAL, etc).

By the way, how did you figure out the answer? Was it just through looking at the pkl docs?

[HT154]

If you want to turn this into something more reusable, it might look like this:

typealias _StatusEnum = // ...
typealias StatusEnum = _StatusEnum(hasValidCases(_StatusEnum, Regex(#"^STATUS_([A-Z0-9_]+)$"#)))

typealias _SomeOtherEnum = // ...
typealias SomeOtherEnum = _SomeOtherEnum(hasValidCases(_SomeOtherEnum, Regex(#"^SOMETHING_([A-Z0-9_]+)$"#)))

const function hasValidCases(alias: TypeAlias, regex: Regex): Boolean =
  let (mirror = reflect.TypeAlias(alias))
    (mirror.referent as reflect.UnionType).members.every((it) ->
      let (enumCase = (it as reflect.StringLiteralType).value)
        enumCase.matches(regex)
          || throw(
            "\(mirror.name) case \(enumCase) does not match required pattern `\(regex.pattern))`"
          )
    )

I was able to figure this out pretty quickly because I've been working with Pkl for a few years now and it's been my full time job for a few months! I've also worked on tangentially related problems with pkl:reflect (such as pkl-go and pkl-swift's code generators, both implemented in Pkl!) so I was already familiar with its capabilities.

[SublunarSage]

Wow! Again, thank you so much for your hard work! I'm incredibly grateful for this work. Now I feel like I can really go full-steam ahead on getting some of the more advanced systems done in the project I'm working on. If I ever have trouble again, I hope I'll be able to come to you for guidance.