F# 7 continues the journey to make F# simpler and more performant as well as improving interop with new C# features. Syntax for the F# specific feature SRTP is simplified<\/a>. Support has been added for Static abstract members support in interfaces<\/a> and consumption of C# To learn more about F#, see the .NET guide to F#<\/a> and the excellent overview talks at the .NET Conf Focus Day on F#<\/a>. The F# community provide resources through the F# Software Foundation (fsharp.org)<\/a>. If you’re interested in more advanced topics, see Fast F#<\/a> series by Matthew Crews<\/a>, the F# community compiler sessions<\/a>, this interview with F# designer Don Syme (part 1<\/a> \/ part 2<\/a>) and Betatalks #66<\/a> .<\/p>\n To stay up to date, check out the community-provided F# Weekly<\/a>, follow @fsharporg<\/a> on Twitter, and join the F# Software Foundation<\/a> to get the latest news and updates.<\/p>\n We are adding a way of declaring, calling and implementing interfaces with static abstract methods, described in F# RFC 1124<\/a>.\nThis is a new feature in .NET 7, matching the corresponding C# feature<\/a>. One notable application is generic math<\/a>.<\/p>\n First, let’s declare an interface with a static abstract member:<\/p>\n Note<\/strong> The code above will produce Next, we can implement it ( This will allow us to write generic functions that can be used with any type that implements or in the operator form:<\/p>\n This is a runtime feature and can be used with any static methods or properties, you can see a few more examples below.<\/p>\n This feature can also be used with BCL built-in types (such as These simplified examples show how interfaces with static abstract methods work.<\/p>\n This is an advanced feature with potential serious methodological drawbacks if used inappropriately. To learn more about the pros and cons of using the feature in F# methodology, see the drawbacks<\/a> and guidance<\/a> sections of the RFC. In particular, you should not use this feature for application code, nor for library code whose specification may be subject to significant change.<\/p>\n Because of the potential drawbacks, we will emit a warning when interfaces with static abstract methods are declared and implemented in F#<\/a>. Additionally, a warning is emitted when interfaces with static abstract methods are used as types, not type constraints<\/a>. Both these warnings can be suppressed.<\/p>\n F# SRTPs or Statically Resolved Type Parameters<\/a> are type parameters that are replaced with an actual type at compile time instead of at run time. F# 7 simplifies the syntax used for defining SRTPs through F# RFC 1083<\/a> and F# RFC 1124<\/a>. This aligns SRTPs and interfaces with static abstract members and makes it easier to interconvert between these two approaches to generic math.<\/p>\n As a quick refreshment on what SRTPs are, and how they’re used, let’s declare a function named We are making some improvements here. First, you no longer need to use a dedicated type parameter character ( Next, we are also adding a new simpler syntax for calling constraints, which is more readable and easier to write:<\/p>\n Finally, we’ve added the ability to declare constraints in groups:<\/p>\n And a simpler syntax for self-constraints, which are constraints that refer to the type parameter itself:<\/p>\n The simplified call syntax also works with instance members:<\/p>\n Together these changes make working with SRTPs easier and more readable.<\/p>\n C# 11 introduced new required modifier for properties<\/a>, F# 7 supports consuming classes with required properties and enforcing the constraint:<\/p>\n Consider the following data type, defined in the C# library:<\/p>\n When using from F# code, the F# compiler will make sure required properties are getting properly initialized:<\/p>\n The code above will compile correctly, but if we try to omit any of the required properties, we will get a compile-time diagnostic:<\/p>\n In F# 7 we are tightening the rules for Given the following C# data type:<\/p>\n Before, in F# 6, the following code would’ve compiled and mutated the property In F# 7, we are changing this to be a compile-time error:<\/p>\n Starting F# 7, the F# compiler can generate and properly consume reference assemblies<\/a>.<\/p>\n You can generate reference assemblies by:<\/p>\n We are looking forward to your feedback on this feature.<\/p>\n While F# apps can already be trimmed<\/a> and compiled to the native code<\/a> in most cases, we are working on making this experience even better.<\/p>\n In F# 7 we are introducing number of improvements:<\/p>\n We will continue to work on improving the experience of F# self-contained deployments and Native AOT for the next version of F# and core library.<\/p>\n Other changes in F# 7 include:<\/p>\n RFCs for F# 7 can be found here<\/a>.<\/p>\n .NET 7 brought a myriad of improvements, which F# 7 will benefit from – various arm64 performance improvements<\/a>, and general performance improvements<\/a>.<\/p>\n F# is developed as a collaboration between the .NET Foundation, the F# Software Foundation, their members and other contributors including Microsoft. The F# community is involved at all stages of innovation, design, implementation and delivery and we’re proud to be a contributing part of this community.<\/p>\n Many people have contributed directly and indirectly to F# 7, including all who have contributed to the F# Language Design Process through fsharp\/fslang-suggestions<\/a> and fsharp\/fslang-design<\/a> repositories.<\/p>\n Adam Boniecki<\/a>, Brett V. Forsgren<\/a>, Don Syme<\/a>, Jon Sequeira<\/a> Kevin Ransom<\/a>, Petr Pokorn\u00fd<\/a>, Petr Semkin<\/a>, Tom\u00e1\u0161 Gro\u0161up<\/a>, Vlad Zarytovskii<\/a>, Will Smith<\/a> contributed directly as part of F# team at Microsoft.<\/p>\n Florian Verdonck<\/a> contributed 72 PRs<\/a>, including work on parallel type-checking improvements, tons of improvements to the syntax trees, which benefit all<\/strong> tooling in general and Fantomas<\/a> source code formatter in particular.<\/p>\n Eugene Auduchinok<\/a> contributed 26 PRs<\/a> including a bunch of improvements and optimizations in the parser, IL reading, completions, compiler service caching and more.<\/p>\n Our new contributor<\/strong> Edgar Gonzalez<\/a> \ud83e\udd73 contributed 17 PRs<\/a> with tons of improvements and fixes around attributes processing, RequiredQualifiedAccess & lower-cased DU cases relaxations and whole bunch of bugfixes.<\/p>\n kerams<\/a> contributed 13 PRs<\/a> for records, types, unions, enums, lambda variables completions, IL gen improvements, and more.<\/p>\n Other direct contributors to the dotnet\/fsharp<\/a> repository in the F# 7.0 time period include teo-tsirpanis<\/a>, DedSec256<\/a>, baronfel<\/a>, leolorenzoluis<\/a>, dawedawe<\/a>, tmat<\/a>, marcin-krystianc<\/a>, cartermp<\/a>, pirrmann<\/a>, safesparrow<\/a>, omppye<\/a>, Happypig375<\/a>, ncave<\/a>, Nino Floris<\/a> thinkbeforecoding<\/a>, MichaelSimons<\/a>, tboby<\/a>, mmitche<\/a>, nosami<\/a>, jonfortescue<\/a>, smoothdeveloper<\/a>, abelbraaksma<\/a>, uxsoft<\/a>.<\/p>\n Many other people are contributing to the rollout of F# 7 and .NET 7 in Fable<\/a>, Ionide<\/a>, Bolero<\/a>, FSharp.Data<\/a>, Giraffe<\/a>, Saturn<\/a>, SAFE Stack<\/a>, WebSharper<\/a>, FsCheck<\/a>, DiffSharp<\/a>, Fantomas<\/a> and other community-delivered technologies.<\/p>\n We will continue working on improving both F# language as well as tooling, including, but not limited to various VS features and improvements, compiler performance, language simplicity, new language features and more. If you’re interested in following our progress, you check out our tracking issues<\/a>. If contributing to the compiler and tooling is something that interests you more, please check out our “help wanted” issues list<\/a>, or feel free to drop a question in discussions<\/a>.<\/p>\n In this and future announcements, we will highlight some of the individuals who contribute to F#. This text is written in the contributors\u2019 own words:<\/p>\n I’m Edgar Gonzalez, and I live between Albacete(Spain) and London(Uk), where I’m a Mobile Developer at Fund Ourselves.<\/p>\n I’m new to the .NET ecosystem. Previously I was a member of the Spanish Paratroopers Brigade “Almog\u00e1vares” VI, where I served as a Corporal first class (2004-2017).<\/p>\n I started programming five years ago, interested in mobile development with C#, and around the same time, I was introduced to F# by Frank A. Krueger<\/a> using Xamarin.iOS<\/p>\n Last year I moved to F#, and during my journey realized that there is room for improvement regarding compiler error reporting, so I decided to get involved and help make F# simple for newcomers like me.<\/p>\n Why do I like F#? it has a clean and lightweight syntax, is expression-oriented, exhaustive pattern matching, and discriminated unions.<\/p>\n I look forward to continuing to help F# to be even better, focusing on making it easy for newcomers.<\/p>\n Thanks to Timoth\u00e9 Larivi\u00e8re<\/a> and Florian Verdonck<\/a> for helping me get started with open source.<\/p>\n<\/blockquote>\n I\u2019m Florian Verdonck, an independent software consultant with a passion for open-source development. My F# open-source journey started in 2017, as part of the F#\nfoundation mentorship program<\/a>. My mentor, Anthony Lloyd<\/a>, and I started\ncontributing to the Fantomas<\/a> project. Maintaining led to contributing, and later, I\nwas adding to F# editor and compiler tooling. Several great mentors helped me get\nmy contributions accepted and my pull requests merged in and I\u2019m grateful to all of\nthem.<\/p>\n Being inspired to contribute to the wonderful F# community is one thing. Having the\nresources to do it properly is another. Luckily, I found customers that share my\nvision of improving open source by active collaboration.<\/p>\nrequired<\/code> members and init<\/code> scope<\/a>. The F# compiler is improved to offer reference assemblies<\/a>, trimmability, better code gen, ARM64 support, performance enhancements and bug fixes<\/a>.<\/p>\nStatic abstract members support in interfaces<\/h2>\n
type IAddition<'T when 'T :> IAdditionOperator<'T>> =\n static abstract op_Addition: 'T * 'T -> 'T<\/code><\/pre>\n\n
FS3535<\/code> warning – Declaring \"interfaces with static abstract methods\" is an advanced feature. See <https:\/\/aka.ms\/fsharp-iwsams> for guidance. You can disable this warning by using '#nowarn \"3535\"' or '--nowarn:3535'.<\/code><\/p>\n<\/blockquote>\n'T * 'T<\/code> is the F# signature for a function with two parameters of type `T):<\/p>\ntype IAddition<'T when 'T :> IAddition<'T>> =\n static abstract op_Addition: 'T * 'T -> 'T\n\ntype Number<'T when IAddition<'T>>(value: 'T) =\n member _.Value with get() = value\n interface IAddition<Number<'T>> with\n static member op_Addition(a, b) = Number(a.Value + b.Value)<\/code><\/pre>\nIAddition<\/code> interface:<\/p>\nlet add<'T when IAddition<'T>>(x: 'T) (y: 'T) = 'T.op_Addition(x,y)<\/code><\/pre>\nlet add<'T when IAddition<'T>>(x: 'T) (y: 'T) = x + y<\/code><\/pre>\ntype ISinOperator<'T when 'T :> ISinOperator<'T>> =\n static abstract Sin: 'T -> 'T\n\nlet sin<'T when ISinOperator<'T>>(x: 'T) = 'T.Sin(x)<\/code><\/pre>\nINumber<'T><\/code>), for example:<\/p>\nopen System.Numerics\n\nlet sum<'T when INumber<'T>>(values: seq<'T>) =\n let mutable result = 'T.Zero\n for value in values do\n result <- result + value\n result<\/code><\/pre>\nMaking working with SRTPs easier<\/h2>\n
average<\/code> that takes an array of type T<\/code> where type T<\/code> is a type that has at least the following members:<\/p>\n\n
(+)<\/code> or op_Addition<\/code>)<\/li>\nDivideByInt<\/code> static method, which takes a T<\/code> and an int<\/code> and returns a T<\/code><\/li>\nZero<\/code> that returns a T<\/code><\/li>\n<\/ul>\nlet inline average< ^T\n when ^T: (static member (+): ^T * ^T -> ^T)\n and ^T: (static member DivideByInt : ^T * int -> ^T)\n and ^T: (static member Zero : ^T)>\n (xs: ^T array) =\n let mutable sum : ^T = (^T : (static member Zero: ^T) ())\n for x in xs do\n sum <- (^T : (static member op_Addition: ^T * ^T -> ^T) (sum, x))\n (^T : (static member DivideByInt: ^T * int -> ^T) (sum, xs.Length))<\/code><\/pre>\n^T<\/code> here is a type parameter, and ^T: (static member (+): ^T * ^T -> ^T)<\/code>, ^T: (static member DivideByInt : ^T * int -> ^T)<\/code>, and ^T: (static member Zero : ^T)<\/code> are constraints for it.<\/p>\n^<\/code>), a single tick character ('<\/code>) can be used instead, the compiler will decide whether it’s static or generic based on the context – whether the function is inline<\/code> and if it has constraints.<\/p>\nlet inline average<'T\n when 'T: (static member (+): 'T * 'T -> 'T)\n and 'T: (static member DivideByInt : 'T * int -> 'T)\n and 'T: (static member Zero : 'T)>\n (xs: 'T array) =\n let mutable sum = 'T.Zero\n for x in xs do\n sum <- sum + x\n 'T.DivideByInt(sum, xs.Length)<\/code><\/pre>\ntype AverageOps<'T when 'T: (static member (+): 'T * 'T -> 'T)\n and 'T: (static member DivideByInt : 'T*int -> 'T)\n and 'T: (static member Zero : 'T)> = 'T<\/code><\/pre>\nlet inline average<'T when AverageOps<'T>>(xs: 'T array) =\n let mutable sum = 'T.Zero\n for x in xs do\n sum <- sum + x\n 'T.DivideByInt(sum, xs.Length)<\/code><\/pre>\ntype Length<'T when 'T: (member Length: int)> = 'T\nlet inline len<'T when Length<'T>>(x: 'T) =\n x.Length<\/code><\/pre>\nRequired properties checking<\/h2>\n
public sealed class Person\n{\n public required string Name { get; set; }\n public required string Surname { get; set; }\n}<\/code><\/pre>\nlet person = Person(Name = \"John\", Surname = \"Smith\")<\/code><\/pre>\nlet person = Person(Name = \"John\")<\/code><\/pre>\nFS3545: The following required properties have to be initalized:\n property Person.Surname: string with get, set<\/code><\/pre>\nInit scope and init-only properties<\/h3>\n
init-only<\/code> properties so that they can only be initialized within the init<\/code> scope. This is a new compile-time check and is a breaking change. It will only be applied starting F# 7, see examples below.<\/p>\npublic sealed class Person\n{\n public int Id { get; init; }\n public int Name { get; set; }\n public int Surname { get; set; }\n public Person Set() => this;\n}<\/code><\/pre>\nId<\/code> of the Person<\/code>:<\/p>\nlet person = Person(Id = 42, Name = \"John\", Surname = \"Doe\")\nperson.Id <- 123\nperson.set_Id(123)\nperson.Set(Id=123)<\/code><\/pre>\nError FS0810 Init-only property 'Id' cannot be set outside the initialization code. See https:\/\/aka.ms\/fsharp-assigning-values-to-properties-at-initialization\nError FS0810 Cannot call 'set_Id' - a setter for init-only property, please use object initialization instead. See https:\/\/aka.ms\/fsharp-assigning-values-to-properties-at-initialization\nError FS0810 Init-only property 'Id' cannot be set outside the initialization code. See https:\/\/aka.ms\/fsharp-assigning-values-to-properties-at-initialization<\/code><\/pre>\nReference assemblies support<\/h2>\n
\n
ProduceReferenceAssembly<\/code> MSBuild project property to your fsproj<\/code> (<ProduceReferenceAssembly>true<\/ProduceReferenceAssembly><\/code>) file or msbuild flags (\/p:ProduceReferenceAssembly=true<\/code>).<\/li>\n--refout<\/code> or --refonly<\/code> compiler options.<\/li>\n<\/ul>\nF# self-contained deployments & Native AOT<\/h2>\n
\n
--reflectionfree<\/code> – it will allow skipping emitting of automatic (%A<\/code>, reflection-based) ToString<\/code> implementation for records, unions and structs.<\/li>\nFSharp.Core<\/code> – added ILLink.LinkAttributes.xml<\/code> and ILLink.LinkAttributes.xml<\/code> for FSharp.Core<\/code>, which allows trimming compile-time resources and attributes for runtime-only FSharp.Core dependency.<\/li>\n<\/ul>\nOther changes<\/h2>\n
\n
#r<\/code> caching support.<\/li>\nGeneral Improvements in .NET 7<\/h2>\n
Thanks and Acknowledgments<\/h2>\n
What’s next?<\/h2>\n
Contributor Showcase<\/h2>\n
Edgar Gonzalez<\/h3>\n
\n
![\"Contributor](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2022\/11\/EdgarGonzalez.jpg\")
<\/p>\nFlorian Verdonck<\/h3>\n
\n
![\"Contributor](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2022\/11\/FlorianVerdonck.jpg\")
<\/p>\n