RFC FS-1006 Struct Tuples and Interop with C# 7.0 Tuples

[dsyme]

This is the WIP PR for F# RFC FS-1006 Struct Tuples and Interop with C# 7.0 Tuples

Please discuss the implementation on this thread, and the RFC and design on the RFC discussion thread.

[dsyme]

Current failures are all to do with the added FSHarp.Core surface area. This will disappear once we can use a System.ValueTuples.dll from .NET

[00:21:11] 1) Failed : FSharp.Core.Unittests.SurfaceArea.SurfaceAreaTest.VerifyArea
[00:21:11] 2) Failed : FSharp.Core.Unittests.Portable.SurfaceArea.SurfaceAreaTest.VerifyArea
[00:21:11] 3) Failed : FSharp.Core.Unittests.Portable.SurfaceArea.SurfaceAreaTest.VerifyArea
[00:21:11] 4) Failed : FSharp.Core.Unittests.Portable.SurfaceArea.SurfaceAreaTest.VerifyArea
[00:21:11] 5) Failed : FSharp.Core.Unittests.Portable.SurfaceArea.SurfaceAreaTest.VerifyArea

[TIHan]

Why is all this commented out? Just curious! That's all :D

[dsyme]

I'll remove it. It was related to this possible extension

[TIHan]

I just did a brief scan of everything. I do have a pet peeve when I see commented code without an explanation for why something was commented out. I put in some comments, I don't know if they are helpful. I'm no expert here, so there may be good reasons for everything and I am only trying to help when I can! Otherwise, everything seems to look fine on my end; I haven't tested anything though.

[vasily-kirichenko]

Just a side note, I've tested struct tuples in a scenario where they were supposed to speedup returning multiple values from a function http://vaskir.blogspot.ru/2016/05/upcoming-f-struct-tuples-are-they.html
It turned out they makes no difference.

[TIHan]

@vasily-kirichenko The current example isn't a good estimate, as if you compile the first non-struct tuple example in Release, it compiles to this:

[CompilationMapping(SourceConstructFlags.Module)]
public static class Program
{
  [EntryPoint]
  public static int main(string[] _arg1)
  {
    Stopwatch stopwatch = Stopwatch.StartNew();
    for (int index = 1; index < 100000001; ++index)
      Math.Sin((double) index / 1000.0);
    stopwatch.Stop();
    PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, (PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit>) new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("Run: %O")).Invoke(stopwatch.Elapsed);
    stopwatch.Restart();
    GC.Collect(2);
    stopwatch.Stop();
    PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, (PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit>) new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("GC.Collect: %O")).Invoke(stopwatch.Elapsed);
    Console.ReadKey();
    return 0;
  }
}

It doesn't even construct the tuples in the first place.

Try this:

open System
open System.Diagnostics

[<EntryPoint>]
let main _ = 
    let foo x = (x, Math.Sin x)

    let mutable v = (0., 0.)

    let sw = Stopwatch.StartNew()
    for n in 1..100000000 do
        v <- foo (float n / 1000.)
        ()
    sw.Stop()
    printfn "Run: %O" sw.Elapsed
    sw.Restart()
    GC.Collect 2
    sw.Stop()
    printfn "GC.Collect: %O" sw.Elapsed
    Console.ReadKey() |> ignore
    0

[vasily-kirichenko]

@TIHan same time for your last snippet.

[TIHan]

When I use the first example @vasily-kirichenko posted, the compiler optimizes out the tuples. I didn't use this branch though. If I use the snippet I posted, I get similar timings.

[TIHan]

I also did this as a test:

open System
open System.Diagnostics

[<Struct>]
type StructTuple<'T1, 'T2> =

    val X : 'T1

    val Y : 'T2

    new (x, y) = { X = x; Y = y }

[<EntryPoint>]
let main _ = 
    let foo x = StructTuple (x, Math.Sin x)

    let mutable v = StructTuple (0., 0.)

    let sw = Stopwatch.StartNew()
    for n in 1..100000000 do
        v <- foo (float n / 1000.)
        ()
    sw.Stop()
    printfn "Run: %O" sw.Elapsed
    sw.Restart()
    GC.Collect 2
    sw.Stop()
    printfn "GC.Collect: %O" sw.Elapsed
    Console.ReadKey() |> ignore
    0

My timings were:

Run: 00:00:00.2693048
GC.Collect: 00:00:00.0001226

An order of magnitude faster.

I should just use this branch.

[vasily-kirichenko]

I added results in release mode and added decompiled code as well (in the blog post).

@dsyme StructTuples are not erased in Release mode, but old Tuples are. Is it intentionally?

[dsyme]

Awesome to see this passing green

[dsyme]

This looks very close to being ready. However I would expect we should wait until we are 100% certain of the final shape and form of the C# feature, and it has been committed and finalized. I'd hate to have F# commit and then C# change some design detail :)

[dsyme]

This code is raising caught exceptions on every FSharp.Core load

#if FX_ASSEMBLYLOADBYSTRING
            let a = Assembly.Load("System.ValueTuple")
#else
            let a = Assembly.Load(new AssemblyName("System.ValueTuple"))
#endif 

at least if System.ValueTuple is not in the compiler directory by some chance. But in any case it seems a bit inefficient on every library startup

The root cause is that in reflect.fs, these should be computed on-demand rather than be top-level constants, so you only pay the cost once you start to use reflection

    let stuple1 = reflectedValueTupleType 1 [| typedefof<obj> |]
    let stuple2 = reflectedValueTupleType 2 [| typedefof<obj>; typedefof<obj> |]
    let stuple3 = reflectedValueTupleType 3 [| typedefof<obj>; typedefof<obj>; typedefof<obj> |]
    let stuple4 = reflectedValueTupleType 4 [| typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj> |]
    let stuple5 = reflectedValueTupleType 5 [| typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj> |]
    let stuple6 = reflectedValueTupleType 6 [| typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj> |]
    let stuple7 = reflectedValueTupleType 7 [| typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj> |]
    let stuple8 = reflectedValueTupleType 8 [| typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; typedefof<obj>; deOption(reflectedValueTuple 0) |]

[KevinRansom]

@dsyme Thanks for this important feature.

[cartermp]

👍 👍 👍

🎉 🎉 🎉

😸 😸 😸

[KevinRansom]

@dotnet-bot test this please