Correspondência padrão

Artigo
05/10/2023

Os padrões são regras para transformar dados de entrada. Eles são usados em toda a linguagem F# para extrair dados de comparação com um padrão, decompor os dados em partes constituintes ou extrair informações de dados de várias maneiras.

Comentários

Os padrões são usados em muitos constructos de linguagem, como a expressão match. Eles são usados quando você está processando argumentos para funções em associações let, expressões lambda e nos manipuladores de exceção associados à expressão try...with. Para obter mais informações, confira Corresponder Expressões, Permitir associações, Expressões lambda: a palavra-chavefun e Exceções: a expressão try...with.

Por exemplo, na expressão match, o padrão é o que segue o símbolo de pipe.

match expression with
| pattern [ when condition ] -> result-expression
...

Cada padrão atua como uma regra para transformar a entrada de alguma forma. Na expressão match, cada padrão é examinado por sua vez para ver se os dados de entrada são compatíveis com o padrão. Se uma correspondência for encontrada, a expressão do resultado será executada. Se uma correspondência não for encontrada, a próxima regra de padrão será testada. O opcional quando a parte da condição é explicada em Expressões de Correspondência.

Os padrões com suporte são mostrados na tabela a seguir. No tempo de execução, a entrada é testada em cada um dos padrões a seguir na ordem listada na tabela e os padrões são aplicados recursivamente, do primeiro ao último, conforme aparecem no código e da esquerda para a direita para os padrões em cada linha.

Nome	Descrição	Exemplo
Padrão de constante	Qualquer literal numérico, de caractere ou de cadeia de caracteres, uma constante de enumeração ou um identificador literal definido	`1.0`, `"test"`, `30`, `Color.Red`
Padrão de identificador	Um valor de caso de uma união discriminada, um rótulo de exceção ou um caso de padrão ativo	`Some(x)` `Failure(msg)`
Padrão variável	identifier	`a`
Padrão `as`	pattern as identifier	`(a, b) as tuple1`
Padrão OR	pattern1 \| pattern2	`([h] \| [h; _])`
Padrão AND	pattern1 e pattern2	`(a, b) & (_, "test")`
Padrão Cons	identifier :: list-identifier	`h :: t`
Padrão de lista	[ pattern_1; ... ; pattern_n ]	`[ a; b; c ]`
Padrão de matriz	[\| pattern_1; ..; pattern_n \|]	`[\| a; b; c \|]`
Padrão entre parênteses	(padrão)	`( a )`
Padrão de tupla	( pattern_1, ... , pattern_n )	`( a, b )`
Padrão de registro	{ identifier1 = pattern_1; ... ; identifier_n = pattern_n }	`{ Name = name; }`
Padrão de curinga	_	`_`
Padrão junto com anotação de tipo	pattern : type	`a : int`
Padrão de teste de tipo	:? type [ as identifier ]	`:? System.DateTime as dt`
Padrão nulo	nulo	`null`
Padrão nameof	nameof expr	`nameof str`

Padrões constantes

Os padrões constantes são literais numéricos, caracteres e cadeias de caracteres, constantes de enumeração (com o nome do tipo de enumeração incluído). Uma expressão match que tem apenas padrões constantes pode ser comparada a uma instrução case em outras linguagens. A entrada é comparada ao valor literal e o padrão corresponde se os valores forem iguais. O tipo do literal deve ser compatível com o tipo de entrada.

O exemplo a seguir demonstra o uso de padrões literais e também usa um padrão de variável e um padrão OR.

[<Literal>]
let Three = 3

let filter123 x =
    match x with
    // The following line contains literal patterns combined with an OR pattern.
    | 1 | 2 | Three -> printfn "Found 1, 2, or 3!"
    // The following line contains a variable pattern.
    | var1 -> printfn "%d" var1

for x in 1..10 do filter123 x

Outro exemplo de um padrão literal é um padrão baseado em constantes de enumeração. Você deve especificar o nome do tipo de enumeração ao usar constantes de enumeração.

type Color =
    | Red = 0
    | Green = 1
    | Blue = 2

let printColorName (color:Color) =
    match color with
    | Color.Red -> printfn "Red"
    | Color.Green -> printfn "Green"
    | Color.Blue -> printfn "Blue"
    | _ -> ()

printColorName Color.Red
printColorName Color.Green
printColorName Color.Blue

Padrões do identificador

