Struct representations for active patterns limitations

[kevmal]

I would expect to be able to simply switch an existing active pattern to use structs but it seems limited. Any reason for restricting use to top level active patterns? Would be nice to be able to do the following:

let f1() = 
    [<return: Struct>]
    let (|AP|_|) (x : int) = 
         ...
    ...

or

let f2 ([<return: Struct>] ``|AP|_|``) = 
    ...

[Happypig375]

The first one is fsharp/fslang-suggestions#848 while the second one can already be done:

let f2 ((|AP|_|): _ -> _ voption) = 
    match 1 with AP 1 -> 1 | _ -> 2

[kevmal]

It's great that f2 works, and it's actually preferable to an attribute but it seems a bit inconsistent... I can (and probably will) do

let f1() = 
    match 
        (fun x -> 
            if x > 100 then 
                ValueSome 1 
            else 
                ValueNone
        ) with 
    | ``|AP|_|`` ->
    match 1 with AP 1 -> 1 | _ -> 2

yet a simple let binding would give an error.

[dsyme]

I'll close this per @Happypig375's comment #12389 (comment)

[Happypig375]

@kevmal

let f1() =
    fun x ->
        if x > 100 then 
            ValueSome 1 
        else 
            ValueNone
    |> fun (|AP|_|) ->
    match 1 with AP 1 -> 1 | _ -> 2

[kevmal]

@dsyme Does that mean fsharp/fslang-suggestions#848 is approved?

[dsyme]

Ah my mistake, I thought the link was referring to the idea of simply inferring structness from return type here fsharp/fslang-suggestions#1041 (comment)