Desen Eşleştirme

Desenler, giriş verilerini dönüştürme kurallarıdır. F# genelinde verileri mantıksal bir yapı veya yapıyla karşılaştırmak, verileri bileşen parçalara ayırmak veya verilerden çeşitli yollarla bilgi ayıklamak için kullanılır.

Açıklamalar

Desenler, match ifadesi gibi birçok dil yapısında kullanılır. bunlar, let bağlamalarındaki, lambda ifadelerindeki ve try...with ifadesiyle ilişkili özel durum işleyicilerindeki işlevler için bağımsız değişkenleri işlerken kullanılır. Daha fazla bilgi için bkz. Eşleşme İfadeleri, let Bağlamaları, Lambda İfadeleri: fun Anahtar Kelimeve İstisnalar: try...with İfade.

Örneğin, match ifadesinde, deseni boru simgesini izler.

match expression with
| pattern [ when condition ] -> result-expression
...

Her desen, girişi bir şekilde dönüştürmek için bir kural işlevi görür. match ifadesinde her desen sırayla incelenerek giriş verilerinin desenle uyumlu olup olmadığını görebilirsiniz. Eşleşme bulunursa sonuç ifadesi yürütülür. Eşleşme bulunmazsa, sonraki desen kuralı test edilir. İsteğe bağlı "ne zaman" koşulu bölümü, İfadeleri Eşleştirbölümünde açıklanır.

Desteklenen desenler aşağıdaki tabloda gösterilmiştir. Çalışma zamanında, giriş, tabloda listelenen sırayla aşağıdaki kalıpların her biriyle test edilir ve kalıplar, kodunuzda göründükleri sıraya göre baştan sona ve her satırdaki kalıplar için soldan sağa doğru özyinelemeli olarak uygulanır.

Ad	Açıklama	Örnek
Sabit desen	Herhangi bir sayısal, karakter veya dize değişmezi, bir sabit listesi sabiti veya tanımlı bir değişmez değer tanımlayıcısı	1.0, "test", 30, Color.Red
Tanımlayıcı deseni	Ayrımcı bir birleşim durumu, bir özel durum etiketi veya etkin desen durumu	Some(x) Failure(msg)
Değişken desen	tanımlayıcı	a
as deseni	desen olarak tanımlayıcı	(a, b) as tuple1
OR deseni	desen1 | desen2	([h] | [h; _])
VE deseni	desen1 & desen2	(a, b) & (_, "test")
Eksiler deseni	tanımlayıcı :: liste-tanımlayıcı	h :: t
Liste düzeni	[ pattern_1; ... ; pattern_n ]	[ a; b; c ]
Dizi düzeni	[| pattern_1; ..; pattern_n |]	[| a; b; c |]
Ayraçlı desen	( desen )	( a )
Tuple deseni	( pattern_1, ... , pattern_n )	( a, b )
Kayıt düzeni	{ tanımlayıcı1 = pattern_1; ... ; = identifier_npattern_n }	{ Name = name; }
Joker karakter deseni	_	_
Tür ek açıklamasıyla birlikte desen oluşturma	desen : türü	a : int
Test deseni yazın	:? [ tanımlayıcı olarak ] yazın	:? System.DateTime as dt
Null desen	sıfır	null
Nameof deseni	İfade adı	nameof str

Sabit Desenler

Sabit desenler sayısal, karakter ve dizge değişmezleri, numaralandırma sabitleridir (numaralandırma türü adı da dahildir). Yalnızca sabit desenleri olan bir match ifadesi, diğer dillerdeki bir case deyimiyle karşılaştırılabilir. Giriş sabit değerle karşılaştırılır ve eğer değerler eşitse desen eşleşir. Literal'ın türü, verilen girişin türüyle uyumlu olmalıdır.

Aşağıdaki örnek değişmez değer desenlerinin kullanımını gösterir ve ayrıca değişken deseni ve OR deseni kullanır.

[<Literal>]
let Three = 3

let filter123 x =
    match x with
    // The following line contains literal patterns combined with an OR pattern.
    | 1 | 2 | Three -> printfn "Found 1, 2, or 3!"
    // The following line contains a variable pattern.
    | var1 -> printfn "%d" var1

for x in 1..10 do filter123 x

Sabit değer deseninin bir diğer örneği, numaralandırma sabitlerini temel alan bir desendir. Numaralandırma sabitlerini kullanırken numaralandırma türü adını belirtmeniz gerekir.

