object expression with interface chain

gistfile1.txt

type IOOP = abstract Mutate: unit -> unit
type IFunctional<'T> = abstract Reduce: 'T list * ('T -> 'T -> 'T) -> 'T

type ProgramThatMatters = 
    static member Run<'T, 'a when 'a :> IOOP and 'a :> IFunctional<'T>>(paradigm: 'a) = ()

let myCode = {
    new IFunctional<int> with
        member __.Reduce(xs, f) = List.reduce f xs 
    interface IOOP with
        member __.Mutate() = ()
}

ProgramThatMatters.Run myCode

//fails to compile with 
// Error	1	The type 'IFunctional<int>' is not compatible with the type 'IOOP'	...

Workaround:

type ICombine<'T> =
    inherit IOOP
    inherit IFunctional<'T>

let myCode = {
    new ICombine<int>
    interface IFunctional<int> with
        member __.Reduce(xs, f) = List.reduce f xs 
    interface IOOP with
        member __.Mutate() = ()
}

Spec (section 6.3.8):

let obj4 =
    { new System.Object() with
        member x.Finalize() = printfn "Finalize";
      interface System.IDisposable with
        member x.Dispose() = printfn "Dispose"; }

An object expression can specify additional interfaces beyond those required to fulfill the abstract slots of the type being implemented. For example, obj4 in the preceding examples has static type System.Object but the object additionally implements the interface System.IDisposable. The additional interfaces are not part of the static type of the overall expression, but can be revealed through type tests.