F# 5의 새로운 기능
F# 5는 F# 언어 및 F# 대화형에 몇 가지 개선 사항을 추가합니다. .NET 5와 함께 릴리스됩니다.
.NET 다운로드 페이지에서 최신 .NET SDK를 다운로드할 수 있습니다.
시작하기
F# 5는 모든 .NET Core 배포 및 Visual Studio 도구에서 사용할 수 있습니다. 자세한 내용은 F# 으로 시작하기를 참조하세요.
F# 스크립트의 패키지 참조
F# 5는 구문을 사용하여 F# 스크립트에서 패키지 참조를 지원합니다 #r "nuget:..." . 예를 들어 다음 패키지 참조를 고려합니다.
#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 같은 네이티브 종속성이 있는 패키지를 지원합니다.
또한 패키지 참조는 종속 .dlls 참조에 대한 특별한 요구 사항이 있는 패키지를 지원합니다. 예를 들어 FParsec 패키지는 사용자가 F# Interactive에서 참조되기 전에 FParsec.dll 해당 종속 FParsecCS.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}"
마지막 줄에 예외가 발생하며 오류 메시지에 "month"가 표시됩니다.
거의 모든 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 ed인 open마지막 형식의 멤버가 다른 이름을 숨깁니다. 이는 이미 존재하는 그림자에 대한 F# 의미 체계와 일치합니다.
이 기능은 F# RFC FS-1068을 구현합니다.
기본 제공 데이터 형식에 대한 일관된 조각화 동작
F# 5 이전의 일관성이 없는 기본 제공 FSharp.Core 데이터 형식(배열, 목록, 문자열, 2D 배열, 3D 배열, 4D 배열)을 조각화하기 위한 동작입니다. 일부 에지 대/소문자 동작은 예외를 throw했고 일부는 예외를 throw하지 않았습니다. 이제 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을 구현합니다.
적용 계산 식
CES(계산 식) 는 오늘날 "상황별 계산"을 모델링하거나 더 기능적인 프로그래밍 친화적인 용어인 모나딕 계산에서 사용됩니다.
F# 5에는 다른 계산 모델을 제공하는 적용 CE가 도입되었습니다. 적용 CES를 사용하면 모든 계산이 독립적이며 결과가 마지막에 누적되는 경우 보다 효율적인 계산을 할 수 있습니다. 계산이 서로 독립적이면 쉽게 병렬 처리할 수 있으므로 CE 작성자가 보다 효율적인 라이브러리를 작성할 수 있습니다. 그러나 이 이점은 이전에 계산된 값에 의존하는 계산은 허용되지 않는다는 제한 사항이 있습니다.
다음 예제에서는 형식에 대한 기본 적용 CE를 Result 보여줍니다.
// 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를 구현합니다.
nullable 값 형식을 사용하여 간소화된 interop
Nullable(값) 형식(지금까지 Nullable 형식이라고 함)은 F#에서 오랫동안 지원해 왔지만 값을 전달할 때마다 래퍼를 Nullable<SomeType> 생성 Nullable 해야 하므로 일반적으로 이러한 형식과 상호 작용하는 것은 다소 고통스러웠습니다. 이제 컴파일러는 대상 형식이 일치하는 경우 값 형식을 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을 구현합니다.
미리 보기: 계산 식에서 사용자 지정 키워드(keyword) 오버로드
계산 식은 라이브러리 및 프레임워크 작성자에게 강력한 기능입니다. 이를 통해 잘 알려진 멤버를 정의하고 작업 중인 기본 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을 구현합니다.
.NET