type Color =
    | Red = 0
    | Green = 1
    | Blue = 2

let printColorName (color:Color) =
    match color with
    | Color.Red -> printfn "Red"
    | Color.Green -> printfn "Green"
    | Color.Blue -> printfn "Blue"
    | _ -> ()

printColorName Color.Red
printColorName Color.Green
printColorName Color.Blue

Tanımlayıcı Desenleri

Desen geçerli bir tanımlayıcı oluşturan bir karakter dizesiyse, tanımlayıcının biçimi desenin nasıl eşleşeceğini belirler. Tanımlayıcı tek bir karakterden uzunsa ve büyük harfle başlıyorsa, derleyici tanımlayıcı deseniyle eşleşmeyi dener. Bu desenin tanımlayıcısı Literal özniteliği, ayrıcalıklı birliktelik durumu, istisna tanımlayıcısı veya etkin desen durumu ile işaretlenmiş bir değer olabilir. Eşleşen tanımlayıcı bulunmazsa, eşleşme başarısız olur ve bir sonraki desen kuralı olan değişken deseni girişle karşılaştırılır.

Ayrımcı birleşim desenleri basit adlandırılmış durumlar olabilir veya bir değere veya birden çok değer içeren bir tanımlama grubuna sahip olabilirler. Bir değer varsa, değer için bir tanımlayıcı belirtmeniz gerekir. Bir tuple söz konusu olduğunda, tuple'ın her bir ögesi için bir tanımlayıcı içeren bir tuple deseni veya bir ya da daha fazla adlandırılmış birleşim alanı için alan adıyla birlikte bir tanımlayıcı sağlamanız gerekir. Örnekler için bu bölümdeki kod örneklerine bakın.

option türü, Some ve Noneolmak üzere iki örneği olan ayrımcı bir birleşimdir. Bir durum (Some) bir değere sahiptir, ancak diğeri (None) sadece isimlendirilmiş bir durumdur. Bu nedenle, Some, Some durumuyla ilişkili değere yönelik bir değişkene sahip olmalıdır, ancak None tek başına görünmelidir. Aşağıdaki kodda, var1 değişkenine, Some durumuyla eşleşerek elde edilen değer verilir.

let printOption (data : int option) =
    match data with
    | Some var1  -> printfn "%d" var1
    | None -> ()

Aşağıdaki örnekte, PersonName ayrımcı birleşim, olası ad biçimlerini temsil eden dizelerin ve karakterlerin bir karışımını içerir. Ayrımcı birleşim örnekleri FirstOnly, LastOnlyve FirstLast.

type PersonName =
    | FirstOnly of string
    | LastOnly of string
    | FirstLast of string * string

let constructQuery personName =
    match personName with
    | FirstOnly(firstName) -> printf "May I call you %s?" firstName
    | LastOnly(lastName) -> printf "Are you Mr. or Ms. %s?" lastName
    | FirstLast(firstName, lastName) -> printf "Are you %s %s?" firstName lastName

Adlandırılmış alanları olan ayrımcı birleşimler için, adlandırılmış bir alanın değerini ayıklamak için eşittir işaretini (=) kullanırsınız. Örneğin, aşağıdaki gibi bir bildirimle ayrımcı bir birleşim düşünün.

type Shape =
    | Rectangle of height : float * width : float
    | Circle of radius : float

Adlandırılmış alanları bir desen eşleştirme ifadesinde aşağıdaki gibi kullanabilirsiniz.

let matchShape shape =
    match shape with
    | Rectangle(height = h) -> printfn $"Rectangle with length %f{h}"
    | Circle(r) -> printfn $"Circle with radius %f{r}"

Adlandırılmış alanın kullanımı isteğe bağlıdır, bu nedenle önceki örnekte hem Circle(r) hem de Circle(radius = r) aynı etkiye sahiptir.

Birden çok alan belirttiğinizde, ayırıcı olarak noktalı virgül (;) kullanın.

match shape with
| Rectangle(height = h; width = w) -> printfn $"Rectangle with height %f{h} and width %f{w}"
| _ -> ()

Etkin desenler, daha karmaşık özel desen eşleştirmesi tanımlamanızı sağlar. Etkin desenler hakkında daha fazla bilgi için bkz. Etkin Desenler.

Tanımlayıcının özel durum olduğu durum, özel durum işleyicileri bağlamında desen eşleştirmede kullanılır. Özel durum işlemede desen eşleştirme hakkında bilgi için bkz. Özel Durumlar: try...with İfadesi.

Değişken Desenleri

Değişken deseni, eşleştirilen değeri bir değişken adıyla atar. Bu ad, -> simgesinin sağındaki yürütme ifadesinde kullanılabilir. Değişken kalıbı tek başına herhangi bir girdiyi eşleştirebilir, ancak değişken kalıpları genellikle diğer kalıpların içinde yer alır ve böylece tanımlama demetleri ve diziler gibi daha karmaşık yapıların değişkenlere ayrıştırılmasını mümkün kılar.

Aşağıdaki örnekte bir demet deseni içindeki değişken deseni gösterilmektedir.

let function1 x =
    match x with
    | (var1, var2) when var1 > var2 -> printfn "%d is greater than %d" var1 var2
    | (var1, var2) when var1 < var2 -> printfn "%d is less than %d" var1 var2
    | (var1, var2) -> printfn "%d equals %d" var1 var2

function1 (1,2)
function1 (2, 1)
function1 (0, 0)

Örnek Olarak

as deseni, sonuna bir as yan tümcesi eklenmiş bir desendir. as yan tümcesi, eşleşen değeri bir match ifadesinin çalıştırma ifadesinde kullanılabilecek bir ada bağlar veya bu desenin bir let bağlamada kullanıldığı durumlarda, ad yerel kapsamda bir bağlama olarak eklenir.

Aşağıdaki örnekte as deseni kullanılır.

let (var1, var2) as tuple1 = (1, 2)
printfn "%d %d %A" var1 var2 tuple1

OR Deseni

VEYA deseni, giriş verileri birden çok desenle eşleştiğinde ve sonuç olarak aynı kodu yürütmek istediğinizde kullanılır. OR deseninin her iki tarafının türleri uyumlu olmalıdır.

Aşağıdaki örnekte OR deseni gösterilmektedir.

let detectZeroOR point =
    match point with
    | (0, 0) | (0, _) | (_, 0) -> printfn "Zero found."
    | _ -> printfn "Both nonzero."
detectZeroOR (0, 0)
detectZeroOR (1, 0)
detectZeroOR (0, 10)
detectZeroOR (10, 15)

AND Deseni

AND deseni, girişin iki desenle eşleşmesini gerektirir. VE deseninin her iki tarafının türleri uyumlu olmalıdır.

Aşağıdaki örnek, bu konunun devamında Demet Düzeni bölümünde gösterilen detectZeroTuple gibidir, ancak burada hem var1 hem de var2 AND deseni kullanılarak değer olarak elde edilir.

let detectZeroAND point =
    match point with
    | (0, 0) -> printfn "Both values zero."
    | (var1, var2) & (0, _) -> printfn "First value is 0 in (%d, %d)" var1 var2
    | (var1, var2)  & (_, 0) -> printfn "Second value is 0 in (%d, %d)" var1 var2
    | _ -> printfn "Both nonzero."
detectZeroAND (0, 0)
detectZeroAND (1, 0)
detectZeroAND (0, 10)
detectZeroAND (10, 15)

Eksiler Kalıbı

Cons kalıbı, bir listeyi ilk öğe olan başıve kalan öğeleri içeren bir liste olan kuyrukşeklinde ayrıştırmak için kullanılır.

let list1 = [ 1; 2; 3; 4 ]

// This example uses a cons pattern and a list pattern.
let rec printList l =
    match l with
    | head :: tail -> printf "%d " head; printList tail
    | [] -> printfn ""

printList list1

Ayrıca, belirli öğe dizileriyle başlayan listeleri eşleştirmek için birden çok eksi desenini birbirine zincirleyebilirsiniz.

let charList = ['A'; 'B'; 'C'; 'D']

// This example demonstrates multiple cons patterns.
let matchChars xs =
    match xs with
    | 'A'::'B'::t -> printfn "starts with 'AB', rest: %A" t
    | 'A'::t -> printfn "starts with 'A', rest: %A" t
    | 'C'::'D'::t -> printfn "starts with 'CD', rest: %A" t
    | _ -> printfn "does not match"

matchChars charList
matchChars ['A'; 'X']
matchChars ['C'; 'D'; 'E']

Liste Düzeni

Liste düzeni, listelerin bir dizi öğeye ayrıştırılabilmesini sağlar. Liste deseninin kendisi yalnızca belirli sayıda öğe listesiyle eşleşebilir.

