Compreendendo tuplas F#

Aqui, neste artigo, exploraremos os fundamentos das tuplas F# e mostraremos como criar, acessar e combinar padrões nelas.

Além disso, discutiremos alguns dos casos de uso comuns para tuplas F# , como expressar estruturas de dados complexas e retornar vários valores de uma função .

Índice-

Compreendendo as tuplas do F#:

F# Tuplas

Em F#, uma tupla é uma sequência ordenada de elementos de diferentes tipos. As tuplas são imutáveis, o que significa que seus valores não podem ser alterados depois de criados.

Tuplas F# são uma maneira conveniente de agrupar vários valores, especialmente quando esses valores têm uma relação natural entre si.

Por exemplo, uma tupla pode representar o nome e a idade de uma pessoa ou um ponto em um plano bidimensional.

(Michael”, “Clarke”, 41) é um exemplo de uma tupla de 3 consistindo de dois nomes de string e um nome inteiro. Como você pode ver, ele tem o tipo (string string int).

Tupla pode ser duas ou mais do mesmo tipo ou diferentes

Abaixo estão alguns exemplos para lhe dar uma ideia melhor do que são as tuplas F#:

// Tuple of three integers.
( 1, 2, 5 )

// Pair of strings.
( "John", "Alexander" )

// Tuple of unknown types.
( x, y )

// Tuple that has mixed types.
( "Micheal", 16.0, 5)

// Tuple of integer expressions.
( x / 2, y * 3)

Exemplo de Tupla F#

Este é o exemplo básico de criação de uma tupla para o usuário e impressão de seus dados:

Example:

1
2
3
4
5
6
7
8
9
10
11
let user (x, y , z) = 
 printfn "Name: %s, \nAge: %d,\nIs Employed: %b" x y z
let usr = user("Ben", 22, true)
The output will be:
Name: Ben, 
Age: 22,
Is Employed: true
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída será:

Name: Ben,
Age: 22,
Is Employed: true

Média de três números

No exemplo abaixo, você encontrará uma função média que recebe uma tupla de três valores como entrada:

Example:

1
2
3
4
5
6
7
8
9
let calAverage (m, r, x) =
 let sum = m + r + x
 sum / 3.0
let avg:float = calAverage (7.1, 2.8, 3.4)
printfn "Average of three numbers are: %f" avg
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída do exemplo acima é a seguinte:

Average of three numbers are: 4.433333

Acessando membros individuais da tupla

Usando a correspondência de padrões, cada membro da tupla pode ser avaliado separadamente e depois impresso usando o padrão apropriado.

Abaixo está um exemplo que ilustra o conceito sobre o acesso de membros individuais da tupla:

Example:

1
2
3
4
5
6
7
8
let display tuple =
 match tuple with
   | (m, r, x) -> printfn "User Info: \n%A – %A – %A" m r x
display ("Micheal Clarke", "Australia", 41 )
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Isso é o que obteremos como saída:

User Info:
Micheal Clarke - Australia - 41

Os dois primeiros itens de uma tupla dupla são retornados pelas funções internas fst e snd que estão disponíveis para o programador.

Usando o exemplo a seguir, podemos ilustrar o conceito com mais detalhes.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let tuple1 = ("Sunflower", "Rose")
printfn "First member: %A" (fst tuple1)
printfn "Second member: %A" (snd tuple1)
let tuple2 = ("Monica", "Ross")
printfn "\nFirst member: %A" (fst tuple2)
printfn "Second member: %A" (snd tuple2)
let tuple3 = ("Arsenal", "Liverpool")
printfn "\nFirst Name: %A" (fst tuple3)
printfn "Second Name: %A" (snd tuple3)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Usando fst e snd, imprimimos o primeiro e o segundo membros de três tuplas F# da seguinte forma:

First member: Sunflower
Second member: Rose

First member: Monica
Second member: Ross

First Name: Arsenal
Second Name: Liverpool

Acesso individual usando a palavra-chave let para especificar cada valor de tupla em uma variável diferente:

Example:

1
2
3
4
5
6
7
8
9
10
11
let cricketer = ("Micheal", "Clarke", 41, "Australian Cricketer")
let firstname, lastname, age, country = cricketer
printfn "Firstname is: %s" firstname
printfn "Lastname is: %s" lastname
printfn "Age is: %d" age
printfn "%s" country
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída do código acima é:

Firstname is: Micheal
Lastname is: Clarke
Age is: 41
Australian Cricketer

Exemplo de Explicação

Este código é escrito em linguagem F# e demonstra a desestruturação de tupla.

Uma tupla é uma estrutura de dados que contém um número fixo de elementos, cada um dos quais pode ter um tipo diferente. Nesse código, uma tupla chamada “ cricketer ” é definida com quatro elementos: “ Micheal ” como o primeiro nome, “ Clarke ” como o sobrenome, 41 como a idade e “ Australian Cricketer ” como o país.

A próxima linha de código usa a desestruturação de tupla para extrair valores individuais da tupla e atribuí-los a variáveis separadas . As variáveis são declaradas usando uma lista separada por vírgulas e seus valores são obtidos da tupla.

Finalmente, os valores das variáveis individuais são impressos no console usando a função printfn. A primeira e a segunda instruções printfn imprimem o nome e o sobrenome do jogador de críquete, respectivamente. A terceira declaração printfn imprime a idade do jogador de críquete, e a quarta declaração printfn imprime o país do jogador de críquete.

Se você gostou deste artigo e o achou informativo sobre a linguagem de programação funcional F#, você pode deixar seu feedback reagindo abaixo.

Nós valorizamos o seu feedback.

Compreendendo tuplas F#

F# Tuplas

Exemplo de Tupla F#

Example:

Média de três números

Example:

Acessando membros individuais da tupla

Example:

Example:

Example:

Exemplo de Explicação

Sentindo entediado?