Módulo de Collections.SEQ (F#)
Operações básicas de seqüências de enumerable.
Caminho do namespace/módulo: Microsoft.FSharp.Collections
Assembly: FSharp.Core (em FSharp.Core.dll)
module Seq
Comentários
Para uma visão geral de seqüências em F#, consulte Seqüências (F#).
Valores
Valor |
Descrição |
|---|---|
acrescentar : seq<'T> -> seq<'T> -> seq<'T> |
Quebra as duas enumerações determinadas como uma enumeração concatenada única. |
Média : seq<^T> -> ^T |
Retorna a média dos elementos na seqüência. |
averageBy : ('T -> ^U) -> seq<'T> -> ^U |
Retorna a média dos resultados gerados pela aplicação da função para cada elemento da seqüência. |
cache : seq<'T> -> seq<'T> |
Retorna uma seqüência que corresponde a uma versão em cache da seqüência de entrada. |
elenco : IEnumerable -> seq<'T> |
Encapsula uma fracamente tipados System.Collections seqüência como uma seqüência digitada. |
Escolha : ('T -> 'U option) -> seq<'T> -> seq<'U> |
Aplica a função de determinado para cada elemento da lista. Retornar a lista composta dos resultados para cada elemento onde a função retornará Some. |
coletar : ('T -> 'Collection) -> seq<'T> -> seq<'U> |
Aplica a função de determinado para cada elemento da seqüência e concatena todos os resultados. |
compareWith : ('T -> 'T -> int) -> seq<'T> -> seq<'T> -> int |
Compara duas seqüências usando a função de comparação de determinado, elemento por elemento. |
concat : seq<'Collection> -> seq<'T> |
Combina determinadas enumeração-de-enumerações como uma enumeração concatenada única. |
countBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * int> |
Aplica-se a uma função de geração de chave a cada elemento de uma seqüência e retornar uma seqüência Gerando chaves exclusivas e seu número de ocorrências na seqüência original. |
atraso : (unit -> seq<'T>) -> seq<'T> |
Retorna uma seqüência que é criada da especificação atrasada determinada de uma seqüência. |
distintas : seq<'T> -> seq<'T> |
Retorna uma seqüência que contém entradas não duplicadas, de acordo com comparações de igualdade e hash genéricas nas entradas. Se um elemento ocorre várias vezes na seqüência de ocorrências posteriores serão descartadas. |
distinctBy : ('T -> 'Key) -> seq<'T> -> seq<'T> |
Retorna uma seqüência que contém entradas não duplicadas, de acordo com as comparações de hash e de igualdade genéricas nas chaves retornadas pela função de geração de chave fornecida. Se um elemento ocorre várias vezes na seqüência de ocorrências posteriores serão descartadas. |
vazio : seq<'T> |
Cria uma seqüência vazia. |
existe : ('T -> bool) -> seq<'T> -> bool |
Se o predicado determinado satisfaz a qualquer elemento da seqüência de testes. |
exists2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool |
Se qualquer par de elementos correspondentes das seqüências de entrada satisfizer o predicado determinado de testes. |
filtro : ('T -> bool) -> seq<'T> -> seq<'T> |
Retorna uma nova coleção contendo apenas os elementos da coleção para o qual o predicado determinado retorna true. |
localizar : ('T -> bool) -> seq<'T> -> 'T |
Retorna o primeiro elemento para o qual a função determinada retorna true. |
findIndex : ('T -> bool) -> seq<'T> -> int |
Retorna o índice do primeiro elemento para o qual a função determinada retorna true. |
Dobra : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> 'State |
Aplica uma função para cada elemento da coleção, um argumento acumulador por meio de computação de threading. Se a função de entrada for f e os elementos são i0...iN, essa função calcula f (... (f s i0)...) iN. |
ForAll : ('T -> bool) -> seq<'T> -> bool |
Se o predicado determinado de satisfazer todos os elementos da seqüência de testes. |
forall2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool |
Todos os pares de elementos desenhados das duas seqüências de testes satisfazem o determinado predicado. Se uma seqüência é menor que o outro e as demais elementos da seqüência mais longa são ignorados. |
groupBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * seq<'T>> |
Aplica-se a uma função de geração de chave a cada elemento de uma seqüência e gera uma seqüência de chaves exclusivas. Cada chave exclusiva tem também contém uma seqüência de todos os elementos que correspondam a essa chave. |
head : seq<'T> -> 'T |
Retorna o primeiro elemento da seqüência. |
init : int -> (int -> 'T) -> seq<'T> |
Gera uma nova seqüência que, quando iteradas, retorna os elementos de sucessivos chamando a função determinada, até a contagem de determinado. Os resultados da chamada de função não são salvos, ou seja, a função será reaplicada conforme necessário para gerar novamente os elementos. A função é passada o índice do item que está sendo gerado. |
initInfinite : (int -> 'T) -> seq<'T> |
Gera uma nova seqüência que, quando iteradas, retornará elementos sucessivos chamando a função determinada. Os resultados da chamada de função não são salvos, ou seja, a função será reaplicada conforme necessário para gerar novamente os elementos. A função é passada o índice do item que está sendo gerado. |
isEmpty : seq<'T> -> bool |
Testa se uma seqüência tiver quaisquer elementos. |
iter : ('T -> unit) -> seq<'T> -> unit |
Aplica a função de determinado para cada elemento da coleção. |
iter2 : ('T1 -> 'T2 -> unit) -> seq<'T1> -> seq<'T2> -> unit |
Aplica-se a função fornecida para duas coleções simultaneamente. Se uma seqüência é menor que o outro e as demais elementos da seqüência mais longa são ignorados. |
iteri : (int -> 'T -> unit) -> seq<'T> -> unit |
Aplica a função de determinado para cada elemento da coleção. O inteiro passado para a função indica o índice do elemento. |
comprimento : seq<'T> -> int |
Retorna o comprimento da seqüência. |
mapa : ('T -> 'U) -> seq<'T> -> seq<'U> |
Cria uma nova coleção, cujos elementos são os resultados da aplicação da função de determinado para cada um dos elementos da coleção. Função dada será aplicada como elementos são exigidos usando o MoveNext método enumeradores recuperado do objeto. |
map2 : ('T1 -> 'T2 -> 'U) -> seq<'T1> -> seq<'T2> -> seq<'U> |
Cria uma nova coleção, cujos elementos são os resultados da aplicação de determinada função para os pares correspondentes de elementos das duas seqüências. Se uma seqüência de entrada é menor que o outro e as demais elementos da seqüência mais longa são ignorados. |
MAPI : (int -> 'T -> 'U) -> seq<'T> -> seq<'U> |
Cria uma nova coleção, cujos elementos são os resultados da aplicação da função de determinado para cada um dos elementos da coleção. O índice inteiro passado para a função indica o índice (de 0) do elemento que está sendo transformado. |
máx : seq<'T> -> 'T |
Retorna o maior de todos os elementos da seqüência, comparados usando Operators.max. |
maxBy : ('T -> 'U) -> seq<'T> -> 'T |
Retorna o maior de todos os elementos da seqüência, comparados usando Operators.max no resultado da função. |
Mín. : seq<'T> -> 'T |
Retorna o menor de todos os elementos da seqüência, comparados usando Operators.min. |
minBy : ('T -> 'U) -> seq<'T> -> 'T |
Retorna o menor de todos os elementos da seqüência, comparados usando Operators.min no resultado da função. |
enésimo : int -> seq<'T> -> 'T |
Calcula o enésimo elemento na coleção. |
ofArray : 'T array -> seq<'T> |
Exibe a determinada matriz como uma seqüência. |
ofList : 'T list -> seq<'T> |
Exibe a lista fornecida como uma seqüência. |
Pairwise : seq<'T> -> seq<'T * 'T> |
Retorna uma seqüência de cada elemento da seqüência de entrada e seu antecessor, com exceção do primeiro elemento que é retornado como o predecessor de um segundo elemento. |
Escolha : ('T -> 'U option) -> seq<'T> -> 'U |
Aplica a função de determinado elementos sucessivas, retornando o primeiro valor onde a função retorna um Some valor. |
readonly : seq<'T> -> seq<'T> |
Cria um novo objeto de seqüência que delega para o objeto de seqüência de determinada. Isso garante que a seqüência original não pode ser redescoberta e sofrendo mutação por uma conversão de tipo. Por exemplo, se uma matriz de dada a seqüência retornada retornará os elementos da matriz, mas você não pode converter o objeto retornado de seqüência para uma matriz. |
reduzir : ('T -> 'T -> 'T) -> seq<'T> -> 'T |
Aplica uma função para cada elemento da seqüência do argumento acumulador por meio de computação de threading. Comece a aplicação da função para os dois primeiros elementos. Em seguida, alimentam esse resultado a função junto com o terceiro elemento e assim por diante. Retorne o resultado final. |
varredura : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> seq<'State> |
Como Seq.fold, mas calcula sob demanda e retorna a seqüência de resultados intermediários e finais. |
singleton : 'T -> seq<'T> |
Retorna uma seqüência que produz um item somente. |
Ignorar : int -> seq<'T> -> seq<'T> |
Retorna uma seqüência que ignora um número especificado de elementos da seqüência subjacente e, em seguida, gera os elementos restantes da seqüência. |
skipWhile : ('T -> bool) -> seq<'T> -> seq<'T> |
Retorna uma seqüência que, quando iteradas, ignora a elementos da seqüência subjacente, enquanto o predicado retorna a determinado truee em seguida, gera os demais elementos da seqüência. |
classificação : seq<'T> -> seq<'T> |
Gera uma seqüência ordenada por chaves. |
sortBy : ('T -> 'Key) -> seq<'T> -> seq<'T> |
Aplica-se uma função de geração de chave a cada elemento de uma seqüência e o rendimento de uma seqüência ordenada por chaves. As chaves são comparadas usando a comparação de genérica conforme implementado pelo Operators.compare. |
Soma : seq<^T> -> ^T |
Retorna a soma dos elementos na seqüência. |
Retorna a soma dos resultados gerados pela aplicação da função para cada elemento da seqüência. |
|
tirar : int -> seq<'T> -> seq<'T> |
Retorna os primeiros elementos de uma seqüência de até uma contagem especificada. |
takeWhile : ('T -> bool) -> seq<'T> -> seq<'T> |
Retorna uma seqüência que, quando iteradas, produz a elementos da seqüência subjacente, enquanto o predicado retorna a determinado truee em seguida, retorna não mais elementos. |
toArray : seq<'T> -> 'T [] |
Cria uma matriz de determinada coleção. |
toList : seq<'T> -> 'T list |
Cria uma lista de determinada coleção. |
Truncar : int -> seq<'T> -> seq<'T> |
Retorna uma seqüência que, quando enumerado retorna não mais do que um número especificado de elementos. |
tryFind : ('T -> bool) -> seq<'T> -> 'T option |
Retorna o primeiro elemento para o qual a função determinada retorna true, ou None se não há tal elemento existe. |
tryFindIndex : ('T -> bool) -> seq<'T> -> int option |
Retorna o índice do primeiro elemento na seqüência que satisfaça o predicado determinado, ou None se não há tal elemento existe. |
tryPick : ('T -> 'U option) -> seq<'T> -> 'U option |
Aplica a função de determinado elementos sucessivas, retornando o primeiro valor onde a função retorna um Some valor. |
Desdobrar : ('State -> 'T * 'State option) -> 'State -> seq<'T> |
Retorna uma seqüência que contém os elementos gerados por determinada computação. |
em janelas : int -> seq<'T> -> seq<'T []> |
Retorna uma seqüência que gera janelas deslizantes contendo elementos desenhados da seqüência de entrada. Cada janela é retornada como uma nova matriz. |
ZIP : seq<'T1> -> seq<'T2> -> seq<'T1 * 'T2> |
Combina duas seqüências em uma lista de pares. As duas seqüências não precisam ter comprimentos iguais: Quando uma seqüência é esgotada quaisquer elementos restantes na seqüência de são ignorados. |
zip3 : seq<'T1> -> seq<'T2> -> seq<'T3> -> seq<'T1 * 'T2 * 'T3> |
Combina três seqüências em uma lista de triples. As seqüências não precisam ter comprimentos iguais: Quando uma seqüência é esgotada as outras seqüências quaisquer elementos restantes são ignorados. |
Plataformas
O Windows 7, SP2 do Windows Vista, Windows XP SP3, Windows XP Professional x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2
Informações sobre versão
O tempo de execução F#
Compatível com: 2.0, 4.0
Silverlight
Compatível com: 3