I had expected that flexible type would minimize the need of explicit upcast, but

```
type IB =
    abstract B : int

type A() =
    interface IB with
        member this.B = 1

let a = A()

let test (x) = x

let aa = [|a; a|]
let case1 = aa |> Array.map (fun (x: #IB) -> test (x.B))
let case2 = Array.map (fun (x: #IB) -> test (x.B)) aa

```

Here, there are warnings (less generic than type annotation) on the last 2 lines. The compiler is able to compile `case2`, but fails at `case1`, why is that?

It feels odd that the more detailed the compiler can infer, the more code I need to write.

@kvb pointed out there is a simple fix, just to refactor the lambda function into a non inline version.

```
let fix (x: #IB) =
    test x.B

let case1 = aa |> Array.map fix
let case2 = Array.map fix

```

This works well.