F # açık eşleme ve işlev sözdizimi

Belirsiz başlık için üzgünüz, ancak bu sorunun bir kısmı bu iki söz dizimi stilinin adıdır:

let foo1 x = 
    match x with
    | 1 -> "one"
    | _ -> "not one"

let foo2 = function 
    | 1 -> "one" 
    | _ -> "not one"

Diğer kısım, ikisi arasında ne fark olduğu ve birini ne zaman kullanmak isteyeceğim?

Eşleşme versiyonuna "model eşleştirme ifadesi" adı verilir. İşlev sürümüne "desen eşleştirme işlevi" adı verilir. Spesifikasyonun 6.6.4 bölümünde bulundu .

Birini diğerinin üzerinde kullanmak bir stil meselesidir. Yalnızca bir eşleşme ifadesi olan bir işlevi tanımlamam gerektiğinde yalnızca işlev sürümünü kullanmayı tercih ederim.

İkinci sözdiziminin uzmanı, bir lambda'da kullanıldığında biraz daha kısa ve okunaklı olabileceğidir.

List.map (fun x -> match x with | 1 -> "one" | _ -> "not one") [0;1;2;3;1]

vs

List.map (function 1 -> "one" | _ -> "not one") [0;1;2;3;1]

Eşleşme ifadesinin tüm işlev olduğu ve işlevin yalnızca tek bir argümana sahip olduğu (tuplelar bir olarak sayılır) özel durumda işlev sürümü, tam eşleşme sözdizimi için kısa bir eldir. İki bağımsız değişkene sahip olmak istiyorsanız, tam eşleşme sözdizimini * kullanmanız gerekir. Bunu aşağıdaki iki işlevin türlerinde görebilirsiniz.

//val match_test : string -> string -> string
let match_test x y = match x, y with
                        | "A", _ -> "Hello A"
                        | _, "B" -> "Hello B"
                        | _ -> "Hello ??"

//val function_test : string * string -> string                   
let function_test = function
                        | "A", _ -> "Hello A"
                        | _, "B" -> "Hello B"
                        | _ -> "Hello ??"

Gördüğünüz gibi, eşleşme sürümü iki ayrı argüman alırken, fonksiyon versiyonu tek bir tupled argüman alır. İşlev sözdiziminin daha temiz göründüğünü bulduğum için çoğu tek bağımsız değişken işlevi için işlev sürümünü kullanıyorum.

* Eğer gerçekten istiyorsanız, işlev sürümünün doğru tip imzasına sahip olmasını sağlayabilirsiniz, ancak bence oldukça çirkin görünüyor - aşağıdaki örneğe bakın.

//val function_match_equivalent : string -> string -> string
let function_match_equivalent x y = (x, y) |> function
                                                | "A", _ -> "Hello A"
                                                | _, "B" -> "Hello B"
                                                | _ -> "Hello ??"

Sizin durumunuzda da aynı şeyi yaparlar - functionanahtar kelime, funanahtar kelimenin (anonim bir lambda üretmek için) ardından anahtar kelimenin bir kombinasyonu gibi davranır match.

Yani teknik olarak bu ikisi aynı, a eklenmiş fun:

let foo1 = fun x ->
    match x with
    | 1 -> "one"
    | _ -> "not one"

let foo2 = function
    | 1 -> "one"
    | _ -> "not one"

Eksiksizlik uğruna, Uzman FSharp'ın 321. sayfasına gittim :

"Not, Liste 12-2, ifade biçimini kullanır function pattern-rules -> expression. Bu, (fun x -> match x with pattern-rules -> expression)doğrudan ayrımcılığa uğramış sendikalar üzerinde çalışan işlevleri tanımlamanın bir yolu olarak eşdeğerdir ve özellikle uygundur."

işlevi yalnızca bir argümana izin verir, ancak desen eşleştirmesine izin verirken, eğlence bir işlevi tanımlamanın daha genel ve esnek yoludur. Buraya bir göz atın: http://caml.inria.fr/pub/docs/manual-ocaml/expr.html

İki sözdizimi eşdeğerdir. Çoğu programcı birini veya diğerini seçer ve ardından tutarlı bir şekilde kullanır.

İlk sözdizimi, işlev çalışmaya başlamadan önce birkaç bağımsız değişkeni kabul ettiğinde daha okunaklı kalır.

Bu eski bir soru ama 0,02 dolarımı atacağım.

Genel matcholarak, "açık olanın örtükten daha iyi olduğu" Python dünyasından geldiğim için sürümü daha çok seviyorum .

Elbette, parametrede tür bilgisi gerekiyorsa functionsürüm kullanılamaz.

OTOH tarafından yapılan argümanı beğendim, Stringerböylece functionbasit lambdalarda kullanmaya başlayacağım .