Se o padrão for uma cadeia de caracteres que forma um identificador válido, a forma do identificador determinará como é feita a correspondência do padrão. Se o identificador for maior que um caractere e começar com um caractere maiúsculo, o compilador tentará fazer uma correspondência com o padrão do identificador. O identificador desse padrão pode ser um valor marcado com o atributo Literal, um caso de união discriminada, um identificador de exceção ou um caso de padrão ativo. Se nenhum identificador correspondente for encontrado, a correspondência falhará e a próxima regra de padrão, o padrão de variável, será comparada com a entrada.

Padrões de união discriminada podem ser casos nomeados simples ou ter um valor ou uma tupla que contém vários valores. Se houver um valor, você deverá especificar um identificador para ele. No caso de uma tupla, você deve fornecer um padrão de tupla com um identificador para cada elemento da tupla ou um identificador com um nome de campo para um ou mais campos de união nomeados. Confira os exemplos de código nesta seção para exemplos.

O tipo option é uma união discriminada que tem dois casos, Some e None. Um caso (Some) tem um valor, mas o outro (None) é apenas um caso nomeado. Portanto, Some precisa ter uma variável para o valor associado ao caso Some, mas None deve aparecer por si só. No código a seguir, a variável var1 recebe o valor obtido pela correspondência com o caso Some.

let printOption (data : int option) =
    match data with
    | Some var1  -> printfn "%d" var1
    | None -> ()

No exemplo a seguir, a união discriminada PersonName contém uma mistura de cadeias de caracteres e caracteres que representam possíveis formas de nomes. Os casos da união discriminada são FirstOnly, LastOnly e FirstLast.

type PersonName =
    | FirstOnly of string
    | LastOnly of string
    | FirstLast of string * string

let constructQuery personName =
    match personName with
    | FirstOnly(firstName) -> printf "May I call you %s?" firstName
    | LastOnly(lastName) -> printf "Are you Mr. or Ms. %s?" lastName
    | FirstLast(firstName, lastName) -> printf "Are you %s %s?" firstName lastName

Para uniões discriminadas que têm campos nomeados, você usa o sinal de igual (=) para extrair o valor de um campo nomeado. Por exemplo, considere uma união discriminada com uma declaração como a seguinte.

type Shape =
    | Rectangle of height : float * width : float
    | Circle of radius : float

Você pode usar os campos nomeados em uma expressão de padrões correspondentes da maneira a seguir.

let matchShape shape =
    match shape with
    | Rectangle(height = h) -> printfn $"Rectangle with length %f{h}"
    | Circle(r) -> printfn $"Circle with radius %f{r}"

O uso do campo nomeado é opcional; portanto, no exemplo anterior, tanto Circle(r) quanto Circle(radius = r) tem o mesmo efeito.

Ao especificar vários campos, use o ponto e vírgula (;) como separador.

match shape with
| Rectangle(height = h; width = w) -> printfn $"Rectangle with height %f{h} and width %f{w}"
| _ -> ()

Padrões ativos permitem que você defina padrões correspondentes personalizados mais complexos. Para mais informações sobre padrões ativos, confira Padrões Ativos.

O caso em que o identificador é uma exceção é usado em padrões correspondentes no contexto de manipuladores de exceção. Para obter informações sobre padrões correspondentes no tratamento de exceções, confira Exceções: a Expressão try...with.

Padrões de variável

O padrão de variável atribui o valor correspondente a um nome de variável, que está disponível para uso na expressão de execução à direita do símbolo ->. Um padrão de variável sozinho corresponde a qualquer entrada, mas os padrões de variável geralmente aparecem em outros padrões, permitindo que estruturas mais complexas, como tuplas e matrizes, sejam decompostas em variáveis.

O exemplo a seguir demonstra um padrão de variável dentro de um padrão de tupla.

let function1 x =
    match x with
    | (var1, var2) when var1 > var2 -> printfn "%d is greater than %d" var1 var2
    | (var1, var2) when var1 < var2 -> printfn "%d is less than %d" var1 var2
    | (var1, var2) -> printfn "%d equals %d" var1 var2

function1 (1,2)
function1 (2, 1)
function1 (0, 0)

Padrão as

O padrão as é um padrão que tem uma cláusula as acrescentada a ele. A cláusula as associa o valor correspondente a um nome que pode ser usado na expressão de execução de uma expressão match ou, no caso em que esse padrão é usado em uma associação let, o nome é adicionado como uma associação ao escopo local.

