F # - Fonctions

En F #, les fonctions fonctionnent comme des types de données. Vous pouvez déclarer et utiliser une fonction de la même manière que toute autre variable.

Puisque les fonctions peuvent être utilisées comme n'importe quelle autre variable, vous pouvez -

  • Créez une fonction, avec un nom et associez ce nom à un type.
  • Attribuez-lui une valeur.
  • Effectuez un calcul sur cette valeur.
  • Passez-le comme paramètre à une autre fonction ou sous-routine.
  • Renvoie une fonction comme résultat d'une autre fonction.

Définition d'une fonction

Les fonctions sont définies en utilisant le letmot-clé. Une définition de fonction a la syntaxe suivante -

let [inline] function-name parameter-list [ : return-type ]
   = function-body

Où,

  • function-name est un identifiant qui représente la fonction.

  • parameter-listdonne la liste des paramètres séparés par des espaces. Vous pouvez également spécifier un type explicite pour chaque paramètre et, s'il n'est pas spécifié, le compilateur a tendance à le déduire du corps de la fonction (comme les variables).

  • function-bodyse compose d'une expression ou d'une expression composée constituée d'un certain nombre d'expressions. La dernière expression dans le corps de la fonction est la valeur de retour.

  • return-typeest un deux-points suivi d'un type et est facultatif. Si le type de retour n'est pas spécifié, le compilateur le détermine à partir de l'expression finale dans le corps de la fonction.

Paramètres d'une fonction

Vous listez les noms des paramètres juste après le nom de la fonction. Vous pouvez spécifier le type d'un paramètre. Le type du paramètre doit suivre le nom du paramètre séparé par deux points.

Si aucun type de paramètre n'est spécifié, il est déduit par le compilateur.

Par exemple -

let doubleIt (x : int) = 2 * x

Appeler une fonction

Une fonction est appelée en spécifiant le nom de la fonction suivi d'un espace, puis de tous les arguments séparés par des espaces.

Par exemple -

let vol = cylinderVolume 3.0 5.0

Les programmes suivants illustrent les concepts.

Exemple 1

Le programme suivant calcule le volume d'un cylindre lorsque le rayon et la longueur sont donnés en paramètres

// the function calculates the volume of
// a cylinder with radius and length as parameters

let cylinderVolume radius length : float =

   // function body
   let pi = 3.14159
   length * pi * radius * radius

let vol = cylinderVolume 3.0 5.0
printfn " Volume: %g " vol

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Volume: 141.372

Exemple 2

Le programme suivant renvoie la plus grande valeur de deux paramètres donnés -

// the function returns the larger value between two
// arguments

let max num1 num2 : int32 =
   // function body
   if(num1>num2)then
      num1
   else
      num2

let res = max 39 52
printfn " Max Value: %d " res

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Max Value: 52

Exemple 3

let doubleIt (x : int) = 2 * x
printfn "Double 19: %d" ( doubleIt(19))

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Double 19: 38

Fonctions récursives

Les fonctions récursives sont des fonctions qui s'appellent elles-mêmes.

Vous définissez une récursive à l'aide du let rec combinaison de mots clés.

La syntaxe pour définir une fonction récursive est -

//Recursive function definition
let rec function-name parameter-list = recursive-function-body

Par exemple -

let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2)

Exemple 1

Le programme suivant renvoie Fibonacci 1 à 10 -

let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2)
for i = 1 to 10 do
   printfn "Fibonacci %d: %d" i (fib i)

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Fibonacci 1: 1
Fibonacci 2: 2
Fibonacci 3: 3
Fibonacci 4: 5
Fibonacci 5: 8
Fibonacci 6: 13
Fibonacci 7: 21
Fibonacci 8: 34
Fibonacci 9: 55
Fibonacci 10: 89

Exemple 2

Le programme suivant renvoie factoriel 8 -

open System
let rec fact x =
   if x < 1 then 1
   else x * fact (x - 1)
Console.WriteLine(fact 8)

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

40320

Notations de flèche en F #

F # rapporte le type de données dans les fonctions et les valeurs, en utilisant une notation de flèche chaînée. Prenons un exemple de fonction qui prend une entrée int et renvoie une chaîne. En notation fléchée, il s'écrit -

int -> string

Les types de données sont lus de gauche à droite.

Prenons une autre fonction hypothétique qui prend deux entrées de données int et renvoie une chaîne.

let mydivfunction x y = (x / y).ToString();;

F # rapporte le type de données en utilisant la notation de flèche chaînée comme -

val mydivfunction : x:int -> y:int -> string

Le type de retour est représenté par le type de données le plus à droite dans la notation de flèche chaînée.

Quelques autres exemples -

Notation Sens
flotteur → flotteur → flotteur La fonction prend deux entrées float , retourne un autre float .
int → chaîne → float La fonction prend un int et une chaîne d' entrée, retourne un flottant .

Expressions lambda

UNE lambda expression est une fonction sans nom.

Prenons un exemple de deux fonctions -

let applyFunction ( f: int -> int -> int) x y = f x y
let mul x y = x * y
let res = applyFunction mul 5 7
printfn "%d" res

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

35

Maintenant, dans l'exemple ci-dessus, si au lieu de définir la fonction mul, nous aurions pu utiliser des expressions lambda comme -

let applyFunction ( f: int -> int -> int) x y = f x y
let res = applyFunction (fun x y -> x * y ) 5 7
printfn "%d" res

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

35

Composition des fonctions et pipelining

En F #, une fonction peut être composée d'autres fonctions.

L'exemple suivant montre la composition d'une fonction nommée f, à partir de deux fonctions function1 et function2 -

let function1 x = x + 1
let function2 x = x * 5

let f = function1 >> function2
let res = f 10
printfn "%d" res

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

55

F # fournit également une fonctionnalité appelée pipelining of functions. Le pipelining permet d'enchaîner les appels de fonction en tant qu'opérations successives.

L'exemple suivant montre que -

let function1 x = x + 1
let function2 x = x * 5

let res = 10 |> function1 |> function2
printfn "%d" res

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

55