Getters/Setters in Pkl?

[joshqou]

Hi. I'm dealing with a project that requires a lot of data that needs to be processed or converted. To make the user-side configuration easier, I'm transforming user-supplied input into corrisponding classes or the correct string/enum/uint representation. My code looks like this:

module com.example.Test
class Test {
    name: String(matches(Regex(#"^[a-z\-]+$"#))) = uri.host
    uri: UriObject = new UriObject { protocol = "example:" host = name }
}

test: Test

amends "./test.pkl"
test {
    name = "hello-world"
}

I like doing things this way to avoid requiring the user-side configs from having to convert every "uri" into a UriObject or transform the input themselves. However, this results in having duplicated and similarly-named properties that only make sense on the user-side (i.e: name) or the processing side (i.e: uri).

This isn't too bad with classes since you can use hidden or local, however this is a pain point for top-level properties. I have quite a few files that have both values (user-side) and valueobjs (processing side).

Ideally, I'd like some way of attaching a setter to a single property that would automatically convert the user input into the corrisponding object. Maybe something like this?

class UriObject {
    @Transform(Uri, (it) -> new UriObject { protocol = "example:" host = it })
    uri: UriObject
}

test {
    // Both of these lines would result in the same output
    uri = "hello-world"
    uri { protocol = "example:" host = "hello-world" }
}

Any feedback or alternate solutions are welcome

[HT154]

I'm not sure I understand this bit:

This isn't too bad with classes since you can use hidden or local, however this is a pain point for top-level properties.

Both of there are valid at the module level (modules are just a special cases of classes after all!) and they function identically.

That said, I think your proposal is actually something you may be able to implement in-language!

The only change you'd need is adding the user-assignable type to the property:

class Test {
    @Transform { from = Uri; using = (it) -> new UriObject { protocol = "example:" host = it } }
    uri: Uri|UriObject
}

Then you could use an output converter applied all Typed objects. This converter would use pkl:reflect to identify properties with the Transform annotation, check their types against the from type, and upon match apply the using function to the value to produce the desired type.

One note, because I haven't actually tried to implement this: you may only be able to use classes (not any type like typealiases) for from, so instead of Uri (which I'm assuming is a type alias over String) you may need to use String directly, which should be fine in this case.

[joshqou]

output doesn't seem to apply when the module is imported :(

[HT154]

Right, output only applies in the module where it's defined and any that extends/amends it. In general, if you're vending a schema of some kind having end-users not amend some module is a bit of an anti-pattern. Provided that is happening, using the annotation like you've suggested provides a single conversion point that should be simple enough to document and maintain. You can also easily import and module's converters and reuse them:

import "something.pkl"

output {
  renderer {
    converters {
      ...something.output.renderer.converters
    }
  }
}

// OR

output {
  renderer {
    converters {
      ...import("something.pkl").output.renderer.converters
    }
  }
}

[HT154]

You can also implement something sort of like setters/builders, eg.

class Test {
  uri: UriObject

  function withUriHost(it: String): Test = (this) {
    uri = new { protocol = "example:"; host = it }
  }
}

local testWithUri = new Test {}.withUriHost("somehost")

[HT154]

But generally in Pkl you want to use properties and default values for this kind of thing:

class Test {
  hidden uriHost: String
  uri: UriObject = new { protocol = "example:"; host = uriHost }
}

// derive uri from the hostname
local testWithUriHost = new Test { uriHost = "somehost" }
// set uri directly
local testWithUri = new Test {
  uri { protocol = "foo"; host = "bar" }
}

In both cases only the value of uri is produced in the output!

[joshqou]

@HT154: In general, if you're vending a schema of some kind having end-users not amend some module is a bit of an anti-pattern. Provided that is happening, using the annotation like you've suggested provides a single conversion point that should be simple enough to document and maintain. You can also easily import and module's converters and reuse them

The reason output doesn't work in my case is because multiple modules need to interact with UriObject. As output only applies at the root module. Intermediate and leaf modules wouldn't be able to extract data or transform UriObjects. Several modules in my project need to deal with UriObjects for normalization or to correctly compare against other UriObjects.

@HT154: You can also implement something sort of like setters/builders, eg.

I'm already using constructor patterns, but primarily in the business logic to avoid reducing the readability of the end-user side. And, given that UriObject is used for a lot of things, and that Pkl doesn't support aliasing or import deconstruction, it would result in a lot of Utils.UriObject.with( or MapObject.MapObject.with( everywhere. If I didn't need to normalize as many values using a constructor would be a good option, but it would look very messy for around ½k of just things that need to be represented as UriObject or an extension of it.

@HT154: But generally in Pkl you want to use properties and default values for this kind of thing: ⋯ In both cases only the value of uri is produced in the output!

I'm already using hidden, however as my output needs custom rendering, it doesn't do much aside from denote protected properties (: