Tuplas

Uma tupla é um agrupamento de valores não nomeados, mas ordenados, possivelmente de tipos diferentes. Tuplas podem ser tipos de referência ou structs.

Sintaxe

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

Observações

Cada elemento na sintaxe anterior pode ser qualquer expressão F# válida.

Exemplos

Exemplos de tuplas incluem pares, triplos e assim por diante, dos mesmos tipos ou diferentes. Alguns exemplos são ilustrados no código a seguir.

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

Obtendo valores individuais

Você pode usar a correspondência de padrões para acessar e atribuir nomes para elementos de tupla, conforme mostrado no código a seguir.

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

Você também pode desconstruir uma tupla por meio da correspondência de padrões fora de uma match expressão por meio let da associação:

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

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

Ou você pode fazer a correspondência padrão em tuplas como entradas para funções:

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 você precisar apenas de um elemento da tupla, o caractere curinga (o sublinhado) poderá ser usado para evitar a criação de um novo nome para um valor que você não precisa.

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

Copiar elementos de uma tupla de referência em uma tupla de struct também é simples:

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

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

As funções fst e snd (somente tuplas de referência) retornam o primeiro e o segundo elementos de uma tupla, respectivamente.

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

Não há nenhuma função interna que retorne o terceiro elemento de um triplo, mas você pode facilmente escrever um da seguinte maneira.

let third (_, _, c) = c

Geralmente, é melhor usar a correspondência de padrões para acessar elementos de tupla individuais.

Usando tuplas

As tuplas fornecem uma maneira conveniente de retornar vários valores de uma função, conforme mostrado no exemplo a seguir. Este exemplo executa a divisão inteiro e retorna o resultado arredondado da operação como um primeiro membro de um par de tuplas e o restante como um segundo membro do par.

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

Tuplas também podem ser usadas como argumentos de função quando você deseja evitar o curry implícito de argumentos de função implícitos pela sintaxe de função usual.

let sumNoCurry (a, b) = a + b

A sintaxe usual para definir a função let sum a b = a + b permite definir uma função que é a aplicação parcial do primeiro argumento da função, conforme mostrado no código a seguir.

let sum a b = a + b

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

Usar uma tupla como parâmetro desabilita o currying. Para obter mais informações, consulte "Aplicação parcial de argumentos" em funções.

Nomes de tipos de tupla

Ao escrever o nome de um tipo que é uma tupla, use o * símbolo para separar elementos. Para uma tupla que consiste em um int, um floate um string, como (10, 10.0, "ten"), o tipo seria escrito da seguinte maneira.

int * float * string

Observe que parênteses externos são obrigatórios ao criar um alias de tipo para um tipo de tupla struct.

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

Interoperação com Tuplas do C#

Tuplas em C# são structs e são equivalentes a tuplas de struct em F#. Se você precisar interoperar com C#, deverá usar tuplas de struct.

Isso é fácil de fazer. Por exemplo, imagine que você precisa passar uma tupla para uma classe C# e, em seguida, consumir seu resultado, que também é uma tupla:

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

Em seu código F#, você pode passar uma tupla de struct como o parâmetro e consumir o resultado como uma tupla de struct.

open TupleInterop

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

Convertendo entre tuplas de referência e tuplas de struct

Como tuplas de referência e tuplas struct têm uma representação subjacente completamente diferente, elas não são implicitamente conversíveis. Ou seja, código como o seguinte não será compilado:

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

Você deve corresponder a um padrão em uma tupla e construir o outro com as partes constituintes. Por exemplo:

// 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 compilada de tuplas de referência

Esta seção explica a forma de tuplas quando elas são compiladas. As informações aqui não são necessárias para leitura, a menos que você esteja direcionando o .NET Framework 3.5 ou inferior.

As tuplas são compiladas em objetos de um dos vários tipos genéricos, todos nomeados System.Tuple, que são sobrecarregados no arity ou no número de parâmetros de tipo. Os tipos de tupla aparecem nesse formulário quando você os vê de outra linguagem, como C# ou Visual Basic, ou quando você está usando uma ferramenta que não está ciente dos constructos F#. Os Tuple tipos foram introduzidos no .NET Framework 4. Se você estiver direcionando uma versão anterior do .NET Framework, o compilador usará versões da System.Tuple versão 2.0 da Biblioteca do F# Core. Os tipos nessa biblioteca são usados apenas para aplicativos destinados às versões 2.0, 3.0 e 3.5 do .NET Framework. O encaminhamento de tipo é usado para garantir a compatibilidade binária entre os componentes .NET Framework 2.0 e .NET Framework 4 F#.

Forma compilada de tuplas struct

Tuplas de struct (por exemplo, struct (x, y)), são fundamentalmente diferentes das tuplas de referência. Eles são compilados no ValueTuple tipo, sobrecarregados pelo arity ou pelo número de parâmetros de tipo. Elas são equivalentes a Tuplas C# e Tuplas do Visual Basic e interoperam bidirecionalmente.

Consulte também

• Referência da Linguagem F#
• F# Tipos