Módulo de 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 Seqüê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. |
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