Correspondência de padrões F#

F# Pattern Matching permite que você corresponda a estrutura de dados com padrões e execute o código com base na correspondência. Neste artigo, exploraremos a correspondência de padrões do F# em detalhes e aprenderemos como usá-la com eficiência.

Índice-

O que é F# Pattern Matching?

A correspondência de padrão F# é uma construção de linguagem que permite corresponder padrões em estruturas de dados e executar operações com base na correspondência. É um recurso poderoso que torna o código mais conciso e expressivo. O F# tem um sistema sofisticado de correspondência de padrões que fornece uma ampla variedade de recursos de correspondência de padrões.

O recurso de correspondência de padrões do F# é uma das técnicas mais poderosas disponíveis para decompor e extrair informações de estruturas de dados complexas, incluindo listas , registros , uniões discriminadas, bem como seus relacionamentos funcionais, de maneira concisa e expressiva.

Como usar a correspondência de padrões F#?

No F#, a correspondência de padrões é obtida usando a expressão de correspondência. A expressão de correspondência pega um valor e o compara com um ou mais padrões. Se o valor corresponder a um dos padrões, a ação correspondente será executada. Se o valor não corresponder a nenhum dos padrões, uma exceção será lançada.

Portanto, é uma das maneiras mais convenientes e poderosas de testar dados em vários critérios diferentes, o que o torna mais eficiente e flexível. Além disso, também é capaz de realizar alguns cálculos baseados nas condições atendidas.

Sintaxe

A sintaxe para correspondência de padrões em F# é a seguinte:

match expr with
| pat1 - result1
| pat2 -> result2
| pat3 when expr2 -> result3
| _ -> defaultResult

Onde,

  • As condições são definidas pelo | símbolo.
  • Um -> símbolo indica “retorne este valor se a condição for verdadeira…”
  • _ fornece o padrão padrão, que corresponde a tudo como um curinga.

Correspondência de padrão de estação por mês

Aqui está um exemplo de como uma correspondência padrão da estação do tempo por mês pode ser alcançada:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
let printSeason month =
match month with
| "December" | "January" | "February" -> printfn "Winter"
| "March" | "April" -> printfn "Spring"
| "May" | "June" -> printfn "Summer"
| "July" | "August" -> printfn "Rainy"
| "September" | "October" | "November" -> printfn "Autumn"
| _ -> printfn "Season depends on month!"
printSeason "December"
printSeason "March"
printSeason "August"
printSeason "June"
printSeason "October"
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E a saída será como:

Winter
Spring
Rainy
Summer
Autumn

Correspondência no tipo de opção

Abaixo está um exemplo de um tipo de opção usando correspondência de padrões:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let printValue optValue =
match optValue with
| Some value -> printfn "Value: %d" value
| None -> printfn "None"
let value1 = Some 22
let noneValue = None
let value2 = Some 24
printValue value1
printValue noneValue
printValue value2
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Isto é o que imprime como resultado:

Value: 22
None
Value: 24

Fibonacci recursivo usando correspondência de padrões

Este exemplo imprime a série Fibonacci usando o método recursivo de correspondência de padrões:

Example: 

1
2
3
4
5
6
7
8
9
10
11
let rec fibonacci n =
match n with
| 0 -> 0
| 1 -> 1
| _ -> fibonacci (n – 1) + fibonacci (n – 2)
printfn "Fibonacci Series: \n"
for i = 1 to 8 do
printf "%d, " (fibonacci i)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E imprime:

Fibonacci Series:
1, 1, 2, 3, 5, 8, 13, 21,

Funções de correspondência de padrões

Ao usar a palavra-chave function, você pode escrever funções que correspondem a padrões usando a seguinte sintaxe:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
let fruitRate = function
| "pineapple" -> 22.00
| "watermelon" -> 19.50
| "mango" -> 25.00
| "orange" -> 12.22
| "apple" -> 8.15
| _ -> nan
printfn "Pineapple: %g"(fruitRate "pineapple")
printfn "Watermelon: %g"(fruitRate "watermelon")
printfn "Mango: %g"(fruitRate "mango")
printfn "Orange: %g"(fruitRate "orange")
printfn "Apple: %g"(fruitRate "apple")
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E a saída será:

Pineapple: 22
Watermelon: 19.5
Mango: 25
Orange: 12.22
Apple: 8.15

Adicionando filtros ou guardas aos padrões

Ao usar a palavra-chave when, você poderá adicionar filtros ou guardas aos padrões.

Example: 

1
2
3
4
5
6
7
8
9
10
11
let mathSign = function
| 0 -> 0
| a when a < 0 -> -1
| a when a > 0 -> 1
printfn "%d" (mathSign 14)
printfn "%d" (mathSign -14)
printfn "%d" (mathSign 0)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O resultado imprime o seguinte:

1
-1
0

Comparando números usando a palavra-chave when, que é usada como uma condição if:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
let compareNum a =
match a with
| (p, q) when p > q -> printfn "%d is greater than %d" p q
| (p, q) when p < q -> printfn "%d is less than %d" p q
| (p, q) -> printfn "%d equals %d" p q
compareNum (25,21)
compareNum (65, 88)
compareNum (3, 3)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E a saída será a seguinte:

