Update statement

[ronnygunawan]

I'm proposing a new syntax which allows mutating multiple fields or properties of an object in one statement.

update_statement
    : 'update' primary_expression '{' updater_list '}' ';'
    ;

updater_list
    : updater
    | updater ',' updater_list
    ;

updater
    : identifier_with_setter '=' expression
    | identifier_with_getter ':' '{' updater_list '}'
    ;

The token update is a new keyword.

Each identifier_with_setter and identifier_with_getter on the left of an updater must bind to an accessible instance field or property of the type of the primary_expression. There may be no duplicated name among these identifiers of a given updater_list.

This statement does not create a new copy of the object referenced by primary_expression.

An update_statement of the form

update e0 { identifier1 = e1, identifier2 = e2, ... } ;

is translated to

e0.identifier1 = e1;
e0.identifier2 = e2;
...

An update_statement of the form

update e0 { identifier0 : { identifier1 = e1 }, ... } ;

is translated to

e0.identifier0.identifier1 = e1;

The construct is supposed to be analogous to object initializer and record withing.

class A {
    public int X { get; set; }
    public B Y { get; set; }
    pubic List<int> Z { get; } = new List<int>();
}

class B {
    public string S { get; set; }
}

// object initializer
var obj = new A {
    X = 1,
    Y = new B {
        S = "asd"
    },
    Z = { 1, 2, 3 }
};

// record withing
obj = obj with {
    X = 2,
    Y = obj.Y with {
        S = "qwe"
    }
};

// object updater
update obj {
    X = 2,
    Y: {
        S = "qwe"
    }
};

// updating Y instead of Y.S
update obj {
    Y = new B {
        S = "qwe"
    }
}

Motivation

Code analyzer suggests to simplify object initialization, making it easier for us to spot duplicate initializations. But we can't do the same to object updates. This syntax is intended to help us better organize code that updates an object.

var obj = GetOrDefault();
if (obj is null) {
    obj = new Person();
    obj.Name = name;
    obj.Age = age;
} else {
    obj.Name = name;
    obj.Age = age;
}
return obj;

is refactored by current analyzer to

var obj = GetOrDefault();
if (obj is null) {
    obj = new Person {
        Name = name,
        Age = age
    }
} else {
    obj.Name = name;
    obj.Age = age;
}
return obj;

and I think it would be really nice if we can also refactor it to

var obj = GetOrDefault();
if (obj is null) {
    obj = new Person {
        Name = name,
        Age = age
    }
} else {
    update obj {
        Name = name,
        Age = age
    };
}
return obj;

[yaakov-h]

I'm confused by the motivation section. Why not simplify it to:

var obj = GetOrDefault() ?? new Person();
obj.Name = name;
obj.Age = age;
return obj;

?

[ronnygunawan]

When the obj has so many properties to update, sometimes we update same property twice, or miss updating a property due to switch and if clutters. By using update statement we can just hit ctrl-space to find out which properties have not been updated. Using an update statement ensures that all properties are updated at adjacent lines and no property is updated more than once in the statement.

[yaakov-h]

So your proposal includes desired intellisense behaviour that isn't defined in your proposal?

[ronnygunawan]

The restriction that no identifier may be duplicated among an updater list is defined in the proposal, but the desired intellisense behavior isn't. I think it's common sense and I apologize that I included it in my previous argument. I'm crossing that off.

[iam3yal]

Would have been nicer if we could just do something like this:

obj as {
    Name = name,
    Age = age
}

and then change the example made by @yaakov-h to the following:

var obj = GetOrDefault() ?? new Person() as {
    Name = name,
    Age = age
}
return obj;

or even your example to this:

var obj = GetOrDefault();
if (obj is null) {
    obj = new Person {
        Name = name,
        Age = age
    }
} else {
    obj as {
        Name = name,
        Age = age
    };
}
return obj;

So instead of having it as a prefix to make it an infix, I think it's slightly more useful.

Not sure about the syntax but yeah, just a thought.

[ronnygunawan]

@eyalsk does your syntax mutate object's properties in place or does it create a new copy of the object like record's with does?

[iam3yal]

@ronnygunawan it's a syntactic sugar to the following:

obj.Name = name;
obj.Age = age;

So it just a convenient way to set the properties for the instance in bulk, nothing more.

[ronnygunawan]

@eyalsk

So instead of having it as a prefix to make it an infix, I think it's slightly more useful.

Good idea. The keyword as can also act as null conditional too.

obj = obj as {
    Name = name,
    Age = age
};

can be translated to:

if (obj != null) {
    obj.Name = name;
    obj.Age = age;
}

We can also try to cast obj first before mutating it:

var student = obj as Student {
    Name = name,
    Age = age,
    Grade = grade
};

which will be translated to:

if (obj is Student student) {
    student.Name = name;
    student.Age = age;
    student.Grade = grade;
}

My only concern is whether keyword as is clear enough to state that this syntax is an object mutation. In Javascript and Kotlin, the keyword for this syntax is apply, though I think apply would be an awkward english when used as an infix operator:

obj = obj apply {
    ...
};

var student = (obj as Student) apply {
    ...
};

var obj = (GetOrDefault() ?? new Person()) apply {
    ...
};

[iam3yal]

@ronnygunawan Well, I dunno enough keywords are used in C# for different things so it's all about knowing what it does in a given context.

[HaloFour]

When the obj has so many properties to update, sometimes we update same property twice, or miss updating a property due to switch and if clutters.

Sounds like a good use case for an analyzer that can detect duplicate reassignments.

Having a dedicated syntax for mutating an instance in place via object initializer sounds a bit unnecessary. Having an expression form also feels really confusing as it would seem to create a new instance, not change the existing instance.

IMO I'd like to see a way to apply initializers to expressions. This has come up before where people want to initialize a class returned by a factory. If the language supported that it should be very easy to add an identity factory that just returns the same instance that you pass to it.