// This example uses a list pattern.
let listLength list =
    match list with
    | [] -> 0
    | [ _ ] -> 1
    | [ _; _ ] -> 2
    | [ _; _; _ ] -> 3
    | _ -> List.length list

printfn "%d" (listLength [ 1 ])
printfn "%d" (listLength [ 1; 1 ])
printfn "%d" (listLength [ 1; 1; 1; ])
printfn "%d" (listLength [ ] )

Dizi Deseni

Dizi düzeni liste desenine benzer ve belirli bir uzunluktaki dizileri ayrıştırmak için kullanılabilir.

// This example uses array patterns.
let vectorLength vec =
    match vec with
    | [| var1 |] -> var1
    | [| var1; var2 |] -> sqrt (var1*var1 + var2*var2)
    | [| var1; var2; var3 |] -> sqrt (var1*var1 + var2*var2 + var3*var3)
    | _ -> failwith (sprintf "vectorLength called with an unsupported array size of %d." (vec.Length))

printfn "%f" (vectorLength [| 1. |])
printfn "%f" (vectorLength [| 1.; 1. |])
printfn "%f" (vectorLength [| 1.; 1.; 1.; |])
printfn "%f" (vectorLength [| |] )

Ayraçlı Desen

Parantezler, istenen ilişkilendirmeyi elde etmek için desenler etrafında gruplandırılabilir. Aşağıdaki örnekte, ve deseni ile eksi deseni arasındaki ilişkilendirmeyi denetlemek için parantezler kullanılır.

let countValues list value =
    let rec checkList list acc =
       match list with
       | (elem1 & head) :: tail when elem1 = value -> checkList tail (acc + 1)
       | head :: tail -> checkList tail acc
       | [] -> acc
    checkList list 0

let result = countValues [ for x in -10..10 -> x*x - 4 ] 0
printfn "%d" result

Demet Deseni

Demet örüntüsü, demet biçimindeki girişlerle eşleşir ve demetteki her konum için örüntü eşleştirme değişkenleri kullanılarak demetin bileşen öğelerine ayrıştırılabilmesini sağlar.

Aşağıdaki örnek, tuple desenini gösterir ve ayrıca sabit desenler, değişken desenler ve joker desen kullanır.

let detectZeroTuple point =
    match point with
    | (0, 0) -> printfn "Both values zero."
    | (0, var2) -> printfn "First value is 0 in (0, %d)" var2
    | (var1, 0) -> printfn "Second value is 0 in (%d, 0)" var1
    | _ -> printfn "Both nonzero."
detectZeroTuple (0, 0)
detectZeroTuple (1, 0)
detectZeroTuple (0, 10)
detectZeroTuple (10, 15)

Kayıt Deseni

Kayıt düzeni, alanların değerlerini ayıklamak için kayıtları ayrıştırmak için kullanılır. Desenin kaydın tüm alanlarına başvurması gerekmez; Atlanan alanlar yalnızca eşleştirmeye katılmaz ve ayıklanmaz.

// This example uses a record pattern.

type MyRecord = { Name: string; ID: int }

let IsMatchByName record1 (name: string) =
    match record1 with
    | { MyRecord.Name = nameFound; MyRecord.ID = _; } when nameFound = name -> true
    | _ -> false

let recordX = { Name = "Parker"; ID = 10 }
let isMatched1 = IsMatchByName recordX "Parker"
let isMatched2 = IsMatchByName recordX "Hartono"

Joker Karakter Deseni

Joker karakter deseni, alt çizgi (_) karakteriyle temsil edilir ve değişken deseni gibi herhangi bir girişle eşleşir, ancak giriş bir değişkene atanmak yerine atılır. Joker karakter deseni genellikle diğer desenlerde -> simgesinin sağındaki ifadede gerekli olmayan değerler için yer tutucu olarak kullanılır. Joker karakter deseni, eşleşmeyen herhangi bir girişi eşleştirmek için desen listesinin sonunda da sık sık kullanılır. Joker karakter deseni, bu konudaki birçok kod örneğinde gösterilmiştir. Bir örnek için önceki koda bakın.

Aşağıdaki kod, joker karakter deseninin bazı ek kullanımlarını gösterir:

// Wildcard pattern matching "nothing" examples

// Example 1: Wildcard ignoring function parameters
let ignoreAllParams _ _ = "Ignores all input"

// Example 2: Wildcard in destructuring, ignoring elements
let getFirstOnly (first, _) = first