O exemplo a seguir usa um padrão as.

let (var1, var2) as tuple1 = (1, 2)
printfn "%d %d %A" var1 var2 tuple1

Padrão OR

O padrão OR é usado quando os dados de entrada podem corresponder a vários padrões e você deseja executar o mesmo código que um resultado. Os tipos de ambos os lados do padrão OR devem ser compatíveis.

O exemplo a seguir demonstra o padrão OR.

let detectZeroOR point =
    match point with
    | (0, 0) | (0, _) | (_, 0) -> printfn "Zero found."
    | _ -> printfn "Both nonzero."
detectZeroOR (0, 0)
detectZeroOR (1, 0)
detectZeroOR (0, 10)
detectZeroOR (10, 15)

Padrão AND

O padrão AND requer que a entrada corresponda a dois padrões. Os tipos de ambos os lados do padrão AND devem ser compatíveis.

O exemplo a seguir é como detectZeroTuple mostrado na seção Padrão de Tupla mais adiante neste tópico, mas aqui tanto var1 quanto var2 é obtido como valores usando o padrão AND.

let detectZeroAND point =
    match point with
    | (0, 0) -> printfn "Both values zero."
    | (var1, var2) & (0, _) -> printfn "First value is 0 in (%d, %d)" var1 var2
    | (var1, var2)  & (_, 0) -> printfn "Second value is 0 in (%d, %d)" var1 var2
    | _ -> printfn "Both nonzero."
detectZeroAND (0, 0)
detectZeroAND (1, 0)
detectZeroAND (0, 10)
detectZeroAND (10, 15)

Padrão cons

O padrão cons é usado para decompor uma lista no primeiro elemento, a cabeça, e em uma lista que contém os elementos restantes, a cauda.

let list1 = [ 1; 2; 3; 4 ]

// This example uses a cons pattern and a list pattern.
let rec printList l =
    match l with
    | head :: tail -> printf "%d " head; printList tail
    | [] -> printfn ""

printList list1

Padrão de lista

O padrão de lista permite que as listas sejam decompostas em vários elementos. O padrão de lista em si pode corresponder apenas a listas de um número específico de elementos.

// This example uses a list pattern.
let listLength list =
    match list with
    | [] -> 0
    | [ _ ] -> 1
    | [ _; _ ] -> 2
    | [ _; _; _ ] -> 3
    | _ -> List.length list

printfn "%d" (listLength [ 1 ])
printfn "%d" (listLength [ 1; 1 ])
printfn "%d" (listLength [ 1; 1; 1; ])
printfn "%d" (listLength [ ] )

Padrão de matriz

O padrão de matriz se assemelha ao padrão de lista e pode ser usado para decompor matrizes de um comprimento específico.

// This example uses array patterns.
let vectorLength vec =
    match vec with
    | [| var1 |] -> var1
    | [| var1; var2 |] -> sqrt (var1*var1 + var2*var2)
    | [| var1; var2; var3 |] -> sqrt (var1*var1 + var2*var2 + var3*var3)
    | _ -> failwith (sprintf "vectorLength called with an unsupported array size of %d." (vec.Length))

printfn "%f" (vectorLength [| 1. |])
printfn "%f" (vectorLength [| 1.; 1. |])
printfn "%f" (vectorLength [| 1.; 1.; 1.; |])
printfn "%f" (vectorLength [| |] )

Padrão entre parênteses

Parênteses podem ser agrupados em torno de padrões para alcançar a associatividade desejada. No exemplo a seguir, parênteses são usados para controlar a associatividade entre um padrão AND e um padrão cons.

let countValues list value =
    let rec checkList list acc =
       match list with
       | (elem1 & head) :: tail when elem1 = value -> checkList tail (acc + 1)
       | head :: tail -> checkList tail acc
       | [] -> acc
    checkList list 0

let result = countValues [ for x in -10..10 -> x*x - 4 ] 0
printfn "%d" result

Padrão de tupla

O padrão de tupla corresponde à entrada na forma de tupla e permite que a tupla seja decomposta em seus elementos constituintes usando variáveis de padrões correspondentes para cada posição na tupla.

O exemplo a seguir demonstra o padrão de tupla e também usa padrões literais, padrões variáveis e o padrão curinga.

