Tuples

  • Artikel

Een tuple is een groepering van niet-benoemde maar geordende waarden, mogelijk van verschillende typen. Tuples kunnen verwijzingstypen of structs zijn.

Syntaxis

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

Opmerkingen

Elk element in de vorige syntaxis kan elke geldige F#-expressie zijn.

Voorbeelden

Voorbeelden van tuples zijn paren, drievoudige, enzovoort, van dezelfde of verschillende typen. Enkele voorbeelden worden geïllustreerd in de volgende code.

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

Afzonderlijke waarden verkrijgen

U kunt patroonkoppeling gebruiken om namen voor tuple-elementen te openen en toe te wijzen, zoals wordt weergegeven in de volgende code.

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

U kunt een tuple ook deconstrueren via patroonkoppeling buiten een match expressie via let binding:

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

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

U kunt ook patroonovereenkomsten toepassen op tuples als invoer voor functies:

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

Als u slechts één element van de tuple nodig hebt, kan het jokerteken (het onderstrepingsteken) worden gebruikt om te voorkomen dat u een nieuwe naam maakt voor een waarde die u niet nodig hebt.

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

Het kopiëren van elementen uit een verwijzings tuple naar een struct tuple is ook eenvoudig:

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

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

De functies fst en snd (alleen verwijzings tuples) retourneren respectievelijk de eerste en tweede elementen van een tuple.

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

Er is geen ingebouwde functie die het derde element van een triple retourneert, maar u kunt er eenvoudig als volgt een schrijven.

let third (_, _, c) = c

Over het algemeen is het beter om patroonkoppeling te gebruiken voor toegang tot afzonderlijke tuple-elementen.

Tuples gebruiken

Tuples bieden een handige manier om meerdere waarden van een functie te retourneren, zoals wordt weergegeven in het volgende voorbeeld. In dit voorbeeld wordt gehele getallen verdeeld en wordt het afgeronde resultaat van de bewerking geretourneerd als eerste lid van een tuplepaar en de rest als tweede lid van het paar.

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

Tuples kunnen ook worden gebruikt als functieargumenten als u wilt voorkomen dat impliciete kerrie van functieargumenten wordt geïmpliceerd door de gebruikelijke functiesyntaxis.

let sumNoCurry (a, b) = a + b

Met de gebruikelijke syntaxis voor het definiëren van de functie let sum a b = a + b kunt u een functie definiëren die de gedeeltelijke toepassing is van het eerste argument van de functie, zoals wordt weergegeven in de volgende code.

let sum a b = a + b

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

Als u een tuple gebruikt terwijl de parameter het gebruik van curry's uitschakelt. Zie 'Gedeeltelijke toepassing van argumenten' in Functions voor meer informatie.

Namen van Tuple-typen

Wanneer u de naam van een type schrijft dat een tuple is, gebruikt u het * symbool om elementen te scheiden. Voor een tuple die bestaat uit een int, a floaten een string, zoals (10, 10.0, "ten"), wordt het type als volgt geschreven.

int * float * string

Houd er rekening mee dat buitenste haakjes verplicht zijn bij het maken van een typealias voor een struct tuple-type.

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

Interoperation with C# Tuples (Interoperation with C# Tuples)

Tuples in C# zijn structs en zijn gelijk aan struct tuples in F#. Als u wilt samenwerken met C#, moet u struct tuples gebruiken.

Dit is eenvoudig te doen. Stel dat u een tuple moet doorgeven aan een C#-klasse en vervolgens het resultaat ervan verbruikt. Dit is ook een tuple:

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

In uw F#-code kunt u vervolgens een struct tuple doorgeven als de parameter en het resultaat gebruiken als een struct tuple.

open TupleInterop

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

Converteren tussen verwijzings tuples en Struct Tuples

Omdat verwijzings-Tuples en Struct Tuples een volledig andere onderliggende representatie hebben, zijn ze niet impliciet converteerbaar. Dat wil gezegd, code zoals het volgende wordt niet gecompileerd:

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

U moet een patroonovereenkomst hebben op de ene tuple en de andere met de samenstellende onderdelen samenstellen. Voorbeeld:

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

Gecompileerde vorm van verwijzings tuples

In deze sectie wordt de vorm van tuples uitgelegd wanneer ze worden gecompileerd. De informatie hier is niet nodig om te lezen, tenzij u zich richt op .NET Framework 3.5 of lager.

Tuples worden gecompileerd in objecten van een van de verschillende algemene typen, allemaal benoemd System.Tuple, die overbelast zijn op de arity of het aantal typeparameters. Tuple-typen worden in dit formulier weergegeven wanneer u deze vanuit een andere taal bekijkt, zoals C# of Visual Basic, of wanneer u een hulpprogramma gebruikt dat niet op de hoogte is van F#-constructies. De Tuple typen zijn geïntroduceerd in .NET Framework 4. Als u zich richt op een eerdere versie van .NET Framework, gebruikt de compiler versies van System.Tuple de 2.0-versie van de F#Core-bibliotheek. De typen in deze bibliotheek worden alleen gebruikt voor toepassingen die gericht zijn op de 2.0-, 3.0- en 3.5-versies van .NET Framework. Type doorsturen wordt gebruikt om binaire compatibiliteit tussen .NET Framework 2.0- en .NET Framework 4 F#-onderdelen te garanderen.

Gecompileerde vorm van Struct Tuples

Struct tuples (bijvoorbeeld struct (x, y)), verschillen fundamenteel van verwijzings tuples. Ze worden gecompileerd in het ValueTuple type, overbelast door arity of het aantal typeparameters. Ze zijn gelijk aan C# Tuples en Visual Basic Tuples en interoperationeel bidirectioneel.

Zie ook