(Solved) Silly syntax question

I am not sure how to write something quite trivial :blush:

let Example =
      { Type = { foo : Natural, bar : { name : Text, namespace : Text } }
      , default = { foo = 1, bar.namespace = "test" }
      }

in  

-- Example::{=} with bar.name = "test"
-- Example::{bar.name = "test"}

@PierreR:

let Bar =
      { Type = { name : Text, namespace : Text }, default.namespace = "test" }

let Example =
      { Type = { foo : Natural, bar : Bar.Type }
      , default = { foo = 1, bar = Bar.default }
      }

in  Example::{ bar = Bar::{ name = "test" } }

Record completion currently only works 1 level deep. One thing I would like to eventually do is make it work more than one level deep, but it’s low on my priority list at the moment.

@Gabriel439 thanks for your quick reply.

The limitation is a bit annoying in practice because it forces to expose more complexity (both Example and Bar) to the client code but sure it is not urgent.

If somebody would like to get to this before I do, the main idea for generalizing the feature is to change how the operator desugars. Currently SomeRecord::{ foo.bar = 1, baz = True } desugars to:

(SomeRecord.default // { foo.bar = 1, baz = True }) : SomeRecord.Type

… and you would be able to generalize it to work with nesting by instead desugaring it to:

(SomeRecord.default with foo.bar = 1 with baz = True) : SomeRecord.Type