Tupel

Ein Tupel ist eine Gruppierung von nicht benannten, aber sortierten Werten, möglicherweise von verschiedenen Typen. Tupel können entweder Referenztypen oder Strukturen sein.

Syntax

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

Bemerkungen

Jedes Element in der vorherigen Syntax kann ein beliebiger gültiger F#-Ausdruck sein.

Beispiele

Beispiele für Tupel sind Paare, Dreifache usw. der gleichen oder unterschiedlichen Typen. Einige Beispiele werden im folgenden Code veranschaulicht.

(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)

Abrufen einzelner Werte

Sie können den Musterabgleich verwenden, um auf Tupelelemente zuzugreifen und Namen zuzuweisen, wie im folgenden Code gezeigt.

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

Sie können ein Tupel auch über Musterabgleich außerhalb eines match Ausdrucks über let Bindung deconieren:

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

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

Alternativ können Sie die Musterüberstimmung auf Tupeln als Eingaben für Funktionen verwenden:

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

Wenn Sie nur ein Element des Tupels benötigen, kann das Wildcardzeichen (unterstrich) verwendet werden, um zu vermeiden, dass ein neuer Name für einen Wert erstellt wird, den Sie nicht benötigen.

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

Das Kopieren von Elementen aus einem Verweis-Tupel in ein Struktur-Tupel ist ebenfalls einfach:

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

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

Die Funktionen fst und snd (nur Referenz-Tupel) geben die ersten bzw. zweiten Elemente eines Tupels zurück.

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

Es gibt keine integrierte Funktion, die das dritte Element eines Dreifaches zurückgibt, aber Sie können eins ganz einfach wie folgt schreiben.

let third (_, _, c) = c

Im Allgemeinen ist es besser, Musterabgleich zu verwenden, um auf einzelne Tupelelemente zuzugreifen.

Verwenden von Tupeln

Tupel bieten eine bequeme Möglichkeit, mehrere Werte aus einer Funktion zurückzugeben, wie im folgenden Beispiel gezeigt. In diesem Beispiel wird eine ganzzahlige Division ausgeführt und das abgerundete Ergebnis des Vorgangs als erstes Element eines Tupelpaars und des Rests als zweites Element des Paares zurückgegeben.

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

Tupel können auch als Funktionsargumente verwendet werden, wenn Sie die implizite Implizitkeit von Funktionsargumenten vermeiden möchten, die von der üblichen Funktionssyntax impliziert werden.

let sumNoCurry (a, b) = a + b

Die übliche Syntax zum Definieren der Funktion let sum a b = a + b ermöglicht es Ihnen, eine Funktion zu definieren, die die partielle Anwendung des ersten Arguments der Funktion ist, wie im folgenden Code gezeigt.

let sum a b = a + b

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

Durch Die Verwendung eines Tupels als Parameter wird die Verwendung von Pickling deaktiviert. Weitere Informationen finden Sie unter "Partielle Anwendung von Argumenten" in Funktionen.

Namen von Tupeltypen

Wenn Sie den Namen eines Typs ausschreiben, der ein Tupel ist, verwenden Sie das * Symbol, um Elemente zu trennen. Bei einem Tupel, das aus einem , a intfloatund einem string, z(10, 10.0, "ten"). B. , besteht, wird der Typ wie folgt geschrieben.

int * float * string

Beachten Sie, dass äußere Klammern beim Erstellen eines Typalias für einen Struktur-Tupeltyp obligatorisch sind.

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

Interoperabilität mit C#-Tupeln

Tupel in C# sind Strukturen und entsprechen den Struktur-Tupeln in F#. Wenn Sie mit C# zusammenarbeiten müssen, müssen Sie Struktur-Tupel verwenden.

Dies ist einfach zu tun. Stellen Sie sich z. B. vor, Sie müssen ein Tupel an eine C#-Klasse übergeben und dann dessen Ergebnis verbrauchen, was auch ein Tupel ist:

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

Im F#-Code können Sie dann ein Struktur-Tupel als Parameter übergeben und das Ergebnis als Struct-Tupel verwenden.

open TupleInterop

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

Konvertieren zwischen Referenz-Tupeln und Struktur-Tupeln

Da "Reference Tuples" und "Struct Tuples" eine völlig andere zugrunde liegende Darstellung aufweisen, sind sie nicht implizit konvertierbar. Das heißt, Code wie folgendes wird nicht kompiliert:

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

Sie müssen eine Mustervergleichung auf einem Tupel ausführen und den anderen mit den Bestandteilen konstruieren. Beispiel:

// 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)

Kompilierte Form von Referenz-Tupeln

In diesem Abschnitt wird die Form von Tupeln erläutert, wenn sie kompiliert werden. Die hier aufgeführten Informationen sind nicht zu lesen, es sei denn, Sie sind auf .NET Framework 3.5 oder niedriger ausgerichtet.

Tupel werden in Objekte eines von mehreren generischen Typen kompiliert, alle benannten System.Tuple, die für den Arity überladen sind oder die Anzahl der Typparameter. Tupeltypen werden in diesem Formular angezeigt, wenn Sie sie aus einer anderen Sprache anzeigen, z. B. C# oder Visual Basic, oder wenn Sie ein Tool verwenden, das F#-Konstrukte nicht kennt. Die Tuple Typen wurden in .NET Framework 4 eingeführt. Wenn Sie auf eine frühere Version von .NET Framework abzielen, verwendet der Compiler Versionen System.Tuple von der 2.0-Version der F#-Kernbibliothek. Die Typen in dieser Bibliothek werden nur für Anwendungen verwendet, die auf die Versionen 2.0, 3.0 und 3.5 von .NET Framework abzielen. Die Typweiterleitung wird verwendet, um die binäre Kompatibilität zwischen .NET Framework 2.0- und .NET Framework 4 F#-Komponenten sicherzustellen.

Kompilierte Form von Struktur-Tupeln

Struktur-Tupel (z. B struct (x, y). ) unterscheiden sich grundlegend von Referenz-Tupeln. Sie werden in den ValueTuple Typ kompiliert, von Arity überladen oder die Anzahl der Typparameter. Sie entsprechen C#-Tupeln und Visual Basic-Tupeln und werden bidirektional interoperiert.

Siehe auch

• F#-Sprachreferenz
• F#-Typen