Tuples

Un tuple est un regroupement de valeurs non nommées mais ordonnées, éventuellement de différents types. Les tuples peuvent être des types de référence ou des structs.

Syntaxe

(element, ... , element)
struct(element, ... ,element )

Remarques

Chaque élément de la syntaxe précédente peut être n’importe quelle expression F# valide.

Exemples

Des exemples de tuples incluent des paires, des triples, et ainsi de suite, des mêmes types ou différents. Certains exemples sont illustrés dans le code suivant.

(1, 2)

// Triple of strings.
("one", "two", "three")

// Tuple of generic types.
(a, b)

// Tuple that has mixed types.
("one", 1, 2.0)

// Tuple of integer expressions.
(a + 1, b + 1)

// Struct Tuple of floats
struct (1.025f, 1.5f)

Obtention de valeurs individuelles

Vous pouvez utiliser des critères correspondants pour accéder aux éléments tuples et leur attribuer des noms, comme indiqué dans le code suivant.

let print tuple1 =
   match tuple1 with
    | (a, b) -> printfn "Pair %A %A" a b

Vous pouvez également déconstructer un tuple par le biais d’un modèle correspondant en dehors d’une match expression via let la liaison :

let (a, b) = (1, 2)

// Or as a struct
let struct (c, d) = struct (1, 2)

Vous pouvez également créer une correspondance sur les tuples en tant qu’entrées pour les fonctions :

let getDistance ((x1,y1): float*float) ((x2,y2): float*float) =
    // Note the ability to work on individual elements
    (x1*x2 - y1*y2) 
    |> abs 
    |> sqrt

Si vous n’avez besoin que d’un seul élément du tuple, le caractère générique (le trait de soulignement) peut être utilisé pour éviter de créer un nouveau nom pour une valeur dont vous n’avez pas besoin.

let (a, _) = (1, 2)

La copie d’éléments d’un tuple de référence dans un tuple de struct est également simple :

// Create a reference tuple
let (a, b) = (1, 2)

// Construct a struct tuple from it
let struct (c, d) = struct (a, b)

Les fonctions fst et snd (tuples de référence uniquement) retournent les premiers et deuxième éléments d’un tuple, respectivement.

let c = fst (1, 2)
let d = snd (1, 2)

Il n’existe aucune fonction intégrée qui retourne le troisième élément d’un triple, mais vous pouvez facilement en écrire une comme suit.

let third (_, _, c) = c

En règle générale, il est préférable d’utiliser des critères correspondants pour accéder à des éléments tuples individuels.

Utilisation de Tuples

Les tuples offrent un moyen pratique de retourner plusieurs valeurs d’une fonction, comme illustré dans l’exemple suivant. Cet exemple effectue une division entière et retourne le résultat arrondi de l’opération en tant que premier membre d’une paire tuple et le reste en tant que deuxième membre de la paire.

let divRem a b =
   let x = a / b
   let y = a % b
   (x, y)

Les tuples peuvent également être utilisés comme arguments de fonction lorsque vous souhaitez éviter le curry implicite des arguments de fonction implicites qui est implicite par la syntaxe de fonction habituelle.

let sumNoCurry (a, b) = a + b

La syntaxe habituelle de définition de la fonction let sum a b = a + b vous permet de définir une fonction qui est l’application partielle du premier argument de la fonction, comme illustré dans le code suivant.

let sum a b = a + b

let addTen = sum 10
let result = addTen 95
// Result is 105.

L’utilisation d’un tuple comme paramètre désactive le currying. Pour plus d’informations, consultez « Application partielle des arguments » dans Functions.

Noms des types Tuple

Lorsque vous écrivez le nom d’un type qui est un tuple, vous utilisez le * symbole pour séparer les éléments. Pour un tuple qui se compose d’un , d’un int, d’un float, et d’un string, tel que (10, 10.0, "ten"), le type serait écrit comme suit.

int * float * string

Notez que les parenthèses externes sont obligatoires lors de la création d’un alias de type pour un type tuple de struct.

type TupleAlias = string * float
type StructTupleAlias = (struct (string * float))

Interopération avec des tuples C#

Les tuples en C# sont des structs et sont équivalents aux tuples de struct en F#. Si vous avez besoin d’interagir avec C#, vous devez utiliser des tuples de struct.

C’est facile à faire. Par exemple, imaginez que vous devez passer un tuple à une classe C#, puis consommer son résultat, qui est également un tuple :

namespace CSharpTupleInterop
{
    public static class Example
    {
        public static (int, int) AddOneToXAndY((int x, int y) a) =>
            (a.x + 1, a.y + 1);
    }
}

Dans votre code F#, vous pouvez ensuite passer un tuple de struct en tant que paramètre et consommer le résultat en tant que tuple de struct.

open TupleInterop

let struct (newX, newY) = Example.AddOneToXAndY(struct (1, 2))
// newX is now 2, and newY is now 3

Conversion entre tuples de référence et tuples de struct

Étant donné que les tuples de référence et les tuples de struct ont une représentation sous-jacente complètement différente, ils ne sont pas implicitement convertibles. Autrement dit, le code tel que le suivant ne sera pas compilé :

// Will not compile!
let (a, b) = struct (1, 2)

// Will not compile!
let struct (c, d) = (1, 2)

// Won't compile!
let f(t: struct(int*int)): int*int = t

Vous devez faire correspondre un modèle sur un tuple et construire l’autre avec les parties constituantes. Par exemple:

// Pattern match on the result.
let (a, b) = (1, 2)

// Construct a new tuple from the parts you pattern matched on.
let struct (c, d) = struct (a, b)

Forme compilée de tuples de référence

Cette section explique la forme des tuples lorsqu’ils sont compilés. Les informations fournies ici ne sont pas nécessaires pour lire, sauf si vous ciblez .NET Framework 3.5 ou une version antérieure.

Les tuples sont compilés en objets d’un de plusieurs types génériques, tous nommés System.Tuple, surchargés sur l’arité ou le nombre de paramètres de type. Les types tuple apparaissent dans ce formulaire lorsque vous les affichez à partir d’un autre langage, tel que C# ou Visual Basic, ou lorsque vous utilisez un outil qui ne connaît pas les constructions F#. Les Tuple types ont été introduits dans .NET Framework 4. Si vous ciblez une version antérieure de .NET Framework, le compilateur utilise des versions de System.Tuple la version 2.0 de la bibliothèque F# Core. Les types de cette bibliothèque sont utilisés uniquement pour les applications qui ciblent les versions 2.0, 3.0 et 3.5 de .NET Framework. Le transfert de type est utilisé pour garantir la compatibilité binaire entre les composants .NET Framework 2.0 et .NET Framework 4 F#.

Forme compilée de tuples de struct

Les tuples de struct (par exemple, struct (x, y)), sont fondamentalement différents des tuples de référence. Ils sont compilés dans le ValueTuple type, surchargés par arité ou le nombre de paramètres de type. Ils sont équivalents à C# Tuples et Visual Basic Tuples, et interopérabilité bidirectionnellement.

Voir aussi

• Référence du langage F#
• Types F#