Allow referencing of the original object inside a with expression

[devmattr]

Quick and simple, in case it's a silly idea.
Here i've used the imagined 'original' keyword to illustrate what I want.

record Class
{
      public ImmutableList<string> Students {get;init}
     
      // ... a bunch of other properties
}

UpdateClass(GetClass(classId) with { Students = original.Students.Add(newStudent) } );

I can't see a way currently to do this operation without first storing the result of GetClass(classId) on a separate line.

Edit:

One problem with the above is it requires a new keyword (and I dont think you could recycle an existing one).
Perhaps some mechanism to define an inline variable that is filled with the original.

Eg: GetClass(classId) with (original) { Students = original.Students.Add(newStudent) }

Where original would be scoped just to the inside of the following object initializer. (i'm not a fan of how other inlining var declarations have nonintuitive scope and can 'leak' into subsequent operations where they aren't needed)

[colejohnson66]

What's wrong with just storing it in a local variable? That's what the compiler would have to do in order to allow what you're suggesting.

[devmattr]

You could say the same thing about out var newVar, and is Type newVar etc

This proposal is just a bit more syntactic sugar, as many changes to c# have been.

[HaloFour]

As one language designer once said, "too much syntax sugar leads to syntax cavities." The proposal needs to be justified on its own, regardless of how many other language features are just syntax sugar.

That's not a statement for or against this particular proposal, it will have to be weighed on it's own. For instance, the syntax you suggested is already legal syntax in C#.

[devmattr]

Yeah, while I was just trying to suggest there is value in syntactic sugar, I don't mean to imply it should be justified automatically by the fact there are "similar" looking instances already in.

[AndersKehlet]

I think this generalizes to piping essentially.
Imagine something like

GetClass(classId) |> (@class => @class with { Students = @class.Students.Add(newStudent) }) |> UpdateClass

Depending on your relationship with C# you could do something like the following, though some may consider it abusive.

GetClass(classId)
    .Apply(Class.AddStudent.Apply(newStudent))
    .Apply(UpdateClass);

[devmattr]

Yeah I'm up for a more generalized inlining feature. I like both concepts shown here, but I'd probably still just call UpdateClass normally, given its not a transformer of an input.

Something like UpdateClass(GetClass(classId).Apply(@class => @class with { Students = @class.Students.Add(newStudent) }));

I've not seen either concepts you've posted above, are you able to elaborate at all? are either of them styles already commonly used in c# ? or other languages?

[AndersKehlet]

Piping is common in programming languages in general. It's also called function application (you apply a function to a value). Typically scripting and FP languages will have a pipe operator. You could look at F# for an example close to home.

The second example was me being a bit cheeky. It's possible to do currently, but is not typical C#. The least offensive part of it is having an Apply extension on T that effectively acts like a pipe operator.

Here's the example in full:

using System.Collections.Immutable;

static class Extensions
{
    // Partial application / currying
    public static Func<U, TResult> Apply<T, U, TResult>(this Func<T, U, TResult> func, T arg) =>
        arg2 => func(arg, arg2);

    // Pipe operator
    public static TResult Apply<T, TResult>(this T arg, Func<T, TResult> func) => func(arg);
}

record struct Unit;

record Class(ImmutableList<string> Students)
{
    // Necessary to do it like this for partial application to work. This is the part you shouldn't use in production code.
    public static readonly Func<string, Class, Class> AddStudent = (student, @class) =>
        @class with { Students = @class.Students.Add(student) };
}

static class DataStore
{
    public static Class GetClass(string className) => new([]);
    public static Unit UpdateClass(Class @class) => default;
}

static class Program
{
    public static void Main(string[] args)
    {
        var classId = "test";
        var newStudent = "test";

        DataStore.GetClass(classId)
                 .Apply(Class.AddStudent.Apply(newStudent))
                 .Apply(DataStore.UpdateClass);
    }
}