[RFC FS-1072] - Support "without"ers for Anonymous Records

[cartermp]

Discuss the withouters RFC here.

[cartermp]

This is the syntax thread.

with- is kinda shitty.

without is a preferred keyword, but to support it would require making it a contextual keyword, which is something that F# doesn't do. And if we made without a contextual keyword, why not also make with a contextual keyword? It can be a slippery slope.

[cartermp]

Perhaps, since there's nothing in inherently wrong with this aside from it being silly code:

let with = {| with = 12 |}
let b = {| with with Doot = 123 |}

If you can do this:

let without = {| doot="or"; without="you" |}
// val without: {| doot: string; without: string |}

let err = {| without without without |}
// val err: {| doot: string |}

then why should you also not be able to do this?

let without = {| with="or"; without="you" |}
// val without: {| with: string; without: string |}

let with = {| without without without |}
// val with: {| with: string |}

[rmunn]

Other suggestions that were mentioned recently ("recently" in this case meaning since Jan 2021) in the fsharp/fslang-suggestions#762 discussion:

In fsharp/fslang-suggestions#762 (comment), @jcmrva suggested using a less-common antonym like sans.

In fsharp/fslang-suggestions#762 (comment), @rmunn suggested using not with, which @jcmrva endorsed in fsharp/fslang-suggestions#762 (comment).

The rest of the comments since Jan 2021 were along the lines of "I don't like with- and something else would be better". The only syntaxes anyone has proposed seem to be the original without proposal, the with- syntax that got several negative responses, not with, and sans.

[rmunn]

Now to offer my opinion: I don't actually like not with now that I think about it, for two reasons:

1. How would the parser handle let foo = {| bar not with x; with y = 5 |}? It seems to me that implementing not with would also require implementing contextual keywords in some form to be able to tell the difference between not with and with in that assignment.
2. The following legal (but extremely silly) code would either become illegal, or would be a nasty corner case for the parser:

let not = {| x = 5; y = 8 |}
let foo = {| not with y = 13 |}
printfn "%A" foo
// Should print x = 5; y = 13

While that's not much different from the without without without example* in terms of parser difficulty, at least without is a single word, as opposed to a keyword pair. A single word is probably (I assume, not having looked at parser internals) a little easier to cope with.

* Which is rapidly approaching "Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo" territory. (If you've never see that sentence before, it's a totally valid sentence according to the rules of English grammar. The challenge is to make sense of it. Hint (rot13): "gb ohssnyb" pna or n ireo zrnavat "gb ohyyl").

[hvester]

If using without is out of the question how about using - in front of the label to be dropped as below?

let data = {| X = 1; Y = "abc"; Z = 6 |}
// val data: {| X: int; Y: string; Z: int |}

let subset = {| data with -Z |}
// val subset: {| X: int; Y: string |}

This would allow adding and dropping labels within one with:

let data = {| X = 1; Y = "abc"; Z = 6; W = 0 |}
// val data: {| W: int; X: int; Y: string; Z: int |}

let subset = {| data with A = 3; -Z; -W |}
// val subset: {| A: int; X: int; Y: string |}

I would prefer this to both with-and not with and would assume that is is more understandable than with- for someone seeing the syntax for the first time.

[uxsoft]

Perhaps, since there's nothing in inherently wrong with this aside from it being silly code:

let with = {| with = 12 |}
let b = {| with with Doot = 123 |}

If you can do this:

let without = {| doot="or"; without="you" |}
// val without: {| doot: string; without: string |}

let err = {| without without without |}
// val err: {| doot: string |}

then why should you also not be able to do this?

let without = {| with="or"; without="you" |}
// val without: {| with: string; without: string |}

let with = {| without without without |}
// val with: {| with: string |}

The IDE should color everything to show if it's a keyword, a property, or a variable. So, even in this silly code, all should be clear to the user?

[dsyme]

I'm ok with without if it can be made to work as a contextual keyword, not making it a full keyword

[uxsoft]

I'm very much not a fan of with-. This mixing of symbols and letters is weird for a keyword, also what happens when people format it as in the English language and put space inbetween (with -)? I reckon the compiler will get confused and will reply with some unhelpful error message that - wasn't expected which will confuse people even more.

I like @baronfel's suggestion to make both with and without a contextual keyword and implement this in a clean and consistent way. If we don't we'll be stuck with this forever as it's much harder to take things out without breaking people than to put them in.

[purkhusid]

Would it be possible to derive an anonymous record from a named record?
E.g. if I have this record

type Donk = { A: int; B: string; C: double }

Then I would like to be able to do something like:

let originalDonk = { A = 1; B = "yo"; C = 2.0 }
let anonymousDerivedDonk = { originalDonk without C }

And now anonymousDerivedDonk would be of the type

{| A: int; B: string |}

[Happypig375]

Existing code:

type Donk = { A: int; B: string; C: double }
let originalDonk = { A = 1; B = "yo"; C = 2.0 }
let anonymousDerivedDonk = {| originalDonk with D = 2 |}

I would think that {| originalDonk without C |} is required instead of { originalDonk without C }.