[: and {: syntax to allow indent-based list/CE scoping

[reinux]

I propose we add syntax to allow indent-based scoping of list expressions and computation expressions, maybe using symbols like [:, seq {:, task {:, [|: etc.:

let view model dispatch =
  Html.html [:
    Html.body [:
      prop.style [:
        style.`foreground-color`.green
        style.`background-color`.yellow
      prop.children [ Html.text "MY EYES!" ]

The existing way of approaching this problem in F# is

let view model dispatch =
  Html.html [
    Html.body [
      prop.style [
        style.`foreground-color`.green
        style.`background-color`.yellow
      prop.children [ Html.text "MY EYES!" ]
    ]
  ]
]

This is a relatively small example, but it's not uncommon to see an explosion of ] ] ] ] not just in view code but also in models of all sorts.

Pros and Cons

The advantages of making this adjustment to F# are

• More in line with F#'s indent aesthetic
• Easier to move code around, e.g. in Elmish views
• Substantial reduction in noise
• Fit a lot more into a screenful vertically
• No need to count closing brackets after structural changes
• Might be a little bit more inviting to Haskellers who are used to using do notation for monads
• We could all use some more smiles

The disadvantages of making this adjustment to F# are ...

• Probably a pretty deep change to the parser, including the need to add tokens, though non-breaking (I think)
• Fantomas will probably have a lot to deal with, if not the LSP or syntax highlighters
• Might be some deal-breaking parsing conflicts that I haven't thought of
• Maybe it's a bit gimmicky? I don't know

Extra information

I've been on a roll lately with ambitious suggestions on various projects, so I acknowledge that this could just be coming from my being in a weird headspace. I promise to take zero offense if the idea is declined outright. Please be ruthless!

Estimated cost (XS, S, M, L, XL, XXL):
L

Affidavit (please submit!)

Please tick these items by placing a cross in the box:

• [x] This is not a question (e.g. like one you might ask on StackOverflow) and I have searched StackOverflow for discussions of this issue
• [x] This is a language change and not purely a tooling change (e.g. compiler bug, editor support, warning/error messages, new warning, non-breaking optimisation) belonging to the compiler and tooling repository
• [x] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it
• [x] I have searched both open and closed suggestions on this site and believe this is not a duplicate

Please tick all that apply:

• [x] This is not a breaking change to the F# language design
• [x] I or my company would be willing to help implement and/or test this

For Readers

If you would like to see this issue implemented, please click the :+1: emoji on this issue. These counts are used to generally order the suggestions by engagement.

[vzarytovskii]

I don't think we want to pursue it at this point. Are there examples of this feature in other languages?

[reinux]

Yeah, I figured it was kind of a long-shot.

I'm not sure it's in use anywhere else. The closest I can think of is Haskell's do notation.