Proposal: Lambda expression set-only properties

[AustinBryan]

I know we almost never use set-only properties, and, because they have to be side effect driven, some people say that they should never be used and a method should be used instead. Regardless, here is an example of when I'd find it useful:

public class Cube
{
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Z { get; private set; }

    public int Volume => X * Y * Z;

    // Current
    public int Scale { set => X = Y = Z = value; }
    // Proposal
    public int Scale <= X = Y = Z = value;
    // Or
    public int Scale <- X = Y = Z = value;
}

Ideally it would be <= to mirror the get-only =>, but if that gets confusing with the existing boolean operator, maybe something similar like <- .

[stakx]

Hmm, like you said, set-only properties are rare, and not encouraged, so I am not confident that your proposal to expand the language with a construct targeting them will meet much support.

That being said, I find both of your proposed symbols <= and <- problematic because they suggest a meaning other than what you intend. This is quite subjective, but I thought I'd mention it anyway:

• I've always understood lhs => rhs to mean "lhs maps to rhs" in a mathematical sense. I would probably read it the same way if its direction were reversed (<=): "rhs maps to lhs".

• Using <- might be confusing to at least two groups of people: those knowing certain functional languages (such as F#) where that symbol is used for assignment; and those knowing C++ IOStream's left-directed <<. In both cases, people might easily assume that LHS <- rhs means "rhs is being put into LHS".

[AustinBryan]

@stakx I see where your coming from. I see lhs <= rhs as rhs goes to lhs, which is kind of what's going on. The body is what happens when someone tries to put something inside lhs .

At the same time, it isn't as necessary still as => was because that had to have a return inside it, whereas set is only saving a few more characters.

Foo { get { return foo = value; } }   // only setting foo here to make an equal comparision
Foo => foo = value;                   // nearly half the size

Foo { set { foo = value; } }
Foo => foo = value;    // not as big of an improvement

Also, IIRC, Foo => _foo; was allowed before foo { get => _foo; }, right? That would mean it was more needed at the time.

I came across an instance the other day when I could've used a set-only, but then I found a better way to do it. Regardless, it's a feature I wouldn't mind.

[jnm2]

Does the existing syntax (public int Scale { set => X = Y = Z = value; }) seem burdensome for such a rare scenario as this? I would have said it was clearer than the proposed syntax.

[AustinBryan]

@jnm2 Not really, which is why I'm 😕over this myself. Maybe if we could remove the brackets to be cleaner public int Scale set => X = Y = Z = value;, if it's not significantly harder to parse.