F# explicite match vs syntaxe de la fonction

Question

Désolé au sujet de la vague de titre, mais une partie de cette question est ce que ces deux la syntaxe styles sont appelés:

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

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

L'autre partie est quelle différence il y a entre les deux, et quand je veux utiliser l'un ou l'autre?

Answer 1

La pro de la seconde syntaxe est que lorsqu'il est utilisé dans un lambda, il pourrait être un peu plus concis et lisible.

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]

Answer 2

Le match version est appelée un "pattern matching expression". La version fonction est appelée un "pattern matching function". Trouvé dans la section 6.6.4 de la spec.

À l'aide de l'un sur l'autre est une affaire de style. Je préfère que l'aide de la fonction de la version quand j'ai besoin de définir une fonction qui n'est qu'un match de déclaration.

Answer 3

La fonction de la version est un raccourci pour la correspondance complète de la syntaxe dans le cas particulier où le match déclaration est l'ensemble de la fonction et de la fonction n'a qu'un seul argument (tuples comptent pour un). Si vous voulez avoir deux arguments, alors vous devez utiliser la correspondance complète de la syntaxe*. Vous pouvez les voir dans les types des deux fonctions suivantes.

//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 ??"

Comme vous pouvez le voir match version prend deux arguments alors que la version fonction prend un seul tupled argument. J'utilise la fonction de la version pour la plupart un seul argument fonctions car je trouve la syntaxe de la fonction semble plus propre.

*Si vous avez vraiment envie de vous pouvez obtenir la fonction de la version de la signature, mais il a l'air assez moche à mon avis - voir l'exemple ci-dessous.

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

Answer 4

Ils font la même chose dans votre cas, l' function mot agit comme une combinaison de l' fun mot-clé (pour produire un anonyme lambda), suivie par l' match mot-clé.

Donc, techniquement, ces deux sont les mêmes, avec l'ajout d'un fun:

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

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

Answer 5

Juste par souci d'exhaustivité, je viens de recevoir à la page 321 de l' Expert FSharp:

"Remarque, Liste 12-2 utilise l'expression de la forme function pattern-rules -> expression. C'est l'équivalent d' (fun x -> match x with pattern-rules -> expression) et est particulièrement pratique comme un moyen de définir des fonctions de travail directement au-dessus de victimes de syndicats."