// Example 3: Using wildcard to ignore optional values
let handleEmpty opt =
    match opt with
    | Some _ -> "Has something"
    | None -> "Has nothing"

// Usage
printfn "%s" (ignoreAllParams 42 "test")
printfn "%d" (getFirstOnly (1, "ignored"))
printfn "%s" (handleEmpty None)

Tür Anotasyonlarına Sahip Desenler

Desenler tür ek açıklamalarına sahip olabilir. Bunlar diğer tür anotasyonlar gibi davranır ve diğer tür anotasyonlar gibi çıkarıma rehberlik eder. Desenlerdeki tür ek açıklamalarının çevresinde parantezler gereklidir.

Tür ek açıklamasına sahip bir desen söz dizimini pattern : type kullanır ve tür denetleyicisine derleme zamanı türü bilgileri sağlar. Bu yalnızca tür çıkarımına yardımcı olan statik bir tür ek açıklamasıdır; çalışma zamanı türü denetimi veya dönüştürmesi gerçekleştirmez. Derleyici, desen değişkeninin türünü belirlemek için derleme sırasında bu bilgileri kullanır.

Aşağıdaki kod, tür ek açıklamasına sahip bir deseni gösterir:

let detect1 x =
    match x with
    | 1 -> printfn "Found a 1!"
    | (var1 : int) -> printfn "%d" var1
detect1 0
detect1 1

Bu örnekte, (var1 : int) derleyiciye türünde intolduğunu var1 söyler. Bu, derleme zamanında çözülür ve oluşturulan kod, eşleşme ifadesi boyunca bir tamsayı olarak ele alır var1 . Bu desen herhangi bir tamsayı değeriyle eşleşir ve değerine var1bağlar.

Temel özellikler:

• Söz dizimini pattern : type kullanır (tek iki nokta üst üste ile).
• Derleme zamanında çözüldü - tür denetleyicisine tür bilgileri sağlar.
• Çalışma zamanı türü testi gerçekleştirmez.
• Tür çıkarımı ve derleyiciye yol göstermek için kullanılır.

Tür Testi Deseni

Tür testi deseni, girişi çalışma zamanındaki bir türle eşleştirmek için kullanılır. Giriş türü, desende belirtilen türle (veya türetilmiş türüyle) eşleşiyorsa, eşleşme başarılı olur.

Tür testi düzeni söz dizimini :? type kullanır ve C# içindeki veya as işleçlerine benzer şekilde isçalışma zamanı türü denetimi gerçekleştirir. Bu desen, bir değerin program yürütme sırasında belirli bir türde olup olmadığını test eder ve devralma hiyerarşileri veya arabirim uygulamalarıyla çalışırken yararlı olur.

Aşağıdaki örnekte tür testi deseni gösterilmektedir:

open System.Windows.Forms

let RegisterControl(control:Control) =
    match control with
    | :? Button as button -> button.Text <- "Registered."
    | :? CheckBox as checkbox -> checkbox.Text <- "Registered."
    | _ -> ()

Tanımlayıcının yalnızca belirli bir türetilmiş türde olup olmadığını kontrol ediyorsanız, aşağıdaki örnekte gösterildiği gibi desenin as identifier parçasına ihtiyacınız yoktur:

type A() = class end
type B() = inherit A()
type C() = inherit A()

let m (a: A) =
    match a with
    | :? B -> printfn "It's a B"
    | :? C -> printfn "It's a C"
    | _ -> ()

Temel özellikler:

• Söz dizimini :? type veya :? type as identifier (soru işaretiyle) kullanır.
• Çalışma zamanında çözüldü - yürütme sırasında gerçek tür denetimi gerçekleştirir.
• Bir değerin belirli bir türün örneği mi yoksa türetilmiş türleri mi olduğunu test eder.
• Genellikle devralma hiyerarşileri ve çok biçimli türlerle kullanılır.
• C# is işlecine veya as işlecine benzer.

Karşıtlık Türü Ek Açıklamaları ve Tür Testi Desenleri

Her iki desen de türleri içerse de, çok farklı amaçlara hizmet eder:

Özellik	Tür Ek Açıklaması Deseni (pattern : type)	Tür Testi Deseni (:? type)
Sözdizimi	Tek iki nokta üst üste: a : int	Soru işareti olan iki nokta üst üste: :? Button
Çözümlendiğinde	Derleme zamanı	Çalışma zamanı
Purpose	Kılavuzlar tür çıkarımı	Gerçek değer türünü test etme
Kullanım örneği	Derleyicinin türleri anlamasına yardımcı olma	Devralma hiyerarşilerinde çalışma zamanı türlerini denetleme
C'de eşdeğer#	Anahtar desenlerine ek açıklamalar yazma	is veya as işleçleri

