What if F# supported higher-kinded polymorphism?

Higher-Kinded F#

// Functor interface.
type Functor<'F> = { map : ('T -> 'U) -> 'F<'T> -> 'F<'U> }
 
// Monad interface.
type Monad<'M> = {
    return : 'T -> 'M<'T>
    join : 'M<'M<'T>> -> 'M<'T>
}
 
// Monad "library" (operations over monads).
// Assuming:
//  - higher-kinded polymorphism 
//  - polymorphic fields (existentially quantified)
type MonadUtils<'M> = {
    bind : 'M<'T> -> ('T -> 'M<'S>) -> 'M<'S>
    sequence : Seq<'M<'T>> -> 'M<List<'T>>
}
 
// Function for building a Monad Utils "library".
let buildMonadUtils (M: Monad<'M>) (F: Functor<'F>) =
    let bind m g = M.join (F.map g m)
    let rec sequence = function
        | []        -> M.return
        | x :: xs   -> bind x (fun y -> bind (sequence xs) (fun ys -> y :: ys))
    {
        bind = bind
        sequence = List.ofSeq >> sequence 
    }
 
// Functor instance for option types.
let optionFunctor = {map = Option.map}
 
// Monad instance for option types.
let optionMonad = 
    let join = function
        | Some x    -> x
        | _         -> None
    {return = Some; join = join}
 
// Builds the monad library for option types.
let OM = buildMonadUtils optionFunctor optionMonad
 
 
OM.sequence [Some 42 Some 11]