(this[0]) adding a new element to a listing instead of amending it

[della-90]

Say I have the following classes:

class KafkaConfiguration {
    brokers: Listing<Broker>
    client_id: String
}

class Broker {
    uri: String
}

my_broker: KafkaConfiguration

And the following toy config files:

1. File kafka-broker-test.pkl

   amends "Kafka.pkl"
   
   my_broker = new KafkaConfiguration {
       brokers = new {
           new {
               uri = "testserver1"
           }
       }
       client_id = "myclientid"
   }
   

2. File: kafka-broker-prod.pkl

   amends "kafka-broker-test.pkl"
    
   my_broker {
       brokers {
           (this[0]) {
               uri = "prodserver1"
           }
       }
   }
   

When I evaluate kafka-broker-prod.pkl (pkl eval kafka-broker-prod.pkl), I get:

my_broker {
  brokers {
    new {
      uri = "testserver1"
    }
    new {
      uri = "prodserver1"
    }
  }
  client_id = "myclientid"
}

Now, leaving aside that I could write kafka-broker-prod.pkl in other ways, what I'm wondering is why (this[0]) { ... } ends up adding a new item to the listing instead of amending the first item from kafka-broker-test.pkl.

What I think is happening is that this[0] actually refers to a hypothetical first element in the kafka-broker-prod.pkl's brokers listing itself, and since it's not there, the instruction is interpreted as a shorthand instantiation. What throws me off, though, is that if I add a trace, I get the following: pkl: TRACE: this[0] = new Broker { uri = "testserver1" } (.../kafka-broker-prod.pkl, line 5), i.e. the entry from the -test file.

[translatenix]

I think (this[0]) {...} adds a new element that amends the inherited testserver1. I'm not sure how to amend testserver1 in place. It would be more obvious with a Mapping.

[della-90]

in order to amend it in place I can just use [0], which adds to my confusion on why (this[0]) doesn't work:

amends "kafka-broker-test.pkl"
 
my_broker {
    brokers {
        [0] {
            uri = "prodserver1"
        }
    }
}

this produces:

my_broker {
  brokers {
    new {
      uri = "prodserver1"
    }
  }
  client_id = "myclientid"
}

[StefMa]

According to the docs that is what I would expect 🤔.
Using (this[0]) means create a new item while inheriat the first element. If you want, you can change the new created item to your needs. So only overrides the properties you need.

[della-90]

The only example I could find in the docs is in the late binding section, but that’s just creating a new listing, not amending one. I had a look at the grammar, and I think that syntax should be an amendExpr, though I’ve never used Antlr so I may be wrong

[translatenix]

The myListing { myExpr } syntax adds an element. To overwrite an element, you need to use the myListing { [index] = myExpr } syntax.

[della-90]

Thanks for clarifying that! I’m wondering why this amends the item instead of adding a new one though:

amends "kafka-broker-test.pkl"
 
my_broker {
    brokers {
        [0] {
            uri = "prodserver1"
        }
    }
}

[bioball]

This syntax:

brokers {
  (this[0]) {
    uri = "prodserver1"
  }
}

Means: declare a new element. The element's value is (this[0]) { uri = "prodserver" }.
So, here, you are creating a new element, rather than amending an existing element.

It might be clearer if you reduce it to:

brokers {
  this[0]
}

This is basically the same thing. The only difference is, in your example, you are amending this[0] also.

If you want to amend an existing element, you can either use [<index>] {, like what @translatenix suggested. Alternatively, you can use a member predicate. Member predicates tend to be less brittle.

brokers {
  [[this.uri.startsWith("test")]] {
     uri = "prodserver1"
  }
}

[della-90]

Thanks for your reply @bioball. So is it correct to say that (this[index]) { ... } has a unique behaviour that differs from just [index] { ... }: The former always creates a new element (by amending the element at position index), while the latter is an "amends expression" (i.e. it doesn't create a new element but instead it just amends the one at position index)?

[bioball]

Yeah, they are semantically different.

while the latter is an "amends expression" (i.e. it doesn't create a new element but instead it just amends the one at position index)?

No, the former is an amends expression. Amends expressions have the form (<expr> ) { ... }.
The latter is not an expression at all. It is an object member, specifically, an object member that means: "amend the element at index 0".