25 is greater than 21
65 is less than 88
3 equals 3

Correspondência de padrão F# com tuplas

O exemplo a seguir mostra como tuplas podem ser usadas para combinar padrões:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
let printUserInfo user =
match user with
| (name, age, city, dob) ->
printfn "Name: %s" name
printfn "Age: %d" age
printfn "City: %s" city
printfn "Date of Birth: %s" dob
let user1 = ("John", 25, "New York", "18/march/2002")
let user2 = ("Ben", 32, "San Antonio","12/august/1998")
printUserInfo user1
printUserInfo user2
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Output of the above example will be
Name: John
Age: 25
City: New York
Date of Birth: 18/march/2002
Name: Ben
Age: 32
City: San Antonio
Date of Birth: 12/august/1998

Correspondência de padrões com listas

A correspondência de padrões em F# também pode ser usada com listas .

Você pode combinar a estrutura de uma lista, incluindo seu comprimento e elementos individuais.

Aqui está um exemplo de correspondência de padrões com uma lista:

Example: 

1
2
3
4
5
6
7
8
9
let listLength list =
match list with
| [] -> 0
| [x] -> 1
| [x; y] -> 2
| _ -> 3
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Neste exemplo, a função listLength pega um parâmetro de lista e o compara com quatro padrões usando a expressão de correspondência. Se a lista estiver vazia, a função retorna 0. Se a lista tiver um elemento, a função retornará 1. Se a lista tiver dois elementos, a função retornará 2. Se a lista tiver mais de dois elementos, a função retornará 3.

Correspondência de padrões com registros

Registros do usuário usando a técnica de correspondência de padrões:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
type user = {
Name: string
Age: int
City: string
Dob: string
}
let printUserInfo user =
match user with
| { Name = name; Age = age; City = city; Dob = dob; } ->
printfn "Name: %s" name
printfn "Age: %d" age
printfn "City: %s" city
printfn "Date of Birth: %s \n" dob
let user1 = { Name = "John"; Age = 25; City = "New York"; Dob = "18/March/2002";}
let user2 = { Name = "Ben"; Age = 32; City = "San Antonio"; Dob = "12/August/1998";}
printUserInfo user1
printUserInfo user2
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Exemplo de Explicação

Como grupo, definimos um tipo de registro chamado user com os campos Name , Age , City e Dob que representam as informações do usuário. Em seguida, criamos uma função chamada printUserInfo que recebe um registro do usuário como entrada.

Quando chamamos a função printUserInfo com user1, usamos correspondência de padrão para desestruturar o registro do usuário em seus campos Nome, Idade, Cidade e Dob usando o padrão de registro { Nome = nome; Idade = idade; Cidade = cidade; Dob = dob; }. Em seguida, imprimimos os valores desses campos usando a função printfn com a formatação apropriada.

A saída do usuário1  seria:

Name: John
Age: 25
City: New York
Date of Birth: 18/March/2002

Da mesma forma, quando chamamos a função printUserInfo com user2, ela imprime os valores dos campos do registro user2 de maneira semelhante.

User2 produziria:

Name: Ben
Age: 32
City: San Antonio
Date of Birth: 12/August/1998

Benefícios da Correspondência de Padrão F#

Aqui estão alguns benefícios de usar a correspondência de padrões F#:

  • A correspondência de padrão F# permite que você escreva um código conciso e expressivo que seja fácil de ler e entender. Você pode combinar valores com padrões, eliminando a necessidade de instruções if-else ou switch longas.
  • O uso de correspondência de padrões em seu código melhora a legibilidade tornando o código mais autodocumentável. Com a correspondência de padrões, o código expressa a intenção do desenvolvedor com mais clareza, facilitando a compreensão.
  • A correspondência de padrão F# pode ajudar a detectar erros em tempo de compilação, reduzindo a probabilidade de erros de tempo de execução. Ao combinar valores com padrões, você pode garantir que o código seja executado apenas quando os valores atenderem a condições específicas.
  • A correspondência de padrões pode ser mais eficiente do que usar instruções if-else ou switch, pois permite que o compilador gere código otimizado. A correspondência de padrões também é menos propensa a erros do que usar outros métodos, pois reduz a chance de introdução de bugs.
  • A correspondência de padrões pode ser usada com uma ampla variedade de tipos de dados, incluindo números inteiros, strings e tipos definidos pelo usuário. Você também pode usar a correspondência de padrões com estruturas de dados complexas, como listas e arrays .

Conclusão

A correspondência de padrões é um recurso poderoso do F# que permite comparar valores com padrões e executar ações com base no resultado. No F#, a correspondência de padrões é obtida usando a expressão de correspondência. Você pode combinar diferentes tipos de valores, incluindo números inteiros, strings, tipos definidos pelo usuário e listas. A correspondência de padrões em F# permite que você escreva um código conciso e expressivo, tornando-o uma ferramenta essencial.

Se você gostou deste artigo e o achou informativo sobre a correspondência de padrões F#, você pode deixar seus comentários reagindo abaixo.

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.