Different indentation level changes behaviour of the code

let foo t = "(" + t + ")"

let tttt =
  let text =
    match Some "" with
    | Some t ->
      match t with
      | "" ->
        "a"
      | "b" ->
        "b"
      |> foo
    | _ -> "fooo"
  text  

let tttt' =
    let text =
        match Some "" with
        | Some t ->
            match t with
            | "" ->
                "a"
            | "b" ->
                "b"
            |> foo
        | _ -> "fooo"
    text

In foo I use two spaces for indentation, in foo' four spaces are used.

The resulting expressions are different while I’d had expected those to be the same.

I tried to find something which would explain that in the language specification (which I haven’t thoroughly read) but failed, and the behaviour seems to fail me at “principle of least surprise” so submitting this as an issue to get clarification.

Thanks.

[radekm]

IMO it seems correct - see the specification 15.1.9 Exceptions to the Offside Rules - the first exception:

An infix token may be offside by the size of the token plus one.

Here is a similar example:

let (||>) = (|>)

let () =
    let x =
        match "" with
        | "" -> 1
        | _ ->
            4
        |> (+) 9
    printfn "%A" x

The code prints 10 because the exception doesn’t apply (the expression in the second branch of match is 4).

But if you replace |> by ||> or decrease the indentation of the line with 4 by one space the result will change to 1 because the exception to the offside rule will apply (the expression in the second branch of match will be 4 |> (+) 9).

[dsyme]

@smoothdeveloper We try really, really hard not to add compiler flags that “fork” the language (or even restrict it). It’s possible that adding the warning to FSharpLint or Fantomas or FSharp.Compiler.Service may be the right place.