Aşağıdaki örnekte farklılıklar gösterilmektedir:

// Type annotation pattern - compile time
let detect1 x =
    match x with
    | 1 -> printfn "Found a 1!"
    | (var1 : int) -> printfn "%d" var1
// The ': int' tells the compiler var1 is an int
// Everything is resolved at compile time

// Type test pattern - runtime
type A() = class end
type B() = inherit A()

let test (a: A) =
    match a with
    | :? B -> printfn "Runtime check: it's a B"
    | _ -> printfn "Runtime check: it's not a B"
// The ':? B' performs a runtime type check
// The actual type is tested during execution

Null Tasarımı

Null kalıbı, null değere izin veren türlerle çalışırken karşılaşabileceğiniz null değerle eşleşir. Null desenler sık sık .NET Framework koduyla birlikte çalışırken kullanılır. Örneğin, .NET API'sinin dönüş değeri match ifadesine giriş olarak olabilir. Dönüş değerinin null olup olmadığına ve döndürülen değerin diğer özelliklerine göre program akışını denetleyebilirsiniz. Null değerlerin programınızın geri kalanına yayılmasını önlemek için null desenini kullanabilirsiniz.

Aşağıdaki örnek null desenini ve değişken desenini kullanır.

let ReadFromFile (reader : System.IO.StreamReader) =
    match reader.ReadLine() with
    | null -> printfn "\n"; false
    | line -> printfn "%s" line; true

let fs = System.IO.File.Open("..\..\Program.fs", System.IO.FileMode.Open)
let sr = new System.IO.StreamReader(fs)
while ReadFromFile(sr) = true do ()
sr.Close()

Null desen, F# 9null atanabilirlik özellikleri için de önerilir:

let len (str: string | null) =
    match str with
    | null -> -1
    | s -> s.Length

Benzer şekilde, null atanabilirlikle ilgili yeni ayrılmışdesenlerini kullanabilirsiniz:

let len str =       // str is inferred to be `string | null`
    match str with
    | Null -> -1
    | NonNull (s: string) -> s.Length

Nameof deseni

nameof deseni, değeri nameof anahtar sözcüğünü izleyen ifadeye eşit olduğunda bir dizeyle eşleşir. Bu desen, dize değerlerini kodunuzun türleri, ayrımcı birleşim durumları veya diğer simgelerin adlarıyla eşleştirmeniz gerektiğinde özellikle yararlıdır. Bir nameof simgeyi yeniden adlandırırsanız desen otomatik olarak yeni adı kullanacağından, kullanmak derleme zamanı güvenliği sağlar.

Yaygın bir kullanım örneği, dize değerlerinin tür veya büyük/küçük harf adlarını temsil ettiği verileri seri durumdan çıkarmadır:

type EventType =
    | OrderCreated
    | OrderShipped
    | OrderDelivered

let handleEvent eventName data =
    match eventName with
    | nameof OrderCreated -> printfn "Processing order creation: %s" data
    | nameof OrderShipped -> printfn "Processing order shipment: %s" data
    | nameof OrderDelivered -> printfn "Processing order delivery: %s" data
    | _ -> printfn "Unknown event type: %s" eventName

handleEvent "OrderCreated" "Order #123" // matches first case
handleEvent "OrderShipped" "Order #123" // matches second case

Bu yaklaşım, dize değişmez değerlerini (gibi "OrderCreated") kullanmaktan daha iyidir çünkü:

• olarak yeniden adlandırırsanız OrderCreatedOrderPlaced, desen otomatik olarak güncelleştirilir.
• Derleyici, simgenin mevcut olmasını sağlayarak yazım hatalarını önler.
• Yeniden düzenleme sırasında kodunuz tutarlı olmaya devam eder.

Ayrıca şu parametrelerle de kullanabilirsiniz nameof :

let f (str: string) =
    match str with
    | nameof str -> "It's 'str'!"
    | _ -> "It is not 'str'!"

f "str" // matches
f "asdf" // does not match

Nelerin adını alabileceğiniz konusunda bilgi almak için nameof işlecine bakın.

Ayrıca bkz.

• İfadeleri Eşleştir
• Aktif Desenler
• F# Dil Referansı