Expressions lambda : mot clé fun (F#)

Le fun mot clé est utilisé pour définir une expression lambda, c’est-à-dire une fonction anonyme.

Syntaxe

fun parameter-list -> expression

Ou en utilisant la _.Property notation abrégée :

_.

fun, la liste des paramètres et la flèche lambda (->) sont omises, et il _. s’agit d’une partie de l’expression où _ remplace le symbole de paramètre.

Les extraits de code suivants sont équivalents :

(fun x -> x.Property) _.Property

Remarques

La liste de paramètres se compose généralement de noms et, éventuellement, de types de paramètres. Plus généralement, la liste des paramètres peut être composée de n’importe quel modèle F#. Pour obtenir la liste complète des modèles possibles, consultez Mise en correspondance des modèles. Les listes de paramètres valides incluent les exemples suivants.

// Lambda expressions with parameter lists.
fun a b c -> ...
fun (a: int) b c -> ...
fun (a : int) (b : string) (c:float) -> ...

// A lambda expression with a tuple pattern.
fun (a, b) -> …

// A lambda expression with a cons pattern.
// (note that this will generate an incomplete pattern match warning)
fun (head :: tail) -> …

// A lambda expression with a list pattern.
// (note that this will generate an incomplete pattern match warning)
fun [_; rest] -> …

L’expression est le corps de la fonction, dont la dernière expression génère une valeur de retour. Voici quelques exemples d’expressions lambda valides :

fun x -> x + 1
fun a b c -> printfn "%A %A %A" a b c
fun (a: int) (b: int) (c: int) -> a + b * c
fun x y -> let swap (a, b) = (b, a) in swap (x, y)

Utilisation d’expressions lambda

Les expressions lambda sont particulièrement utiles lorsque vous souhaitez effectuer des opérations sur une liste ou une autre collection et que vous souhaitez éviter le travail supplémentaire de définition d’une fonction. De nombreuses fonctions de bibliothèque F# prennent des valeurs de fonction en tant qu’arguments, et il peut être particulièrement pratique d’utiliser une expression lambda dans ces cas. Le code suivant applique une expression lambda aux éléments d’une liste. Dans ce cas, la fonction anonyme vérifie si un élément est un texte qui se termine par des caractères spécifiés.

let fullNotation = [ "a"; "ab"; "abc" ] |> List.find ( fun text -> text.EndsWith("c") )
printfn "%A" fullNotation         // Output: "abc"

let shorthandNotation = [ "a"; "ab"; "abc" ] |> List.find ( _.EndsWith("b") )
printfn "%A" shorthandNotation    // Output: "ab"

L’extrait de code précédent montre les deux notations : à l’aide du fun mot clé et de la notation abrégée _.Property .

Voir aussi

• Fonctions