Tuple

Articolo
03/05/2024

Una tupla è un raggruppamento di valori non denominati ma ordinati, possibilmente di tipi diversi. Le tuple possono essere tipi o struct di riferimento.

Sintassi

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

Osservazioni:

Ogni elemento nella sintassi precedente può essere qualsiasi espressione F# valida.

Esempi

Esempi di tuple includono coppie, triple e così via, degli stessi tipi o diversi. Alcuni esempi sono illustrati nel codice seguente.

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

Recupero di singoli valori

È possibile usare criteri di ricerca per accedere e assegnare nomi per gli elementi della tupla, come illustrato nel codice seguente.

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

È anche possibile decostruire una tupla tramite criteri di ricerca all'esterno di un'espressione match tramite let binding:

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

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

In alternativa, è possibile modificare la corrispondenza tra le tuple come input per le funzioni:

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

Se è necessario un solo elemento della tupla, è possibile usare il carattere jolly (il carattere di sottolineatura) per evitare di creare un nuovo nome per un valore che non è necessario.

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

Anche la copia di elementi da una tupla di riferimento in una tupla struct è semplice:

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

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

Le funzioni fst e snd (solo tuple di riferimento) restituiscono rispettivamente i primi e i secondi elementi di una tupla.

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

Non esiste alcuna funzione predefinita che restituisce il terzo elemento di una triple, ma è possibile scriverne facilmente uno come indicato di seguito.

let third (_, _, c) = c

In genere, è preferibile usare criteri di ricerca per accedere a singoli elementi di tupla.

Uso delle tuple

Le tuple offrono un modo pratico per restituire più valori da una funzione, come illustrato nell'esempio seguente. In questo esempio viene eseguita la divisione integer e viene restituito il risultato arrotondato dell'operazione come primo membro di una coppia di tuple e il resto come secondo membro della coppia.

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

Le tuple possono essere usate anche come argomenti di funzione quando si vuole evitare il curry implicito degli argomenti di funzione impliciti impliciti nella sintassi della funzione consueta.

let sumNoCurry (a, b) = a + b

La sintassi consueta per la definizione della funzione let sum a b = a + b consente di definire una funzione che rappresenta l'applicazione parziale del primo argomento della funzione, come illustrato nel codice seguente.

let sum a b = a + b

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

L'uso di una tupla come parametro disabilita il currying. Per altre informazioni, vedere "Applicazione parziale degli argomenti" in Funzioni.

Nomi dei tipi di tupla

Quando si scrive il nome di un tipo che è una tupla, si usa il * simbolo per separare gli elementi. Per una tupla costituita da un intoggetto , un floate , stringad esempio (10, 10.0, "ten"), il tipo verrà scritto come segue.

int * float * string

Si noti che le parentesi esterne sono obbligatorie quando si crea un alias di tipo per un tipo di tupla struct.

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

Interoperabilità con tuple C#

Le tuple in C# sono struct e sono equivalenti alle tuple di struct in F#. Se è necessario interagire con C#, è necessario usare le tuple di struct.

Questo è facile da fare. Si supponga, ad esempio, di dover passare una tupla a una classe C# e quindi di utilizzarla, che è anche una tupla:

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

Nel codice F# è quindi possibile passare una tupla di struct come parametro e usare il risultato come tupla di struct.

open TupleInterop

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

Conversione tra tuple di riferimento e tuple di struct

Poiché le tuple di riferimento e le tuple struct hanno una rappresentazione completamente diversa sottostante, non sono convertibili in modo implicito. Ovvero, il codice come il seguente non verrà compilato:

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

È necessario che il criterio corrisponda a una tupla e costruisca l'altro con le parti costitutive. Ad esempio:

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

Forma compilata di tuple di riferimento

In questa sezione viene illustrato il formato delle tuple durante la compilazione. Le informazioni riportate di seguito non sono necessarie per la lettura, a meno che non si sia destinati a .NET Framework 3.5 o versioni precedenti.

Le tuple vengono compilate in oggetti di uno dei diversi tipi generici, tutti denominati System.Tuple, di cui viene eseguito l'overload sull'arity o numero di parametri di tipo. I tipi di tupla vengono visualizzati in questo modulo quando vengono visualizzati da un altro linguaggio, ad esempio C# o Visual Basic o quando si usa uno strumento che non riconosce costrutti F#. I Tuple tipi sono stati introdotti in .NET Framework 4. Se si usa una versione precedente di .NET Framework, il compilatore usa versioni di System.Tuple dalla versione 2.0 della libreria F# Core. I tipi in questa libreria vengono usati solo per le applicazioni destinate alle versioni 2.0, 3.0 e 3.5 di .NET Framework. L'inoltro dei tipi viene usato per garantire la compatibilità binaria tra i componenti F# di .NET Framework 2.0 e .NET Framework 4.

Formato compilato di tuple di struct

Le tuple di struct (ad esempio , struct (x, y)) sono fondamentalmente diverse dalle tuple di riferimento. Vengono compilati nel ValueTuple tipo, sovraccaricati da arity o dal numero di parametri di tipo. Sono equivalenti alle tuple C# e alle tuple di Visual Basic e all'interoperabilità bidirezionale.