Módulo Collections.Seq (F#)

Operações básicas de seqüências enumeráveis.

Namespace/Module Path: Microsoft.FSharp.Collections

Assembly: FSharp.Core (em FSharp.Core.dll)

module Seq

Comentários

Para obter uma visão geral de seqüências em F#, consulte Sequências (F#).

Valores

Valor	Descrição
acrescentar: seq<'T> -> seq<'T> -> seq<'T>	Envolve as duas enumerações disponíveis como uma única enumeração concatenada.
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 aplicando a 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 a seqüência de entrada.
conversão: IEnumerable -> seq<'T>	Envolve uma seqüência fracamente tipado de System.Collections como uma seqüência tipada.
escolha: ('T -> 'U option) -> seq<'T> -> seq<'U>	Aplica a função fornecida para cada elemento da lista. Retornar a lista composta de resultados para cada elemento onde a função retorna Some.
coletar: ('T -> 'Collection) -> seq<'T> -> seq<'U>	Aplica a função fornecida 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 determinada de comparação, elemento do elemento.
concat: seq<'Collection> -> seq<'T>	Combina as enumeração -- enumerações disponíveis como uma única enumeração concatenada.
countBy: ('T -> 'Key) -> seq<'T> -> seq<'Key * int>	Aplica uma função de geração para cada elemento de uma seqüência e retornam uma seqüência que produz chaves exclusivas e o número de acertos na seqüência original.
atraso: (unit -> seq<'T>) -> seq<'T>	Retorna uma seqüência que é compilada da especificação tardia de uma determinada seqüência.
distinto: seq<'T> -> seq<'T>	Retorna uma seqüência que não contém nenhuma entrada duplicada de acordo com hash genéricos comparações de igualdade e nas entradas. Se um elemento ocorre várias vezes na seqüência nas ocorrências posteriores são descartados.
distinctBy: ('T -> 'Key) -> seq<'T> -> seq<'T>	Retorna uma seqüência que não contém nenhuma entrada duplicada de acordo com as comparações genéricos de hash e de igualdade em chaves retornadas pela função de geração determinada. Se um elemento ocorre várias vezes na seqüência nas ocorrências posteriores são descartados.
vazio: seq<'T>	Cria uma seqüência vazia.
exactlyOne: seq<'T> -> 'T	Retorna o único elemento de seqüência.
existe: ('T -> bool) -> seq<'T> -> bool	Teste se qualquer elemento de seqüência satisfaz o predicado dado.
: ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> booldeexists2	Teste se qualquer par de elementos correspondentes de seqüências de entrada satisfaz o predicado dado.
filtro: ('T -> bool) -> seq<'T> -> seq<'T>	Retorna uma nova coleção que contém apenas elementos da coleção para que o predicado determinado retorna true.
localizar: ('T -> bool) -> seq<'T> -> 'T	Retorna o primeiro elemento para que a função retorna determinada true.
findIndex: ('T -> bool) -> seq<'T> -> int	Retorna o índice do primeiro elemento para que a função retorna determinada true.
dobra: ('State -> 'T -> 'State) -> 'State -> seq<'T> -> 'State	Aplica uma função para cada elemento da coleção, rosqueando um argumento de acumulador com a computação. Se a função de entrada é f e os elementos são i0...iN, em cálculos f (... (f s i0)...) iNde essa função.
forall: ('T -> bool) -> seq<'T> -> bool	Teste se todos os elementos da seqüência no predicado dado.
: ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> booldeforall2	Testa pares de todos os elementos desenhados das seqüências no predicado dado. Se uma seqüência é menor que a outros elementos restantes a seqüência maior será ignorada em.
groupBy: ('T -> 'Key) -> seq<'T> -> seq<'Key * seq<'T>>	Aplica uma função de geração para cada elemento de uma seqüência e produz uma seqüência de chaves exclusivas. Cada chave exclusiva tem também contém uma seqüência de todos os elementos que correspondem a essa chave.
o início: seq<'T> -> 'T	Retorna o primeiro elemento da seqüência.
init: int -> (int -> 'T) -> seq<'T>	Gera uma nova seqüência que, quando iterada, retorna os elementos sucessivos chamar a função determinada, até a contagem determinada. Os resultados de chamar a função não são salvos, ou seja, a função é reaplicada conforme necessário para gerar 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 iterada, retorna os elementos sucessivos chamar a função especificados. Os resultados de chamar a função não são salvos, ou seja, a função será reaplicada conforme necessário para gerar os elementos. A função é passada o índice do item que está sendo gerado.
isEmpty: seq<'T> -> bool	Testa se uma seqüência ter quaisquer elementos.
ITER: ('T -> unit) -> seq<'T> -> unit	Aplica a função fornecida para cada elemento da coleção.
: ('T1 -> 'T2 -> unit) -> seq<'T1> -> seq<'T2> -> unitdeiter2	Aplica a função recebe a duas coleções simultaneamente. Se uma seqüência é menor que a outros elementos restantes a seqüência maior será ignorada em.
iteri: (int -> 'T -> unit) -> seq<'T> -> unit	Aplica a função fornecida para cada elemento da coleção. Toda passado para a função indica o índice do elemento.
último: seq<'T> -> 'T	Retorna o último elemento da seqüência.
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 de aplicar a função fornecida para cada um dos elementos da coleção. A função fornecida será aplicada como elementos é necessária usando o método de MoveNext nos enumeradores recuperados do objeto.
: ('T1 -> 'T2 -> 'U) -> seq<'T1> -> seq<'T2> -> seq<'U>demap2	Cria uma nova coleção cujos elementos são os resultados de aplicar a função dada aos pares correspondentes de elementos das seqüências. Se uma seqüência de entrada é menor que a outros elementos restantes a seqüência maior será ignorada em.
mapi: (int -> 'T -> 'U) -> seq<'T> -> seq<'U>	Cria uma nova coleção cujos elementos são os resultados de aplicar a função fornecida para cada um dos elementos da coleção. O índice inteiro passado para a função indica o índice (0) do elemento que está sendo transformado.
máximo: seq<'T> -> 'T	Retorna o grande de todos os elementos da seqüência, comparadas usando Operators.max.
maxBy: ('T -> 'U) -> seq<'T> -> 'T	Retorna o grande de todos os elementos da seqüência, comparadas usando Operators.max o resultado da função.
minuto: seq<'T> -> 'T	Retorna o mais baixo de todos os elementos da seqüência, comparadas usando Operators.min.
minBy: ('T -> 'U) -> seq<'T> -> 'T	Retorna o mais baixo de todos os elementos da seqüência, comparadas usando Operators.min o resultado da função.
nth: int -> seq<'T> -> 'T	Calcula o nth elemento na coleção.
ofArray: 'T array -> seq<'T>	Exibe a matriz fornecida como uma seqüência.
ofList: 'T list -> seq<'T>	Exibe a lista fornecida como uma seqüência.
por pares: seq<'T> -> seq<'T * 'T>	Retorna uma seqüência de cada elemento na seqüência de entrada e em seu antecessor, com exceção do primeiro elemento que é retornado somente como o antecessor do segundo elemento.
picareta: ('T -> 'U option) -> seq<'T> -> 'U	Aplica a função determinada para sucessivos elementos, retornando o primeiro valor onde a função retorna um valor de Some .
readonly: seq<'T> -> seq<'T>	Cria um novo objeto de seqüência que representantes a seqüência determinada objeto. Isso garante que a seqüência original não pode ser redescoberta e transformado por uma conversão de tipos. Por exemplo, se fornecida uma matriz a seqüência retornado retornará os elementos da matriz, mas você não pode converter o objeto retornado da seqüência a uma matriz.
reduza: ('T -> 'T -> 'T) -> seq<'T> -> 'T	Aplica uma função para cada elemento da seqüência, rosqueando um argumento de acumulador com a computação. Inicie aplicando a função para os primeiros dois elementos. Alimente então o resultado da função juntamente com o terceiro elemento e assim por diante. Retornar o resultado final.
: ('State -> 'T -> 'State) -> 'State -> seq<'T> -> seq<'State>deverificação	Como Seq.fold, mas sob demanda calcula e retorna a seqüência de resultados intermediários e finais.
singleton: 'T -> seq<'T>	Retorna uma seqüência que gere um item somente.
ignorar: int -> seq<'T> -> seq<'T>	Retorna uma seqüência que pular um número especificado de elementos da seqüência subjacente e gere os elementos restantes na seqüência.
skipWhile: ('T -> bool) -> seq<'T> -> seq<'T>	Retorna uma seqüência que, quando iterada, pule os elementos da seqüência subjacente quando o predicado determinado retornar true, e gere os elementos restantes na seqüência.
tipo: seq<'T> -> seq<'T>	Produz uma seqüência ordenada por chaves.
sortBy: ('T -> 'Key) -> seq<'T> -> seq<'T>	Aplica uma função de geração para cada elemento de uma seqüência e produzem uma seqüência ordenada por chaves. As chaves são comparadas usando a comparação genérico como implementadas por Operators.compare.
soma: seq<^T> -> ^T	Retorna a soma dos elementos na seqüência.
sumBy	Retorna a soma dos resultados gerados aplicando a função para cada elemento da seqüência.
tomada: int -> seq<'T> -> seq<'T>	Retorna o primeiro elementos da seqüência até uma pontuação especificada.
takeWhile: ('T -> bool) -> seq<'T> -> seq<'T>	Retorna uma seqüência que, quando iterada, guarde os elementos da seqüência subjacente quando o predicado determinado retornar true, e então não retorna nenhum elemento adicional.
toArray: seq<'T> -> 'T []	Cria uma matriz de coleção dada.
toList: seq<'T> -> 'T list	Cria uma lista de coleção dada.
truncado: int -> seq<'T> -> seq<'T>	Retorna uma seqüência que quando retorna enumerados não mais do que um número especificado de elementos.
tryFind: ('T -> bool) -> seq<'T> -> 'T option	Retorna o primeiro elemento para que a função retorna truedeterminada, ou se nenhum None tal elemento existe.
tryFindIndex: ('T -> bool) -> seq<'T> -> int option	Retorna o índice do primeiro elemento na seqüência que satisfaz o predicado determinado, ou em None se nenhum tal elemento existe.
tryPick: ('T -> 'U option) -> seq<'T> -> 'U option	Aplica a função determinada para sucessivos elementos, retornando o primeiro valor onde a função retorna um valor de Some .
desdobrar: ('State -> 'T * 'State option) -> 'State -> seq<'T>	Retorna uma seqüência que contém os elementos gerados pela computação determinada.
onde: ('T -> bool) -> seq<'T> -> seq<'T>	Retorna uma nova coleção que contém apenas elementos da coleção para que o predicado determinado retorna true. Um sinónimo para Seq.filter.
da janela: int -> seq<'T> -> seq<'T []>	Retorna uma seqüência do windows que gere deslizamento dos elementos recipientes desenhados a seqüência de entrada. Cada janela é retornada como uma matriz atualizado.
CEP: seq<'T1> -> seq<'T2> -> seq<'T1 * 'T2>	Combina as duas seqüências em uma lista de pares. As duas seqüências não precisam ter tamanhos iguais: quando uma seqüência é esgotada todos os elementos restantes na outra seqüência são ignorados.
: seq<'T1> -> seq<'T2> -> seq<'T3> -> seq<'T1 * 'T2 * 'T3>dezip3	Combina as três seqüências em uma lista triplicar-se. Sequências não precisam ter tamanhos iguais: quando uma seqüência é esgotada todos os elementos restantes em outras seqüências são ignoradas.

Plataformas

O windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Informações de Versão

Versões da biblioteca principal de F#

Suportado em: 2,0, 4,0, portáteis

Consulte também

Referência

Namespace Microsoft.FSharp.Collections (F#)

Sequências (F#)

Abreviação de tipo Collections.seq<'T> (F#)