Why can't we satisfy F# static member constraints with type extensions?

Question

I'd like to be able to extend types from other libraries with static methods to enable generic arithmetic. Take, for example, the newly minted SIMD-friendly fixed-size VectorN types from Microsoft. They define Zero, they define (+), they define (/), but I can't use Array.average on them because they don't define DivideByInt, which I'd be happy to:

open System.Numerics
type Vector2f with 
  static member DivideByInt (v:Vector2f) (i:int) = v / Vector2f(single i, single i)
let bigArray : Vector2f[] = readABigFile()
printf "the average is %A" (Array.average bigArray)

But it won't let me compile, complaining

error FS0001: The type 'Vector2f' does not support the operator 'DivideByInt'

Why does this limitation exist in the F# compiler?

(Edit: essentially the same question was asked previously.)

Vivavivace

I suspect that DivideByInt needs to be an operator rather than a function. Maybe try either defining an operator, or I think op_DivideByInt might work. – Nosology

DivideByInt isn't a valid name for an operator in F# – Vivavivace

Does doing DivideByInt (v:Vector2f,i:int) (tuple form) work? I have got a minimal example with type extensions that works. – Nosology

Looking at the source will show the constraints you need to satisfy: github.com/fsharp/fsharp/blob/master/src/fsharp/FSharp.Core/… – Nosology

No, unfortunately it's not possible. Possible duplicate of #3681642 – Faden

Answer 1

It is not currently possible to define an operator overload in a type extension. There is an F# language user voice item for this (with quite a lot of votes) and so this is something that might change in future versions of F# (I think it would be great addition that fits nicely with the F# design).

If you absolutely need something like this today, you can either create a lightweight wrapper for your type that adds the operators, or you can use a (somewhat scary) trick that lets you hide the standard operator with a new overloaded one. The following question has both examples: Global operator overloading in F#

Papen