"Cannot tell which parent to amend" when using typed parameter in function

[chrisvander]

Hi; let's say I have a need for nesting an object as per a config specification. So I have two classes, a wrapper "parent", and the "body" or main configuration. And let's say, since I'm publishing this as a module and want to configuration to be easy + flat for the user of my module, I make a function to create the class.

class Obj {
  name: String
  body: ObjBody
}

class ObjBody {
  value: Number
}

function create(nameParam: String, bodyParam: ObjBody) = new Obj {
  name = nameParam
  body = bodyParam
}

I would like to use the create() function as way to instantiate the object. In my module's docs I could recommend using it. Let's say my module is called obj for simplicity.

The experience isn't perfect. I would have thought newObj = obj.create("test", new { value = 2 }) would work, but that results in the error "Cannot tell which parent to amend." So, the user would have to type the more verbose newObj = obj.create("test", new obj.ObjBody { value = 2 }).

I kind of want the usage of ObjBody to be hidden to the user of my module; it's not relevant. All they need to know is they're making an Obj. Will this use case be supported? Is there an alternative that I'm not thinking of here?

[translatenix]

What's the purpose of ObjBody? Could you instead define a data structure that's right for your users and have them create it directly?
If necessary, you can transform the data structure before you render it.

[chrisvander]

Yeah, I see what you're saying. My concern is key conflicts. I'm working on this for terraform, so for something like a domain record, there's the resource, the Terraform name, and the record name. Both record name and resource name share the key "name". I could do the backtick trick, but for the resource and Terraform name, it feels that a function would be more ergonomic.

Why would Pkl not be able to infer the class type with new?

[translatenix]

Not sure, but it doesn’t seem straightforward for a dynamically typed language.

I wonder if you could rename conflicting properties instead of having nested properties.
If that’s not an option, perhaps a plain object literal is the lesser evil:
new obj.Obj { name = “test”; body { value = 2 } }

[chrisvander]

Renaming conflicting values to keep it flat is probably the best way to go, if I can figure that out. I just wonder, if the function has a specific type that it takes in the function, why would new {} not be able to figure out that ObjBody is the parent? It works in an object sense, like you just showed, where new obj.Obj { name = “test”; body { value = 2 } } lets Pkl figure out that the body parameter must be of class ObjBody, and doesn't require (but can optionally be added) the new keyword or the explicit new obj.ObjBody to figure it out. What makes the function different?