Listas F#
As listas F# podem ser definidas como coleções de valores ordenados que têm o mesmo tipo e são da mesma ordem.
A lista F# é um objeto imutável, o que significa que não pode ser modificado depois de criado.
As operações em listas, por outro lado, retornam uma nova lista que contém as alterações solicitadas.
Existem muitas funções disponíveis para criar, manipular e consultar listas em F#, o que as torna poderosas e flexíveis.
Uma sequência de dados, como uma lista de nomes, números ou outros valores, pode ser representada por eles.
Existe um módulo F# chamado Microsoft.FSharp.Collections.List que possui todas as operações comuns em listas. No entanto, o F# importa automaticamente esse módulo para cada aplicativo F# e o torna acessível a todos os aplicativos escritos com F#.
No final do artigo, você aprenderá como criar e manipular listas de itens em F#, incluindo como inserir e remover itens, filtrar e classificar listas e executar operações em mais de uma lista por vez.
- F# Listas:
- Métodos de criação de listas F#:
- Literais da lista:
- O Operador Contras ():
- Método de inicialização da lista:
- Compreensões de lista:
- Tipo de dados da lista F#:
- F# lista os operadores básicos:
- Inversão de listas F#:
- F# List.average:
- Filtro de lista F#:
- Mapa de lista F#:
- F# Classificação da lista:
- Anexar lista F#:
- F# Lista.Soma:
- F# List.Fold:
Métodos de criação de listas F#
Aqui estão algumas das maneiras pelas quais você pode criar uma lista:
| Métodos | Visão geral |
| Literais | Usando literais de lista, podemos criar uma lista. |
| (::) | Usando o operador cons ( :: ), você pode conseguir isso. |
| List.init | O módulo List tem um método List.init que pode ser usado para iniciar uma lista. |
| construção sintática | Utilizando uma construção sintática chamada List Comprehension. |
Listar literais
O literal de lista expressa uma nova lista que conterá os valores especificados na expressão do literal de lista.
Os literais de lista em F# são exibidos da seguinte maneira:
let list1 = [1; 2; 3; 4] let list2= ["apple"; "banana"; "cherry"]
O Operador Contras (::)
Uma nova lista pode ser criada anexando um elemento a uma lista existente usando o operador cons :: em F#.
É a forma abreviada da palavra “ construir ” e é pronunciada como “ contras ”.
:: aceita dois operandos: um elemento e uma lista.
Um elemento é retornado como parte de uma nova lista, que consiste no elemento e nos elementos da lista original a seguir.
Aqui está um exemplo.
let list1 = 1 :: [2; 3; 4] let list2 = 1::2::3::4::5::6::7::8::9::10::[];;
O caractere [] denota que a lista está vazia.
Método de inicialização da lista
Usar o método List.init em F# é uma maneira de criar uma nova lista aplicando uma determinada função aos inteiros em um determinado intervalo de valores.
Aqui está a aparência da sintaxe de List.init:
val init : int -> (int -> 'T) -> 'T list
Em primeiro lugar, há um argumento especificando o número de itens a serem gerados na nova lista e, em segundo lugar, há um argumento especificando a função inicializadora usada para criar os itens da lista.
let stringList = List.init 5 (fun i -> "Item " + string i)
Aqui, a função String i é usada aqui para gerar uma lista de strings.
Compreensões de lista
A compreensão de lista AF# é um método conciso para criar listas adicionais de dados de uma sequência ou lista existente. O conceito de compreensão de lista é baseado na notação matemática de compreensão de conjunto e pode ser usado para mapear, combinar e filtrar elementos.
Por exemplo,
let list1 = [1 .. 10]
Existe uma construção em geradores que é: [for x in a collection do … yield expr],
Por exemplo,
let evenNumbers = [ for i in 1..10 do if i % 2 = 0 then yield i ]
Da mesma forma que a palavra-chave yield coloca algum valor individual em uma lista, yield! É usado para enviar uma coleção de valores para a lista.
Abaixo está uma função de exemplo demonstrando como os métodos acima podem ser usados:
Example:
A saída do exemplo acima é a seguinte:
The list: [1; 2; 3; 4; 5; 6; 7; 8] The list: [1; 2; 3; 4; 5; 6] The list: [1; 2; 3; 4; 5; 6; 7; 8] The list: [a; b; c; d; e; f; g; h] The list: [0,0,0; 1,1,1; 2,4,8; 3,9,27; 4,16,64] The list: [1; 4; 9; 16; 25; 36; 49; 64] The list: [15; 30; 45; 60; 75; 90] The list: [1; 2; 3; 2; 3; 4]
Tipo de dados da lista F#
Abaixo está uma tabela que mostra uma variedade de propriedades associadas aos tipos de dados de lista:
| Propriedade | Tipo | Visão geral |
| Cabeça | T | Este é o primeiro elemento da lista. |
| Vazio | lista T | Uma lista vazia do tipo apropriado pode ser retornada por esta propriedade estática como resultado da solicitação. |
| Está vazia | bool | É verdadeiro se não houver elementos na lista. |
| Item | T | Este elemento está no índice especificado (baseado em zero). |
| Comprimento | int | Contagem de elementos. |
| Cauda | lista T | Uma lista que não contém o primeiro elemento. |
Aqui está um exemplo de como essas propriedades podem ser usadas:
Example:
Os resultados de todas as propriedades acima são impressos da seguinte forma:
li.IsEmpty is false li.Length is 8 li.Head is 1 li.Tail.Head is 3 li.Tail.Tail.Head is 5 li.Item(1) is 3
F# lista operadores básicos
Existem várias operações básicas que você pode executar em um tipo de dados de lista, conforme ilustrado na tabela a seguir:
| Valor | Visão geral |
| anexar: 'T list → 'T list → 'T list | A função retorna uma nova lista contendo os elementos da primeira lista seguidos pelos elementos da segunda lista no final. |
| média: 'T list → 'T list → 'T list | O elemento médio na lista de elementos é retornado como resultado dessa função. |
| mediaBy : ('T → ^U) → 'T lista → ^U | Aplicando a função a cada elemento da lista e tirando a média de ambos os elementos, retornará a média dos elementos gerados. |
| escolha : (opção 'T → 'U) → 'Lista T → 'Lista U | A função fornecida será aplicada a todos os elementos da lista, um por um. Esta função retornará uma lista do resultado de cada elemento para cada elemento onde a função retorna Some como resultado. |
| Coletar : ('T → 'Lista U) → 'T lista → 'U lista | Esta função será aplicada a cada elemento da lista, um de cada vez. Retorna a lista combinada de todos os resultados após concatenar todos eles. |
| concat : seq<'T lista> → 'T lista | Uma nova lista será retornada contendo os elementos de todas as listas, ordenadas alfabeticamente. |
| vazio : 'lista T | A função retorna uma lista vazia com o tipo fornecido como seu valor. |
| existe : ('T → bool) → 'Lista T → bool | A função verifica se algum elemento da lista atende ao predicado fornecido, verificando se ele está presente. |
| existe2 : ('T1 → 'T2 → bool) → 'Lista T1 → 'Lista T2 → bool | Nesta função, é testado para ver se um par de elementos correspondentes nas listas é satisfeito pelo predicado fornecido. |
| filtro: ('T → bool) → 'T lista → 'T lista | Nessa função, é retornada uma nova coleção que contém apenas os elementos da coleção original para os quais o predicado fornecido corresponde a true . |
| find : ('T → bool) → 'T lista → 'T | Ele retorna o elemento que é o primeiro elemento a retornar verdadeiro quando a função fornecida é usada. |
| findIndex : ('T → bool) → 'T lista → int | Um predicado que é satisfeito pelo primeiro elemento na lista é retornado. |
| fold : ('Estado → 'T → 'Estado) → 'Estado → 'Lista T → 'Estado | Essa função encadeia um argumento de acumulador por meio de cada elemento da coleção. Aplica a função ao segundo argumento e ao primeiro elemento da lista. Este resultado será então passado pelo programa junto com o segundo elemento, e o processo continuará desta forma. Em seguida, retorna o resultado final. Uma função f é dada, e os elementos são i0…iN, então esta função calcula f (… (fs i0) i1 …) iN. |
| fold2 : ('Estado → 'T1 → 'T2 → 'Estado) → 'Estado → 'Lista T1 → 'Lista T2 → 'Estado | Essa função aplica uma função aos elementos de duas coleções que correspondem entre si e também encadeia um argumento de acumulador por meio da computação. Deve haver coleções idênticas. Usando i0…iN e j0…jN como funções de entrada, esta função calcula f (… (fs i0 j0)…) iN jN. |
| foldBack : ('T → 'Estado → 'Estado) → 'T lista → 'Estado → 'Estado | Essa função aplica uma função a cada elemento da coleção, por meio da qual um argumento do acumulador é passado para a computação de cada elemento. Uma função f é passada como uma entrada, e os elementos de entrada i0…iN são passados como entrada que calcula f i0 (…(f iN s)). |
| foldBack2 : ('T1 → 'T2 → 'Estado → 'Estado) → 'Lista T1 → 'Lista T2 → 'Estado → 'Estado | Nesta função, um elemento de duas coleções é encadeado através da computação e uma referência de função é passada como um argumento. As coleções devem ser idênticas. Uma função f é passada para esta função e se os elementos em cada caso forem i0…iN e j0…jN, então esta função calculará o valor de f i0 j0 (…(f iN jN s )). |
| forall : ('T → bool) → 'Lista T → bool | Esta função verifica se todos os elementos satisfazem o predicado fornecido na coleção. |
| forall : ('T → bool) → 'Lista T → bool | Identifica se todos os elementos correspondentes ao predicado fornecido são satisfeitos aos pares na coleção. |
| head : 'Lista T → 'T | É usado para retornar o primeiro elemento de uma lista. |
| init : int → (int → 'T) → 'T lista | A função cria uma lista usando o gerador fornecido como um índice em cada item da lista. |
| isEmpty : 'Lista T → bool | Este método retorna true se a lista não contiver nenhum elemento e false se contiver. |
| iter : ('T → unidade) → 'T lista → unidade | Cada elemento da coleção será aplicado com a função dada. |
| iter2 : ('T1 → 'T2 → unidade) → 'Lista T1 → 'Lista T2 → unidade | A função fornecida é aplicada simultaneamente a duas coleções. Deve haver um tamanho idêntico entre as duas coleções. |
| iteri : (int → 'T → unidade) → 'T lista → unidade | Cada elemento da coleção é aplicado à função especificada. Inteiros passados para a função indicam índices de elementos. |
| iteri2 : (int → 'T1 → 'T2 → unidade) → 'lista T1 → 'lista T2 → unidade | A função fornecida será aplicada simultaneamente a duas coleções. Deve haver um tamanho igual entre as duas coleções. Este inteiro indica o índice do elemento que foi passado para a função. |
| comprimento: 'Lista T → int | O comprimento da lista é retornado por esta função. |
| map : ('T → 'U) → 'T lista → 'U lista | Nesse método, os elementos de uma coleção são os resultados da aplicação de uma determinada função a cada elemento de uma coleção e o resultado é retornado como os elementos de uma nova coleção. |
| map2 : ('T1 → 'T2 → 'U) → 'Lista T1 → 'Lista T2 → 'Lista U | Nesse método, uma nova coleção é criada cujos elementos correspondem aos respectivos elementos dos dois conjuntos de coleções se a função fornecida for aplicada aos pares aos elementos correspondentes dos dois conjuntos. |
| map3 : ('T1 → 'T2 → 'T3 → 'U) → 'Lista T1 → 'Lista T2 → 'Lista T3 → 'Lista U | Nesta função, as três coleções são aplicadas simultaneamente aos seus elementos correspondentes para produzir uma nova coleção. |
| mapi : (int → 'T → 'U) → 'T lista → 'U lista | Aplicar uma determinada função a cada elemento da coleção cria uma nova coleção cujos elementos são os resultados do aplicativo. Este índice inteiro representa o índice do elemento (de 0) quando passado para a função. |
| mapi2 : (int → 'T1 → 'T2 → 'U) → 'Lista T1 → 'Lista T2 → 'Lista U | Isso é semelhante a List.mapi, mas mapeia os elementos de duas listas com o mesmo comprimento entre si. |
| max : 'T lista → 'T | Ao usar Operators.max, essa função retorna o maior valor entre todos os elementos da lista. |
| maxBy : ('T → 'U) → 'T lista → 'T | A função retorna o maior elemento da lista entre todos os elementos da lista, comparando o resultado da função com seu método Operators.max. |
| min : 'Lista T → 'T | Essa função retorna o elemento mais baixo em uma lista, comparado usando Operators.min como método de comparação. |
| minBy : ('T → 'U) → 'T lista → 'T | Usando Operators.min no resultado da função, esta função retorna o menor elemento dentro de todos os elementos da lista |
| nth : 'T lista → int → 'T | O índice de cada item na lista. 0 é o índice do primeiro elemento da lista. |
| ofArray : 'T [] → 'T lista | A partir de uma matriz de itens, uma lista pode ser criada. |
| ofSeq : seq<'T> → 'T lista | Fornece uma nova lista com base no objeto enumerável fornecido a ela. |
| partição : ('T → bool) → 'Lista T * 'Lista T | Esse método divide uma coleção em duas coleções contendo elementos que retornam verdadeiro ou falso com base no predicado fornecido. |
| permutar : (int → int) → 'Lista T → 'Lista T | Especifica um método de permutação que retorna uma lista com todos os elementos permutados. |
| pick : ('T → 'U opção) → 'T lista → 'U | Retorna o primeiro resultado quando a função fornecida retorna Some para algum valor quando aplicada a elementos sucessivos. |
| reduzir : ('T → 'T → 'T) → 'T lista → 'T | Essa função é aplicada a cada elemento da coleção e um argumento acumulador é passado para a função quando o cálculo é executado. Os dois primeiros elementos da lista estão sujeitos à função especificada. O resultado é então passado para a função com o terceiro elemento e assim por diante. Por fim, ele retorna o resultado final. Suponha que a função de entrada seja f e os elementos de entrada sejam i0…iN, então a função calculará f (… (f i0 i1) i2 …) iN para a função de entrada especificada. |
| reduzBack : ('T → 'T → 'T) → 'T lista → 'T | A função é aplicada a cada elemento da coleção e, em seguida, um argumento do acumulador é passado pela computação para controlar a operação. Uma função f é inserida e os elementos serão i0…iN, então a função calculará f i0 (…(f iN-1 iN)). |
| replicar: (int → 'T → lista 'T) | A função cria uma lista usando o gerador fornecido como um índice em cada item da lista. |
| rev : 'Lista T → 'Lista T | Existe uma função que retorna uma nova lista que possui os elementos na ordem inversa. |
| scan : ('State → 'T → 'State) → 'State → 'T list → 'State list | Uma função é aplicada a cada elemento da coleção, encadeando a computação por meio do argumento do acumulador associado a cada elemento. Com esta função, podemos pegar o segundo argumento e aplicar a função especificada a ele junto com o primeiro elemento da lista. A seguir, o resultado do cálculo é passado para a função junto com o segundo elemento e assim por diante. No final, ele retorna os resultados intermediários e finais. |
| scanBack : ('T → 'Estado → 'Estado) → 'T lista → 'Estado → 'Lista de Estados | O resultado são resultados intermediários e finais, assim como foldBack. |
| sort : 'Lista T → 'Lista T | Ao usar Operators.compare, essa função classifica a lista fornecida a ela. |
| sortBy : ('T → 'Chave) → 'T lista → 'T lista | A lista fornecida é classificada usando as chaves fornecidas pela projeção fornecida na entrada. Usando o método Operators.compare, as chaves são comparadas entre si. |
| sortWith : ('T → 'T → int) → 'T lista → 'T lista | Esta função usa a função de comparação fornecida na lista fornecida para classificar a lista fornecida. |
| soma: ^T lista → ^T | Calcula a soma dos elementos em uma lista. |
| sumBy : ('T → ^U) → 'T lista → ^U | O resultado de cada elemento da lista é retornado como uma soma quando a função é aplicada. |
| tail : 'Lista T → 'Lista T | Uma lista de elementos de entrada sem o primeiro elemento é retornada. |
| toArray : 'T lista → 'T [] | A função cria uma matriz a partir de uma lista fornecida a ela. |
| toSeq : 'Lista T → seq<'T> | Fornece uma exibição de sequência da lista fornecida. |
| tryFind : ('T → bool) → 'T lista → 'T opção | Fornece uma lista de elementos para os quais uma função retorna verdadeiro com base nos parâmetros fornecidos. Se não houver tal elemento, o valor de retorno será None . |
| tryFindIndex : ('T → bool) → 'T lista → opção int | Haverá um índice retornado que representa a posição na lista do primeiro elemento que atende ao predicado fornecido. Se não houver tal elemento, retorne None . |
| tryPick : ('T → 'U opção) → 'T lista → 'U opção | À medida que aplicamos elementos sucessivos à função dada, ela retorna um primeiro resultado quando a função retorna Some para um determinado valor. O valor de retorno deve ser None se tal elemento não existir. |
| descompacte: ('T1 * 'T2) lista → 'Lista T1 * 'Lista T2 | Esta função é usada para dividir uma lista de pares em duas listas. |
| unzip3 : ('T1 * 'T2 * 'T3) lista → 'Lista T1 * 'Lista T2 * 'Lista T3 | A função divide uma lista de triplos em três listas separadas. |
| zip : 'Lista T1 → 'Lista T2 → ('T1 * 'T2) lista | Esta função é usada para combinar as duas listas em uma lista de pares. Deve haver um comprimento igual entre as duas listas. |
| zip3 : 'Lista T1 → 'Lista T2 → 'Lista T3 → ('T1 * 'T2 * 'T3) lista | Uma lista de triplos é formada combinando as três listas. Deve haver um comprimento igual entre as listas. |
Inversão de listas F#
Aqui está um programa que mostra como inverter uma lista recursivamente:
Example:
E a saída será:
Se você precisar fazer a mesma coisa, você pode usar a função List.rev do módulo da seguinte forma:
Example:
Saída:
F# List.average
Abaixo está um exemplo de cálculo da média de todos os elementos na lista usando List.average :
Example:
E o resultado é:
Filtro de Lista F#
No programa a seguir, você poderá ver como filtrar uma lista usando o método List.filter .
Example:
Os resultados da filtragem da lista são os seguintes:
Mapa de Lista F#
O método List.map é usado para mapear uma lista entre dois tipos:
Example:
Mapeando a lista em diferentes tipos de saída da seguinte forma:
Classificação da lista F#
As listas podem ser classificadas usando o método List.sort .
Example:
Como resultado da classificação da lista, aqui está a aparência da saída:
Anexar Lista F#
List.append é um método que combina duas listas e as anexa uma à outra:
Example:
A saída será a seguinte:
The first list: [2; 4; 58; 85; 12] The second list: [6; 5; 4; 3; 2] The appened list: [2; 4; 58; 85; 12; 6; 5; 4; 3; 2]
F# List.Sum
List.sum é um método que retorna a soma dos elementos em uma lista
Example:
A soma de todos os elementos é:
The sum: 161
F# List.Fold
No método List.fold , uma função é aplicada da esquerda para a direita para cada elemento da List:
Example:
A saída será a seguinte:
Exemplo de Explicação
Este código F# define uma lista de números inteiros com os valores [2; 1; 5; 6; 8] . Em seguida, ele usa a função List.fold para calcular a soma dos elementos na lista, que é armazenada na variável sum. O valor inicial do acumulador acc é definido como 2 .
A função List.fold aceita três argumentos: uma função que especifica como combinar o acumulador com cada elemento da lista, um valor inicial para o acumulador e a própria lista.
Nesse caso, a função lambda passada como o primeiro argumento para List.fold recebe dois argumentos: acc e x. Ele retorna a soma de acc e x, que é usado como o novo valor do acumulador. O valor inicial do acumulador é 2.
A função List.fold aplica a função lambda a cada elemento da lista e atualiza o acumulador de acordo. Ele começa com um valor acumulador inicial de 2 e, em seguida, adiciona 2 a cada elemento da lista, resultando em um valor acumulador final de 2 + 2 + 1 + 5 + 6 + 8 , que é 24 .
Finalmente, o código usa a função printfn para imprimir os resultados. Este programa produziria:
The sum of the numbers is: 24
Se você gostou deste artigo e o achou informativo sobre a linguagem de programação funcional F#, você pode deixar seu feedback reagindo abaixo.
