Yes, I'll file a bug report once I've confirmed what all is actually buggy behavior.

Pardon the annoying spacing; I haven't figured out this site's BBcode support yet.

Anyway, I found some interesting things related to this issue. Take these C# structs:

namespace TestLibrary

{

public struct TestStruct

{

float value;

public float Value { get { return value; } }

public TestStruct(float value)

{

this.value = value;

}

public static TestStruct operator *(float scalar, TestStruct testStruct)

{

return new TestStruct(scalar * testStruct.Value);

}

public static TestStruct Add(TestStruct a, TestStruct b)

{

System.Console.WriteLine("Add by val");

return new TestStruct(a.Value + b.Value);

}

public static void Add(ref TestStruct a, ref TestStruct b, out TestStruct result)

{

System.Console.WriteLine("Add by ref");

result = new TestStruct(a.Value + b.Value);

}

}

public struct JustByVal

{

float value;

public float Value { get { return value; } }

public JustByVal(float value)

{

this.value = value;

}

public static JustByVal operator *(float scalar, JustByVal testStruct)

{

return new JustByVal(scalar * testStruct.Value);

}

public static JustByVal Add(JustByVal a, JustByVal b)

{

System.Console.WriteLine("Add by val");

return new JustByVal(a.Value + b.Value);

}

}

public struct JustByRef

{

float value;

public float Value { get { return value; } }

public JustByRef(float value)

{

this.value = value;

}

public static JustByRef operator *(float scalar, JustByRef testStruct)

{

return new JustByRef(scalar * testStruct.Value);

}

public static void Add(ref JustByRef a, ref JustByRef b, out JustByRef result)

{

System.Console.WriteLine("Add by ref");

result = new JustByRef(a.Value + b.Value);

}

}

}

I can duplicate the issue I was having with Vector3:

> let a = TestStruct 5.0f

let b = TestStruct 5.0f;;

val a : TestStruct

val b : TestStruct

> 5.0f * (TestStruct.Add(a, b));;

5.0f * (TestStruct.Add(a, b));;

--------^^^^^^^^^^^^^^^^^^^^^

stdin(39,9): error FS0193: Type constraint mismatch. The type

TestStruct

is not compatible with type

float32.

The type 'TestStruct' is not compatible with the type 'float32'.

For some reason, it confuses the two overloads of Add. Removing the by-ref overload results in no error:

> let a = JustByVal 5.0f

let b = JustByVal 5.0f;;

val a : JustByVal

val b : JustByVal

> 5.0f * (JustByVal.Add (a, b));;

Add by val

val it : JustByVal = TestLibrary.JustByVal {Value = 50.0f;}

Removing the by-value overload also results in no error if you tweak the calling code a bit.

> let mutable a = JustByRef 5.0f

let mutable b = JustByRef 5.0f;;

val mutable a : JustByRef

val mutable b : JustByRef

> 5.0f * (JustByRef.Add (&a, &b));;

Add by ref

val it : JustByRef = TestLibrary.JustByRef {Value = 50.0f;}

In F#, you can (optionally) leave off arguments to "out" parameters, and it will return a tuple containing what would be the return value and all values that would have been placed in the omitted "out" parameters. The by-ref overload of TestStruct.Add has the F# type signature: (TestStruct byref * TestStruct byref * TestStruct ref -> unit). However, if you leave off the third argument, it behaves like a function with the signature: (TestStruct byref * TestStruct byref -> TestStruct). There seems to be some kind of clash between overloading and the"out"-parameter omission mechanism, as demonstrated in this code execution:

> let g = (TestStruct.Add : TestStruct byref * TestStruct byref -> TestStruct);;

val g : TestStruct byref * TestStruct byref -> TestStruct

> let h = (TestStruct.Add : TestStruct byref * TestStruct byref * TestStruct ref -> unit);;

val h : TestStruct byref * TestStruct byref * TestStruct ref -> unit

> let x = (JustByRef.Add : JustByRef byref * JustByRef byref -> JustByRef);;

val x : JustByRef byref * JustByRef byref -> JustByRef

> let y = (JustByRef.Add : JustByRef byref * JustByRef byref * JustByRef ref -> unit);;

let y = (JustByRef.Add : JustByRef byref * JustByRef byref * JustByRef ref -> unit);;

---------^^^^^^^^^^^^^^

stdin(50,10): error FS0001: Type mismatch. Expecting a

JustByRef byref * JustByRef byref * JustByRef ref

but given a

JustByRef byref * JustByRef byref.

The tuples have differing lengths of 3 and 2.

As demonstrated by g and x, it actually seems to generate an [i]overload[/i] of Add with the type signature (T byref * T byref -> T). However, it only seems to see the overload with the proper signature of (T byref * T byref * T ref -> unit) in TestStruct. When the by-val overload is removed, the by-ref overload with the proper signature disappears! Although that's not actually the case, because it can still be [i]called[/i] that way:

> let mutable a = JustByRef 5.0f

let mutable b = JustByRef 5.0f

let c = ref (JustByRef 5.0f);;

val mutable a : JustByRef

val mutable b : JustByRef

val c : JustByRef ref

> JustByRef.Add (&a, &b, c);;

Add by ref

val it : unit = ()

A related bug I ran across (which I will definitely report, because it said so) is:

> let g = (TestStruct.Add : TestStruct byref * TestStruct byref * TestStruct ref -> unit);;

val g : TestStruct byref * TestStruct byref * TestStruct ref -> unit

> let h = g;;

error FS0193: internal error: The type 'TestLibrary.TestStruct&' may not be used as a type argument.

Please build a small example that reproduces this problem and report it to fsbugs@microsoft.com.

val h : (TestStruct byref * TestStruct byref * TestStruct ref -> unit)

> let r = (TestStruct.Add : TestStruct byref * TestStruct byref -> TestStruct);;

val r : TestStruct byref * TestStruct byref -> TestStruct

> let s = r;;

error FS0193: internal error: The type 'TestLibrary.TestStruct&' may not be used as a type argument.

Please build a small example that reproduces this problem and report it to fsbugs@microsoft.com.

val s : (TestStruct byref * TestStruct byref -> TestStruct)

> let x = (JustByRef.Add : JustByRef byref * JustByRef byref -> JustByRef);;

val x : JustByRef byref * JustByRef byref -> JustByRef

> let y = x;;

error FS0193: internal error: The type 'TestLibrary.JustByRef&' may not be used as a type argument.

Please build a small example that reproduces this problem and report it to fsbugs@microsoft.com.

val y : (JustByRef byref * JustByRef byref -> JustByRef)

Anyway, I'm considering sending pretty much this whole post in a bug report, but I wanted to get some feedback first.