Sparse Class

[discount-elf]

I would like to be able to render a subset of a class relying on the validation for the defined fragment, but not utilizing any defaults for properties for unspecified properties of that class or invalidation due to properties that are not nullable.

Essentially this is to represent a sparse patch to change the state, but rely on the schema for the properties present in the patch

Example:

class Something {
   someString: String
   someDefault: String = whatever
   editedString: String
}

patch: new Something {
  editedString = "patchMe"
}.toPatch()

output ->
patch {
  editedString = "patchMe"
}

I haven't gone that deeply in playing with reflection, it seems like I can't really get around value undefined for non nullable types. class.isDefined("propertyName") would be very useful. Otherwise it seems like my only option to represent a patch is via Dynamic. Any ideas?

[HT154]

This is exactly what Mixins are for!

Using a Mixin, your example looks like this:

class Something {
   someString: String
   someDefault: String = whatever
   editedString: String
}

patch: Mixin<Something> = new {
  editedString = "patchMe"
}

result = mySomething |> patch

[HT154]

Haha beat me to it! You might also be interested in the PR adding Object.toMixin().

[HT154]

I think you might be able to get closer to the user experience you want with a generic typealias and a clever output converter:

class Something {
  someString: String
  someDefault: String = "abc"
  editedString: String(endsWith("Me"))
}

typealias Patch<T> = Mixin<T | Dynamic>

patch: Patch<Something> = new {
  editedString = "patchMe"
}

output {
  renderer {
    converters {
      [Function1] = (it) -> new Dynamic {} |> it // will error rendering non-Patch functions
    }
  }
}

[discount-elf]

Epic! I was just playing with the type alias and trying to figure what type to compare for the convertor :D

[discount-elf]

Is it possible reflect the class of the mixin type parameter?

[HT154]

Unfortunately not. Pkl values don't "capture" their type arguments, so it's not possible to ask a Function1 value "what are your parameter and return types?". It's only possible to ask that of a class/modules property with a type annotation, which doesn't help you much in a value converter. You could convert Typed and use reflection to iterate the object's properties to find ones matching your desired type, but that's a lot of work.

[discount-elf]

This seems to be the best I can do using a wrapper class to pass along the type association:

new bucket.BucketPatch {
  patch { // mixin of Patch<T>
    label = "bucket-to-patch"
    versioningConfiguration = new bucket.VersioningConfiguration {
      status = "Enabled"
    }
  }
}

Sadly if functions could be annotated seems like could just use an annotated mixin :(