Tupplar

Artikel
03/05/2024

En tuppeln är en gruppering av namnlösa men ordnade värden, eventuellt av olika typer. Tupplar kan antingen vara referenstyper eller structs.

Syntax

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

Kommentarer

Varje element i föregående syntax kan vara valfritt giltigt F#-uttryck.

Exempel

Exempel på tupplar är par, tripplar och så vidare av samma eller olika typer. Några exempel illustreras i följande kod.

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

Hämta enskilda värden

Du kan använda mönstermatchning för att komma åt och tilldela namn för tuppelns element, enligt följande kod.

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

Du kan också dekonstruera en tuppeln via mönstermatchning utanför ett match uttryck via let bindning:

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

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

Eller så kan du mönstermatcha på tupplar som indata till funktioner:

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

Om du bara behöver ett element i tuppeln kan jokertecknet (understrecket) användas för att undvika att skapa ett nytt namn för ett värde som du inte behöver.

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

Det är också enkelt att kopiera element från en referenstupplar till en struct-tupplar:

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

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

Funktionerna fst och snd (endast referenstupplar) returnerar de första respektive andra elementen i en tupplar.

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

Det finns ingen inbyggd funktion som returnerar det tredje elementet i en trippel, men du kan enkelt skriva en på följande sätt.

let third (_, _, c) = c

I allmänhet är det bättre att använda mönstermatchning för att komma åt enskilda tupppelelement.

Använda tupplar

Tupplar är ett bekvämt sätt att returnera flera värden från en funktion, som du ser i följande exempel. Det här exemplet utför heltalsdelning och returnerar det rundade resultatet av åtgärden som första medlem i ett tupplarpar och resten som en andra medlem i paret.

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

Tupplar kan också användas som funktionsargument när du vill undvika implicit currying av funktionsargument som underförstås av den vanliga funktionssyntaxen.

let sumNoCurry (a, b) = a + b

Med den vanliga syntaxen för att definiera funktionen let sum a b = a + b kan du definiera en funktion som är den partiella tillämpningen av funktionens första argument, enligt följande kod.

let sum a b = a + b

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

Om du använder en tupplar som parameter inaktiveras currying. Mer information finns i "Partiell tillämpning av argument" i Functions.

Namn på tuppelns typer

När du skriver ut namnet på en typ som är en tuppeln använder du symbolen * för att separera element. För en tuppeln som består av , inten float, och en string, till exempel (10, 10.0, "ten"), skrivs typen på följande sätt.

int * float * string

Observera att yttre parenteser är obligatoriska när du skapar ett typalias för en struct tupplartyp.

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

Samverkan med C#-tupplar

Tupplar i C# är structs och motsvarar struct tupplar i F#. Om du behöver samverka med C#, måste du använda struct tupplar.

Det är lätt att göra. Anta till exempel att du måste skicka en tuppeln till en C#-klass och sedan använda resultatet, vilket också är en tuppeln:

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

I F#-koden kan du sedan skicka en struct tuppeln som parameter och använda resultatet som en struct tuppeln.

open TupleInterop

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

Konvertera mellan referenstupplar och Struct-tupplar

Eftersom Referenstupplar och Struct Tuples har en helt annan underliggande representation, är de inte implicit konvertibla. Kod som följande kompileras alltså inte:

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

Du måste mönstra matchning på en tuppeln och konstruera den andra med de ingående delarna. Till exempel:

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

Kompilerad form av referenstupplar

I det här avsnittet beskrivs tupplar när de kompileras. Informationen här är inte nödvändig för att läsa om du inte riktar in dig på .NET Framework 3.5 eller lägre.

Tupplar kompileras till objekt av någon av flera generiska typer, alla med namnet System.Tuple, som är överbelastade på ariteten eller antalet typparametrar. Tupplar visas i det här formuläret när du visar dem från ett annat språk, till exempel C# eller Visual Basic, eller när du använder ett verktyg som inte känner till F#-konstruktioner. Typerna Tuple introducerades i .NET Framework 4. Om du riktar in dig på en tidigare version av .NET Framework använder kompilatorn versioner av System.Tuple från 2.0-versionen av F#Core-biblioteket. Typerna i det här biblioteket används endast för program som riktar sig till versionerna 2.0, 3.0 och 3.5 av .NET Framework. Typvidarebefordring används för att säkerställa binär kompatibilitet mellan .NET Framework 2.0- och .NET Framework 4 F#-komponenter.

Kompilerad form av Struct Tuples

Struct-tupplar (till exempel struct (x, y)), skiljer sig i grunden från referenstupplar. De kompileras till ValueTuple typen, överbelastade av aritet eller antalet typparametrar. De motsvarar C#-tupplar och Visual Basic-tupplar och samverkar dubbelriktat.

Dela via