F# 5 中的新增功能
F# 5 增加了对 F# 语言和 F# 交互窗口的几项改进。 它随 .NET 5 一起发布。
可以从 .NET 下载页下载最新 .NET SDK。
入门
F# 5 在所有 .NET Core 分发版和 Visual Studio 工具中提供。 有关详细信息，请参阅 F# 入门以了解更多信息。
F# 脚本中的包引用
F# 5 支持使用 #r "nuget:..." 语法在 F# 脚本中进行包引用。 例如，请考虑以下包引用：
#r "nuget: Newtonsoft.Json"
open Newtonsoft.Json
let o = {| X = 2; Y = "Hello" |}
printfn $"{JsonConvert.SerializeObject o}"
还可以在包的名称后提供显式版本，如下所示：
#r "nuget: Newtonsoft.Json,11.0.1"
包引用支持具有本机依赖项的包，例如 ML.NET。
包引用还支持对引用依赖 .dll 具有特殊要求的包。 例如，FParsec 包用于要求用户手动确保先引用其依赖 FParsecCS.dll，然后再在 F# 交互窗口中引用 FParsec.dll。 不再需要这样，可以按如下所示引用该包：
#r "nuget: FParsec"
open FParsec
let test p str =
match run p str with
| Success(result, _, _) -> printfn $"Success: {result}"
| Failure(errorMsg, _, _) -> printfn $"Failure: {errorMsg}"
test pfloat "1.234"
此功能实现 F# 工具 RFC FST-1027。 有关包引用详细信息，请参阅 F# 交互窗口教程。
字符串内插
F# 内插字符串与 C# 或 JavaScript 内插字符串非常相似，因为它们允许你可以在字符串文本内的“孔”中编写代码。 下面是一个基本示例：
let name = "Phillip"
let age = 29
printfn $"Name: {name}, Age: {age}"
printfn $"I think {3.0 + 0.14} is close to {System.Math.PI}!"
但是，F# 内插字符串还允许类型化内插（就如同 sprintf 函数一样），以强制内插上下文内的表达式符合特定类型。 它使用相同的格式说明符。
let name = "Phillip"
let age = 29
printfn $"Name: %s{name}, Age: %d{age}"
// Error: type mismatch
printfn $"Name: %s{age}, Age: %d{name}"
在前面的类型化内插示例中，%s 要求内插属于类型 string，而 %d 要求内插为 integer。
此外，任何任意的 F# 表达式（或多个表达式）都可以置于内插上下文的一侧。 甚至可以编写更复杂的表达式，如下所示：
let str =
$"""The result of squaring each odd item in {[1..10]} is:
{
let square x = x * x
let isOdd x = x % 2 <> 0
let oddSquares xs =
xs
|> List.filter isOdd
|> List.map square
oddSquares [1..10]
}
"""
不过在实践中不建议执行太多这种操作。
此功能实现 F# RFC FS-1001。
支持 nameof
F# 5 支持 nameof 运算符，该运算符会解析用于它的符号，并在 F# 源中生成其名称。 这可用于各种方案（如日志记录）并保护日志记录免受源代码更改的影响。
let months =
[
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December"
]
let lookupMonth month =
if (month > 12 || month < 1) then
invalidArg (nameof month) (sprintf "Value passed in was %d." month)
months[month-1]
printfn $"{lookupMonth 12}"
printfn $"{lookupMonth 1}"
printfn $"{lookupMonth 13}"
最后一行会引发异常，错误消息中会显示“月份”。
可以采用几乎每个 F# 构造的名称：
module M =
let f x = nameof x
printfn $"{M.f 12}"
printfn $"{nameof M}"
printfn $"{nameof M.f}"
最后添加的三个内容是对运算符工作方式的更改：添加泛型类型参数的 nameof<'type-parameter> 形式，以及能够在模式匹配表达式中使用 nameof 作为模式。
采用运算符的名称可提供其源字符串。 如果需要已编译形式，请使用运算符的已编译名称：
nameof(+) // "+"
nameof op_Addition // "op_Addition"
采用类型参数的名称需要略有不同的语法：
type C<'TType> =
member _.TypeName = nameof<'TType>
这类似于 typeof<'T> 和 typedefof<'T> 运算符。
F# 5 还添加了对可在 match 表达式中使用的 nameof 模式的支持：
[<Struct; IsByRefLike>]
type RecordedEvent = { EventType: string; Data: ReadOnlySpan<byte> }
type MyEvent =
| AData of int
| BData of string
let deserialize (e: RecordedEvent) : MyEvent =
match e.EventType with
| nameof AData -> AData (JsonSerializer.Deserialize<int> e.Data)
| nameof BData -> BData (JsonSerializer.Deserialize<string> e.Data)
| t -> failwithf "Invalid EventType: %s" t
前面的代码在匹配表达式中使用“nameof”而不是字符串文本。
此功能实现 F# RFC FS-1003。
开放类型声明
F# 5 还添加了对开放类型声明的支持。 开放类型声明如同在 C# 中打开静态类，只是使用了一些不同的语法和一些稍微不同的行为来适应 F# 语义。
借助开放类型声明，可以对任何类型执行 open 操作以公开其中的静态内容。 此外，可以对 F# 定义的联合和记录执行 open 操作以公开其内容。 例如，如果在模块中定义了联合，并且要访问其用例，但不想打开整个模块，则这可能会非常有用。
open type System.Math
let x = Min(1.0, 2.0)
module M =
type DU = A | B | C
let someOtherFunction x = x + 1
// Open only the type inside the module
open type M.DU
printfn $"{A}"
与 C# 不同，对公开同名的成员的两个类型执行 open type 操作时，进行 open 的最后一个类型中的成员会隐藏另一个名称。 这与围绕隐藏的已存在 F# 语义一致。
此功能实现 F# RFC FS-1068。
内置数据类型的一致切片行为
对内置 FSharp.Core 数据类型（数组、列表、字符串、2D 数组、3D 数组、4D 数组）进行切片的行为在 F# 5 之前曾经不一致。 某些边缘用例行为会引发异常，而另一些则不会引发异常。 在 F# 5 中，所有内置类型现在都为无法生成的切片返回空切片：
let l = [ 1..10 ]
let a = [| 1..10 |]
let s = "hello!"
// Before: would return empty list
// F# 5: same
let emptyList = l[-2..(-1)]
// Before: would throw exception
// F# 5: returns empty array
let emptyArray = a[-2..(-1)]
// Before: would throw exception
// F# 5: returns empty string
let emptyString = s[-2..(-1)]
此功能实现 F# RFC FS-1077。
FSharp.Core 中 3D 和 4D 数组的固定索引切片
F# 5 支持内置 3D 和 4D 数组类型中具有固定索引的切片。
为了说明这一点，请参考以下 3D 数组：
z = 0
| x\y | 0 | 1 |
|---|---|---|
| 0 | 0 | 1 |
| 1 | 2 | 3 |
z = 1
| x\y | 0 | 1 |
|---|---|---|
| 0 | 4 | 5 |
| 1 | 6 | 7 |
如果要从数组中提取切片 [| 4; 5 |]，该怎么办？ 现在这非常简单！
// First, create a 3D array to slice
let dim = 2
let m = Array3D.zeroCreate<int> dim dim dim
let mutable count = 0
for z in 0..dim-1 do
for y in 0..dim-1 do
for x in 0..dim-1 do
m[x,y,z] <- count
count <- count + 1
// Now let's get the [4;5] slice!
m[*, 0, 1]
此功能实现 F# RFC FS-1077b。
F# 引用改进
F# 代码引用现在能够保留类型约束信息。 请考虑以下示例：
open FSharp.Linq.RuntimeHelpers
let eval q = LeafExpressionConverter.EvaluateQuotation q
let inline negate x = -x
// val inline negate: x: ^a -> ^a when ^a : (static member ( ~- ) : ^a -> ^a)
<@ negate 1.0 @> |> eval
inline 函数生成的约束保留在代码引用中。 现在可以计算 negate 函数的引用形式。
此功能实现 F# RFC FS-1071。
适用的计算表达式
计算表达式 (CE) 现在用于对“上下文计算”（如果采用更适合于函数编程的术语，则是一元计算）进行建模。
F# 5 引入了适用的 CE，它们可提供不同的计算模型。 适用的 CE 可实现更高效的计算，前提是每次计算都是独立的，并且其结果会在最后累积。 当计算彼此独立时，它们也很容易并行化，从而使 CE 创建者能够编写更高效的库。 不过此优势有一个限制：不允许使用依赖于以前计算的值的计算。
下面的示例演示 Result 类型的基本适用的 CE。
// First, define a 'zip' function
module Result =
let zip x1 x2 =
match x1,x2 with
| Ok x1res, Ok x2res -> Ok (x1res, x2res)
| Error e, _ -> Error e
| _, Error e -> Error e
// Next, define a builder with 'MergeSources' and 'BindReturn'
type ResultBuilder() =
member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2
member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x
let result = ResultBuilder()
let run r1 r2 r3 =
// And here is our applicative!
let res1: Result<int, string> =
result {
let! a = r1
and! b = r2
and! c = r3
return a + b - c
}
match res1 with
| Ok x -> printfn $"{nameof res1} is: %d{x}"
| Error e -> printfn $"{nameof res1} is: {e}"
let printApplicatives () =
let r1 = Ok 2
let r2 = Ok 3 // Error "fail!"
let r3 = Ok 4
run r1 r2 r3
run r1 (Error "failure!") r3
如果你是目前在库中公开 CE 的库创建者，则还需要了解一些额外的注意事项。
此功能实现 F# RFC FS-1063。
接口可以在不同的泛型实例化中实现
现在可以在不同的泛型实例化中实现相同的接口：
type IA<'T> =
abstract member Get : unit -> 'T
type MyClass() =
interface IA<int> with
member x.Get() = 1
interface IA<string> with
member x.Get() = "hello"
let mc = MyClass()
let iaInt = mc :> IA<int>
let iaString = mc :> IA<string>
iaInt.Get() // 1
iaString.Get() // "hello"
此功能实现 F# RFC FS-1031。
默认接口成员消耗
F# 5 允许使用具有默认实现的接口。
请考虑 C# 中定义的接口，如下所示：
using System;
namespace CSharp
{
public interface MyDim
{
public int Z => 0;
}
}
可以通过实现接口的任何标准方式在 F# 中使用它：
open CSharp
// You can implement the interface via a class
type MyType() =
member _.M() = ()
interface MyDim
let md = MyType() :> MyDim
printfn $"DIM from C#: %d{md.Z}"
// You can also implement it via an object expression
let md' = { new MyDim }
printfn $"DIM from C# but via Object Expression: %d{md'.Z}"
这使你能够在期望用户能够使用默认实现时，安全地利用采用现代 C# 编写的 C# 代码和 .NET 组件。
此功能实现 F# RFC FS-1074。
与可以为 null 的值类型的简化互操作
可以为 null 的（值）类型（历史上称为可以为 null 的类型）长期以来一直受 F# 支持，但与它们交互在传统上有点困难，因为每次要传递值时都必须构造 Nullable 或 Nullable<SomeType> 包装器。 现在，如果目标类型匹配，则编译器会将值类型隐式转换为 Nullable<ThatValueType>。 现在可以执行以下代码：
#r "nuget: Microsoft.Data.Analysis"
open Microsoft.Data.Analysis
let dateTimes = PrimitiveDataFrameColumn<DateTime>("DateTimes")
// The following line used to fail to compile
dateTimes.Append(DateTime.Parse("2019/01/01"))
// The previous line is now equivalent to this line
dateTimes.Append(Nullable<DateTime>(DateTime.Parse("2019/01/01")))
此功能实现 F# RFC FS-1075。
预览：反向索引
F# 5 还引入了允许反向索引的预览。 语法为 ^idx。 下面介绍了如何从列表末尾查找元素 1 值：
let xs = [1..10]
// Get element 1 from the end:
xs[^1]
// From the end slices
let lastTwoOldStyle = xs[(xs.Length-2)..]
let lastTwoNewStyle = xs[^1..]
lastTwoOldStyle = lastTwoNewStyle // true
还可以为自己的类型定义反向索引。 为此，需要实现以下方法：
GetReverseIndex: dimension: int -> offset: int
下面是 Span<'T> 类型的示例：
open System
type Span<'T> with
member sp.GetSlice(startIdx, endIdx) =
let s = defaultArg startIdx 0
let e = defaultArg endIdx sp.Length
sp.Slice(s, e - s)
member sp.GetReverseIndex(_, offset: int) =
sp.Length - offset
let printSpan (sp: Span<int>) =
let arr = sp.ToArray()
printfn $"{arr}"
let run () =
let sp = [| 1; 2; 3; 4; 5 |].AsSpan()
// Pre-# 5.0 slicing on a Span<'T>
printSpan sp[0..] // [|1; 2; 3; 4; 5|]
printSpan sp[..3] // [|1; 2; 3|]
printSpan sp[1..3] // |2; 3|]
// Same slices, but only using from-the-end index
printSpan sp[..^0] // [|1; 2; 3; 4; 5|]
printSpan sp[..^2] // [|1; 2; 3|]
printSpan sp[^4..^2] // [|2; 3|]
run() // Prints the same thing twice
此功能实现 F# RFC FS-1076。
预览：计算表达式中的自定义关键字的重载
计算表达式是适用于库和框架创建者的强大功能。 它们允许定义已知成员并为正在其中工作的域形成 DSL，从而可极大地提高组件的表现力。
F# 5 为在计算表达式中重载自定义操作添加了预览支持。 它允许编写和使用以下代码：
open System
type InputKind =
| Text of placeholder:string option
| Password of placeholder: string option
type InputOptions =
{ Label: string option
Kind : InputKind
Validators : (string -> bool) array }
type InputBuilder() =
member t.Yield(_) =
{ Label = None
Kind = Text None
Validators = [||] }
[<CustomOperation("text")>]
member this.Text(io, ?placeholder) =
{ io with Kind = Text placeholder }
[<CustomOperation("password")>]
member this.Password(io, ?placeholder) =
{ io with Kind = Password placeholder }
[<CustomOperation("label")>]
member this.Label(io, label) =
{ io with Label = Some label }
[<CustomOperation("with_validators")>]
member this.Validators(io, [<ParamArray>] validators) =
{ io with Validators = validators }
let input = InputBuilder()
let name =
input {
label "Name"
text
with_validators
(String.IsNullOrWhiteSpace >> not)
}
let email =
input {
label "Email"
text "Your email"
with_validators
(String.IsNullOrWhiteSpace >> not)
(fun s -> s.Contains "@")
}
let password =
input {
label "Password"
password "Must contains at least 6 characters, one number and one uppercase"
with_validators
(String.exists Char.IsUpper)
(String.exists Char.IsDigit)
(fun s -> s.Length >= 6)
}
在进行此更改之前，可以按原样编写 InputBuilder 类型，但无法采用在示例中使用它的方式来进行使用。 由于现在允许使用重载、可选参数和 System.ParamArray 类型，因此一切都按预期方式工作。
此功能实现 F# RFC FS-1056。
反馈
即将发布：在整个 2024 年，我们将逐步淘汰作为内容反馈机制的“GitHub 问题”，并将其取代为新的反馈系统。 有关详细信息，请参阅：https://aka.ms/ContentUserFeedback。
提交和查看相关反馈