F# 8 is released as part of .NET 8. It is included with new updates of Visual Studio 2022 and .NET 8 SDK.<\/p>\n
F# 8 brings in many features to make F# programs simpler, more uniform and more performant.\nRead more about language changes, new diagnostics, quality of life improvements, performance boosts for project compilation and upgrades given to the FSharp.Core standard library.<\/p>\n
This announcement lists the major changes brought in by F# 8 developed at F#’s open source code repository<\/a>.<\/p>\n Do you want to learn more about .NET 8 in general? Join us and many other speakers at .NET Conf 2023<\/a>, an online event scheduled for November 14th-16th.<\/p>\n Are you new to F#? Start your journey at the .NET guide to F# with learning materials, examples and YouTube videos<\/a>.<\/p>\n Do you want to see how others are using F#? See recordings of this year’s fsharpConf<\/a>, the F# Community Virtual Conference. For more advanced topics as well as recordings of live contributions to F# compiler and the F# library ecosystem, see the sessions of Amplifying F#<\/a>, a community initiative to grow F#.<\/p>\n If you want to stay up-to-date with F#, follow @fsharponline on social media – LinkedIn<\/a>, X<\/a> and Hachyderm<\/a>.<\/p>\n This section describes updates to the language itself, changes you will notice when writing or reading F# code the most.\nMost of the code samples in this blog post are duplicated in the FSharp 8 News repository<\/a> as a F# project. If you installed the latest .NET 8 tooling, you can check it out and experiment with the code already.<\/p>\n Do you have any interesting use cases for the new features you want to make public for others?\nLet me know in that repository<\/a> via a new issue or open a direct pull request straight away!<\/p>\n The first feature I want to introduce is a shorthand for defining simple lambda functions – useful for situations, when a lambda only does an atomic expression on the lambda argument. An atomic expression is an expression which has no whitespace unless enclosed in method call parentheses.<\/p>\n Let’s have a look at a practical example before and after this feature.<\/p>\n Before:<\/strong><\/p>\n After:<\/strong><\/p>\n As you can see, the snippet Also:<\/strong><\/p>\n What’s more, this feature can also be used outside of a function call to define a standalone lambda to future usage.\nIn the second example The same syntax can be used to define accessors via SRTP syntax<\/a>, allowing the same binding to be used by all items having the same member, without the need to share a common interface.<\/p>\n There is a situation where this syntax is not suitable: when the surrounding scope already makes use of the Such code will end up producing a warning FS3570, saying Next new feature is a copy-and-update<\/a> enhancement for nested records.\nLet’s again demonstrate the feature with before and after examples.<\/p>\n Before:<\/strong><\/p>\n After:<\/strong><\/p>\n The two blocks make the identical change. Instead of having to write multiple nested Also works for anonymous records:<\/strong>\nThe same syntax extension can be used on anonymous records, or when updating regular records into anonymous ones.\nUsing the same type definitions from the example above, we can update the field Beware of name clashes between types and record fields:<\/strong><\/p>\n When trying out this feature, you might get into a conflict<\/a> when naming a field the same as an existing type.\nBefore F# 8, it was possible to qualify record updates using the The last example, since it has to prefer to pre-existing Workaround:<\/strong>\nWhen this happens, it is sufficient to qualify the update with the right type, as in the The What does Before this feature:<\/strong><\/p>\n With The two code blocks are equivalent in their behavior.<\/p>\n The addition of The separate blog post<\/a> uses the F# 8 took inspiration from interpolated raw string literals in C#<\/a> and improved the support for existing interpolated strings in F#<\/a>.<\/p>\n In interpolated strings, literal text output can be combined with values and expressions by wrapping them into a pair of braces This gets in the way if the text naturally contains a lot of braces, e.g. in the context of embedding other languages in F# strings – JSON, CSS or HTML-based templating languages such as mustache<\/a>.<\/p>\n Embedding CSS in F# strings before:<\/strong>\nNotice how each brace for the literal output had to be doubled.<\/p>\n The extended interpolation syntax introduces the ability to redefine that behaviour by entering multiple With new feature:<\/strong><\/p>\n HTML templating:<\/strong>\nIn HTML-based templating languages, doubled braces are commonly used to render variables.\nIn the example below, you can see how F# strings compare with and without extended interpolation syntax.<\/p>\n You can read more about the feature in the blog post about new syntax for string interpolation in F# 8<\/a>.<\/p>\n String literals have received one more update in this release, for usages of built-in printing functions (printfn, sprintfn and others<\/a>).<\/p>\n Before F# 8:<\/strong><\/p>\n Before F# 8, the format specified has to be a string literal typed directly at the place of usage.\nWith F# 8, string literals defined elsewhere are supported.\nWhat’s more, you can define a string literal using a concatenation of existing string literals.\nThat way, commonly repeating format specifiers can be reused as patterns, instead of repeating same string snippets throughout the codebase.<\/p>\n Why does it have to be a String format reuse with F# 8:<\/strong><\/p>\n Numeric literals have also received an update.\nIn the past, they had to be fully specified using constant values.<\/p>\n Before:<\/strong><\/p>\n With F# 8, numeric literals can also be expressed using existing operators and other literals.\nThe compiler evaluates the expression at compile time, and stores the resulting value in the produced assembly. You will notice this when you hover over a defined literal (or its usage) in Visual Studio – it will show you the calculated value.<\/p>\n Example using F# 8:<\/strong><\/p>\n Also works for enum values and literals:<\/strong><\/p>\n The feature can be used at places which require literal values, such as enum values or attribute parameters.<\/p>\n In the case of enum values, arithmetic expressions need to be wrapped in parentheses like in the example above.<\/p>\n F# 8 brings in a new feature to simplify definition of multiple intersected generic constraints using flexible types<\/a>.<\/p>\n Code prior to F# 8:<\/strong><\/p>\n The definiton does require repeating the generic type argument The same syntax also works on specifying signatures, e.g. in signature files or for defining abstract functions:<\/p>\n F# has the fixed keyword<\/a>, which can be used to pin memory and get its address as F# 8 extends this feature<\/a> with additionally allowing it on:<\/p>\n The last two additions are especially relevant for the growing ecosystem and the types like ReadOnlySpan<\/a> or Span<\/a>.<\/p>\n Possible now:<\/strong><\/p>\n The Before:<\/strong><\/p>\n With F# 8, the compiler will only require the attribute on the extension method, and will automatically add the type-level attribute for you.<\/p>\n After:<\/strong><\/p>\n The following changes are making F# more consistent by allowing existing constructs at previously forbidden contexts.\nThis aims to reduce beginner confusion, reduce the need for workarounds and lead to a more succinct code.<\/p>\n This change allows to declare and implement static members in interfaces.\nNot to confuse with static abstract members in interfaces from F#7<\/a>, the upcoming change is about concrete members in interfaces, with their implementation.<\/p>\n Today, the same would be typically accomplished by putting a module with implemented function(s) below the type.<\/p>\n Before:<\/strong><\/p>\n With F# 8, interfaces can have concrete members on them and a standalone module is not needed.<\/p>\n After:<\/strong><\/p>\n Second example of uniformity is enablement of static bindings<\/a> in more F# types. We are talking about the following constructs:<\/p>\n Before F# 8, those were only possible in regular class definitions. With F# 8, they can be added to:<\/p>\n This addition can again help with encapsulating data and logic within the type definition, as opposed to declaring a standalone Possible now:<\/strong>\nAs an example, a simple lookup for converting from string to cases of a disriminated union can now be declared directly inside the type definiton.<\/p>\n The example also shows how a static mutable can be added, and how side effects can be triggered via static do<\/a>. This feature respects the declaration order within the file, as well as the declaration order of types and bindings within a single Also possible:<\/strong><\/p>\n The syntax also allows you to define explicit static fields with automatic properties using the ‘member val’ keywords<\/a>.<\/p>\nF# language changes<\/h2>\n
_.Property shorthand for (fun x -> x.Property)<\/h3>\n
type Person = {Name : string; Age : int}\r\nlet people = [ {Name = \"Joe\"; Age = 20} ; {Name = \"Will\"; Age = 30} ; {Name = \"Joe\"; Age = 51}]\r\n\r\nlet beforeThisFeature = \r\n people \r\n |> List.distinctBy (fun x -> x.Name)\r\n |> List.groupBy (fun x -> x.Age)\r\n |> List.map (fun (x,y) -> y)\r\n |> List.map (fun x -> x.Head.Name)\r\n |> List.sortBy (fun x -> x.ToString())\r\n<\/code><\/pre>\ntype Person = {Name : string; Age : int}\r\nlet people = [ {Name = \"Joe\"; Age = 20} ; {Name = \"Will\"; Age = 30} ; {Name = \"Joe\"; Age = 51}]\r\n\r\nlet possibleNow = \r\n people \r\n |> List.distinctBy _.Name\r\n |> List.groupBy _.Age\r\n |> List.map snd\r\n |> List.map _.Head.Name\r\n |> List.sortBy _.ToString()\r\n<\/code><\/pre>\n(fun x -> x.)<\/code> got replaced with just _.<\/code>, and the need for parantheses was eliminated.\nThis can come especially handy in a sequence of |><\/code> pipelined calls, as typically used for F#’s combinators in List, Option and many other modules.\nThe feature works for single property access, nested property access, method calls and even indexers. The example demonstrates this feature on a list of records, but it works on all values that you can use in a regular lambda function, too. So for example also covering objects, primitives, anonymous records or discriminated unions:<\/p>\nlet getIdx5 : {| Foo : int array |} -> int = _.Foo[5]\r\n<\/code><\/pre>\ngetNameLength<\/code>, you can also see that the feature works without the need to annotate the definition.<\/p>\nlet ageAccessor : Person -> int = _.Age\r\nlet getNameLength = _.Name.Length\r\n<\/code><\/pre>\nlet inline myPropGetter (x: 'a when 'a:(member WhatANiceProperty:string)) = \r\n x |> _.WhatANiceProperty\r\n<\/code><\/pre>\n_<\/code> underscore symbol, typically to discard a parameter.<\/p>\nlet a : string -> string = (fun _ -> 5 |> _.ToString())\r\n<\/code><\/pre>\n\"The meaning of _ is ambiguous here. It cannot be used for a discarded variable and a function shorthand in the same scope.\"<\/code><\/p>\nNested record field copy and update<\/h3>\n
type SteeringWheel = { Type: string }\r\ntype CarInterior = { Steering: SteeringWheel; Seats: int }\r\ntype Car = { Interior: CarInterior; ExteriorColor: string option }\r\n\r\nlet beforeThisFeature x = \r\n { x with Interior = { x.Interior with \r\n Steering = {x.Interior.Steering with Type = \"yoke\"}\r\n Seats = 5\r\n }\r\n }\r\n<\/code><\/pre>\nlet withTheFeature x = { x with Interior.Steering.Type = \"yoke\"; Interior.Seats = 5 }\r\n<\/code><\/pre>\nwith<\/code> keywords, the new language feature allows you to use the dot-notation to reach to lower levels of nested records and update those.\nAs seen in the example, the syntax still allows copy-and-updating multiple fields using the same expression. Each copy-and-update within the same expression can be on a different level of nesting (see Interior.Steering.Type<\/code> and Interior.Seats<\/code> being used in the same snippet above).<\/p>\nInterior.Seats<\/code> using the new feature as well as as add a brand new field Price<\/code> within the same expression.<\/p>\nlet alsoWorksForAnonymous (x:Car) = {| x with Interior.Seats = 7; Price = 99_999 |}\r\n<\/code><\/pre>\nType.Field<\/code> notation. For backwards compatibility, this behavior still works and has a higher priority over a new language feature.<\/p>\ntype Author = {\r\n Name: string\r\n YearBorn: int\r\n}\r\ntype Book = {\r\n Title: string\r\n Year: int\r\n Author: Author\r\n}\r\n\r\nlet oneBook = { Title = \"Book1\"; Year = 2000; Author = { Name = \"Author1\"; YearBorn = 1950 } }\r\nlet codeWhichWorks = {oneBook with Book.Author.Name = \"Author1Updated\"}\r\nlet codeWhichLeadsToAnError = {oneBook with Author.Name = \"Author1Updated\"}\r\n<\/code><\/pre>\nType.Field<\/code> notation for the existing Author<\/code> type, leads to an error:<\/p>\nThis expression was expected to have type 'Book' but here has type 'Author'<\/code><\/p>\ncodeWhichWorks<\/code> sample: Book.Author.Name<\/code> works fine here.<\/p>\nwhile!<\/h3>\n
while!<\/code> (while bang) feature was announced when as part of an earlier preview. You can read in blog post introducing while!<\/a>.<\/p>\nwhile!<\/code> do?\nIt simplifies the usage of computation expressions when looping over a boolean condition that has to be evaluated by the computation expression first (e.g., inside an async{}<\/code> block).<\/p>\nlet mutable count = 0\r\nlet asyncCondition = async {\r\n return count < 10\r\n}\r\n\r\nlet doStuffBeforeThisFeature = \r\n async {\r\n let! firstRead = asyncCondition\r\n let mutable read = firstRead\r\n while read do\r\n count <- count + 2\r\n let! nextRead = asyncCondition\r\n read <- nextRead\r\n return count\r\n }\r\n<\/code><\/pre>\nwhile!<\/code>:<\/strong><\/p>\nlet doStuffWithWhileBang =\r\n async {\r\n while! asyncCondition do\r\n count <- count + 2\r\n return count\r\n }\r\n<\/code><\/pre>\nwhile!<\/code> means a reduction of boilerplate code needed to maintain the mutable read<\/code> boolean variable which was being looped over. The regular while<\/code> (no bang) can only loop over a bool value, and not over an async<bool><\/code> (or similar wrapper in a different computation expression). while!<\/code> brings this possibility to the language.<\/p>\n<LangVersion>preview<\/LangVersion><\/code> project setting to enable it. That is no longer needed with .NET 8 being released. As a reminder<\/a>, newly developed language and compiler features can be tested using the preview<\/code> value before the final version (in this case, 8) is released.<\/p>\nExtended string interpolation syntax<\/h3>\n
{}<\/code>.\nBraces therefore are special symbols, and need to be escaped by doubling them (via {{<\/code> and }}<\/code> ) if they are meant to be a literal part of the output.<\/p>\nlet classAttr = \"item-panel\"\r\nlet cssOld = $\"\"\".{classAttr}:hover {{background-color: #eee;}}\"\"\"\r\n<\/code><\/pre>\n$<\/code> dollar signs at the beginning of the interpolated string literal. The number of starting dollars then dictates the number of braces needed to enter interpolation mode. Any smaller number of braces just becomes part of the output, without any need to escape them.<\/p>\nlet cssNew = $$\"\"\".{{classAttr}}:hover {background-color: #eee;}\"\"\"\r\n<\/code><\/pre>\nlet templateOld = $\"\"\"\r\n<div class=\"{classAttr}\">\r\n <p>{{{{title}}}}<\/p>\r\n<\/div>\r\n\"\"\"\r\nlet templateNew = $$$\"\"\"\r\n<div class=\"{{{classAttr}}}\">\r\n <p>{{title}}<\/p>\r\n<\/div>\r\n\"\"\"\r\n<\/code><\/pre>\nUse and compose string literals for printf and related functions<\/h3>\n
let renderedCoordinatesOld = sprintf \"(%f,%f)\" 0.25 0.75\r\nlet renderedTextOld = sprintf \"Person at coordinates(%f,%f)\" 0.25 0.75\r\n<\/code><\/pre>\n[<Literal>]<\/code> string that is known at compile time? Since the compiler is doing typechecking on the format string in conjuction with other arguments, full content of it must be known at compile time and it cannot be a runtime value.<\/p>\n[<Literal>] \r\nlet formatBody = \"(%f,%f)\"\r\n[<Literal>] \r\nlet formatPrefix = \"Person at coordinates\"\r\n[<Literal>] \r\nlet fullFormat = formatPrefix + formatBody\r\n\r\nlet renderedCoordinates = sprintf formatBody 0.25 0.75\r\nlet renderedText = sprintf fullFormat 0.25 0.75\r\n<\/code><\/pre>\nArithmetic operators in literals<\/h3>\n
module ArithmeticLiteralsBefore =\r\n let [<Literal>] bytesInKB = 1024f\r\n let [<Literal>] bytesInMB = 1048576f\r\n let [<Literal>] bytesInGB = 1073741824\r\n let [<Literal>] customBitMask = 0b01010101uy\r\n let [<Literal>] inverseBitMask = 0b10101010uy\r\n<\/code><\/pre>\n\n
+,-,*, \/, %, &&&, |||, <<<, >>>, ^^^, ~~~, **<\/code>\n\n
not, &&, ||<\/code><\/li>\n<\/ul>\n\r\nlet [<Literal>] bytesInKB = 2f ** 10f\r\nlet [<Literal>] bytesInMB = bytesInKB * bytesInKB\r\nlet [<Literal>] bytesInGB = 1 <<< 30\r\nlet [<Literal>] customBitMask = 0b01010101uy\r\nlet [<Literal>] inverseBitMask = ~~~ customBitMask\r\n<\/code><\/pre>\ntype MyEnum = \r\n | A = (1 <<< 5)\r\n | B = (17 * 45 % 13)\r\n | C = bytesInGB\r\n\r\n[<System.Runtime.CompilerServices.MethodImplAttribute(enum(1+2+3))>]\r\nlet doStuff = ()\r\n<\/code><\/pre>\nType constraint intersection syntax<\/h3>\n
let beforeThis(arg1 : 't \r\n when 't:>IDisposable \r\n and 't:>IEx \r\n and 't:>seq<int>) =\r\n arg1.h(arg1)\r\n arg1.Dispose()\r\n for x in arg1 do\r\n printfn \"%i\" x\r\n<\/code><\/pre>\n't<\/code> for every clause and they have to be connected using the and<\/code> keyword.\nWith F# 8, intersected constrains can be specified using the &<\/code> characters and achieve the same result:<\/p>\nlet withNewFeature (arg1: 't & #IEx & \r\n #IDisposable & #seq<int>) =\r\n arg1.h(arg1)\r\n arg1.Dispose()\r\n for x in arg1 do\r\n printfn \"%i\" x\r\n<\/code><\/pre>\ntype IEx =\r\n abstract h: #IDisposable & #seq<int> -> unit\r\n<\/code><\/pre>\nExtended fixed bindings<\/h3>\n
nativeptr<int><\/code>. It is used in low-level programming scenarios.<\/p>\n\n
byref<'t><\/code><\/li>\ninref<'t><\/code><\/li>\noutref<'t><\/code><\/li>\nGetPinnableReference : unit -> byref<'t><\/code><\/li>\nGetPinnableReference : unit -> inref<'t><\/code><\/li>\n<\/ul>\nopen System\r\nopen FSharp.NativeInterop\r\n\r\n#nowarn \"9\"\r\n\/\/ \"Warning no. 9 is a warning about using unsafe code with nativeint. We are disabling it here when we know we know what we are doing\"\r\nlet pinIt (span: Span<char>, byRef: byref<int>, inRef: inref<int>) =\r\n \/\/ Calls span.GetPinnableReference()\r\n \/\/ The following lines wouldn't compile before\r\n use ptrSpan = fixed span\r\n use ptrByRef = fixed &byRef\r\n use ptrInref = fixed &inRef\r\n\r\n NativePtr.copyBlock ptrByRef ptrInref 1\r\n<\/code><\/pre>\nEasier
[<Extension>]<\/code> method definition<\/h3>\n[<Extension>]<\/code> attribute exists in order to define C#-style extension methods, which can be consumed both by F# and C#.\nHowever, in order to satisfy the C# compiler, the attribute had to be applied both on the member as well as on the type:<\/p>\nopen System.Runtime.CompilerServices\r\n[<Extension>]\r\ntype Foo =\r\n [<Extension>]\r\n static member PlusOne (a:int) : int = a + 1\r\nlet f (b:int) = b.PlusOne()\r\n<\/code><\/pre>\nopen System.Runtime.CompilerServices\r\ntype Foo =\r\n [<Extension>]\r\n static member PlusOne (a:int) : int = a + 1\r\nlet f (b:int) = b.PlusOne()\r\n<\/code><\/pre>\nMaking F# more uniform<\/h2>\n
Static members in interfaces<\/h3>\n
[<Interface>]\r\ntype IDemoableOld =\r\n abstract member Show: string -> unit\r\n\r\nmodule IDemoableOld =\r\n let autoFormat(a) = sprintf \"%A\" a\r\n<\/code><\/pre>\n[<Interface>]\r\ntype IDemoable =\r\n abstract member Show: string -> unit\r\n static member AutoFormat(a) = sprintf \"%A\" a\r\n<\/code><\/pre>\nStatic let in discriminated unions, records, structs, and types without primary constructors<\/h3>\n
\n
static let<\/code><\/li>\nstatic let mutable<\/code><\/li>\nstatic do<\/code><\/li>\nstatic member val<\/code><\/li>\n<\/ul>\n\n
\n
[<Struct>]<\/code> unions and records<\/li>\n<\/ul>\n<\/li>\nmodule<\/code> and putting the bindings in that module.<\/p>\nopen FSharp.Reflection\r\n\r\ntype AbcDU = A | B | C\r\n with \r\n static let namesAndValues = \r\n FSharpType.GetUnionCases(typeof) \r\n |> Array.map (fun c -> c.Name, FSharpValue.MakeUnion (c,[||]) :?> AbcDU)\r\n static let stringMap = namesAndValues |> dict\r\n static let mutable cnt = 0\r\n\r\n static do printfn \"Init done! We have %i cases\" stringMap.Count\r\n static member TryParse text = \r\n let cnt = Interlocked.Increment(&cnt)\r\n stringMap.TryGetValue text, sprintf \"Parsed %i\" cnt\r\n<\/code><\/pre>\nmodule<\/code>.<\/p>\n