let detectZeroTuple point =
    match point with
    | (0, 0) -> printfn "Both values zero."
    | (0, var2) -> printfn "First value is 0 in (0, %d)" var2
    | (var1, 0) -> printfn "Second value is 0 in (%d, 0)" var1
    | _ -> printfn "Both nonzero."
detectZeroTuple (0, 0)
detectZeroTuple (1, 0)
detectZeroTuple (0, 10)
detectZeroTuple (10, 15)

Padrão de registro

O padrão de registro é usado para decompor registros para extrair os valores dos campos. O padrão não precisa fazer referência a todos os campos do registro; os campos omitidos simplesmente não participam da correspondência e não são extraídos.

// This example uses a record pattern.

type MyRecord = { Name: string; ID: int }

let IsMatchByName record1 (name: string) =
    match record1 with
    | { MyRecord.Name = nameFound; MyRecord.ID = _; } when nameFound = name -> true
    | _ -> false

let recordX = { Name = "Parker"; ID = 10 }
let isMatched1 = IsMatchByName recordX "Parker"
let isMatched2 = IsMatchByName recordX "Hartono"

Padrão de curinga

O padrão curinga é representado pelo caractere sublinhado (_) e corresponde a qualquer entrada, assim como o padrão de variável, exceto que a entrada é descartada, em vez de ser atribuída a uma variável. O padrão curinga geralmente é usado em outros padrões como um espaço reservado para valores que não são necessários na expressão à direita do símbolo ->. O padrão curinga também é usado frequentemente no final de uma lista de padrões para corresponder a qualquer entrada sem correspondência. O padrão curinga é demonstrado em muitos exemplos de código neste tópico. Confira o código anterior para obter um exemplo.

Padrões que têm anotações de tipo

Os padrões podem ter anotações de tipo. Eles se comportam como outras anotações de tipo e guiam a inferência como outras anotações de tipo. Parênteses são necessários em torno de anotações de tipo em padrões. O código a seguir mostra um padrão que tem uma anotação de tipo.

let detect1 x =
    match x with
    | 1 -> printfn "Found a 1!"
    | (var1 : int) -> printfn "%d" var1
detect1 0
detect1 1

Padrão de teste de tipo

O padrão de teste de tipo é usado para fazer a correspondência da entrada com um tipo. Se o tipo de entrada for uma correspondência com o (ou um tipo derivado de) tipo especificado no padrão, a correspondência terá êxito.

O exemplo a seguir demonstra o padrão de teste de tipo.

open System.Windows.Forms

let RegisterControl(control:Control) =
    match control with
    | :? Button as button -> button.Text <- "Registered."
    | :? CheckBox as checkbox -> checkbox.Text <- "Registered."
    | _ -> ()

Se você estiver verificando apenas se um identificador é de um tipo derivado específico, não precisará da parte as identifier do padrão, conforme mostrado no seguinte exemplo:

type A() = class end
type B() = inherit A()
type C() = inherit A()

let m (a: A) =
    match a with
    | :? B -> printfn "It's a B"
    | :? C -> printfn "It's a C"
    | _ -> ()

Padrão nulo

O padrão nulo corresponde ao valor nulo que pode aparecer quando você está trabalhando com tipos que permitem um valor nulo. Padrões nulos são usados frequentemente ao interoperar com código do .NET Framework. Por exemplo, o valor retornado de uma API .NET pode ser a entrada para uma expressão match. Você pode controlar o fluxo do programa com base em se o valor retornado é nulo e também em outras características do valor retornado. Você pode usar o padrão nulo para impedir que valores nulos sejam propagados para o restante do programa.

O exemplo a seguir usa o padrão nulo e o padrão de variável.

let ReadFromFile (reader : System.IO.StreamReader) =
    match reader.ReadLine() with
    | null -> printfn "\n"; false
    | line -> printfn "%s" line; true

let fs = System.IO.File.Open("..\..\Program.fs", System.IO.FileMode.Open)
let sr = new System.IO.StreamReader(fs)
while ReadFromFile(sr) = true do ()
sr.Close()

Padrão nameof

O padrão nameof corresponde a uma cadeia de caracteres quando seu valor é igual à expressão que segue a palavra-chave nameof. Por exemplo:

let f (str: string) =
    match str with
    | nameof str -> "It's 'str'!"
    | _ -> "It is not 'str'!"

f "str" // matches
f "asdf" // does not match

Confira o operador nameof para obter informações sobre do que você pode obter um nome.

Compartilhar via