Facilitating the spread of knowledge and innovation in professional software development



Choose your language

InfoQ Homepage News F# 4.1 Brings Improvements and Interoperation with C# 7

F# 4.1 Brings Improvements and Interoperation with C# 7


F# 4.1 brings improvements to the language. It is distributed through the Microsoft tools for F#, which are stated to ship later this year. This version enables support for struct tuples, interoperation with C# 7 and by-ref returns.

Tuples are commonly used in F#, as the syntax and type inference make them easy to use. They are reference types, stored on the heap. F# 4.1 brings struct tuples, stored on the stack. This has performance benefits for certain scenarios, such as allocating a large number of small tuples.

To support the ValueTuple type, tuple types, tuple expressions and tuple patterns can now be annotated with the struct keyword.

 // Creating a new struct tuple.
let origin = struct (0, 0)

// Take struct tuples as arguments to a function and generate a new struct tuple.
let getPointFromOffset (point: struct (x, y)) (offset: struct (dx, dy)) = 
    struct (x + dx, y + dy)

// Pattern match on a struct tuple.
let doAMatch (input: struct (x, y)) =
    match input with
    | struct (0, 0) -> sprintf "The tuple is the origin!"
    | struct (_, _) -> sprintf "The tuple is NOT the origin!"

Interoperation with C# 7 also works using the struct keyword.

// Calls a C# function returning a value tuple
let struct(word, value) = SomeService.SomeResult()
// Calls a C# function taking a value tuple in parameter.
let result = SomeService.CreateResult(struct("hello", 12))

In addition to tuples, record types and discriminated unions can also be represented as value types. It requires the struct annotation.

 type Student = {
    Id: int
    Name: string
    Age: int
    GPA: double
    Major: string

type Shape = 
| Circle of radius: float
| Square of side: int
| Rectangle of sides: double*double

F# 4.1 also brings by-ref returns. F# already has support for ref locals, but had no support for consuming or generating byref-returning methods.

// Returns from an array.
let f (x:int[]) = &x.[0]

// Returns from a record
type R = { mutable z : int }
let f (x:byref<R>) = &x.z

By-ref returns can also be consumed from a C# method.

public static ref int Find(int val, int[] vals)
        for (int i = 0; i < vals.Length; i++)
            if (vals[i] == val)
                return ref numbers[i];

// 'result' is of type 'byref<int>'.
let result = SomeCSharpClass.Find(3, [| 1; 2; 3; 4; 5 |])

In addition to the F# source code on GitHub, the language specifications are also available publicly for more information.

We need your feedback

How might we improve InfoQ for you

Thank you for being an InfoQ reader.

Each year, we seek feedback from our readers to help us improve InfoQ. Would you mind spending 2 minutes to share your feedback in our short survey? Your feedback will directly help us continually evolve how we support you.

Take the Survey

Rate this Article


Hello stranger!

You need to Register an InfoQ account or or login to post comments. But there's so much more behind being registered.

Get the most out of the InfoQ experience.

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Community comments

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p


Is your profile up-to-date? Please take a moment to review and update.

Note: If updating/changing your email, a validation request will be sent

Company name:
Company role:
Company size:
You will be sent an email to validate the new email address. This pop-up will close itself in a few moments.