Collections.Seq-Modul (F#)
Grundlegende Vorgänge für aufzählbare Sequenzen.
Namespace/Modulpfad: Microsoft.FSharp.Collections
Assembly: FSharp.Core (in FSharp.Core.dll)
module Seq
Hinweise
Eine Übersicht über Sequenzen in F# finden Sie unter Sequenzen (F#).
Werte
Wert |
Beschreibungen |
|---|---|
append : seq<'T> -> seq<'T> -> seq<'T> |
Umschließt die zwei angegebenen Enumerationen in einer verketteten Enumeration. |
average : seq<^T> -> ^T |
Gibt den Durchschnitt der Elemente in der Sequenz zurück. |
averageBy : ('T -> ^U) -> seq<'T> -> ^U |
Gibt den Durchschnitt der Ergebnisse zurück, die durch Anwenden der Funktion auf die einzelnen Elemente der Sequenz generiert wurden. |
cache : seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die einer zwischengespeicherten Version der Eingabesequenz entspricht. |
cast : IEnumerable -> seq<'T> |
Umschließt eine lose typisierte System.Collections-Sequenz als typisierte Sequenz. |
choose : ('T -> 'U option) -> seq<'T> -> seq<'U> |
Wendet die angegebene Funktion auf jedes Element der Liste an. Gibt die Liste zurück, die aus den Ergebnissen für die einzelnen Elemente besteht, bei denen die Funktion Some zurückgibt |
collect : ('T -> 'Collection) -> seq<'T> -> seq<'U> |
Wendet die angegebene Funktion auf die einzelnen Elemente der Sequenz an und verkettet alle Ergebnisse. |
compareWith : ('T -> 'T -> int) -> seq<'T> -> seq<'T> -> int |
Vergleicht zwei Sequenzen elementweise mit der angegebenen Vergleichsfunktion. |
concat : seq<'Collection> -> seq<'T> |
Kombiniert die angegebene Enumeration von Enumerationen zu einer einzigen verketteten Enumeration. |
countBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * int> |
Wendet eine Funktion zur Generierung von Schlüsseln auf die einzelnen Elemente einer Sequenz an und gibt eine Sequenz zurück, die eindeutige Schlüssel sowie die Anzahl der Vorkommen in der ursprünglichen Sequenz ergibt. |
delay : (unit -> seq<'T>) -> seq<'T> |
Gibt eine Sequenz zurück, die aus der angegebenen verzögerten Spezifikation einer Sequenz erstellt wird. |
distinct : seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die nach generischen Hash- und Gleichheitsvergleichen für die Einträge keine doppelten Einträge enthält. Wenn ein Element mehrere Male in der Sequenz auftritt, werden alle nachfolgenden Vorkommen verworfen. |
distinctBy : ('T -> 'Key) -> seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die nach generischen Hash- und Gleichheitsvergleichen für die Schlüssel, die von der angegebenen Funktion zur Generierung von Schlüsseln zurückgegeben werden, keine doppelten Werte enthält. Wenn ein Element mehrere Male in der Sequenz auftritt, werden alle nachfolgenden Vorkommen verworfen. |
empty : seq<'T> |
Erstellt eine leere Sequenz. |
exists : ('T -> bool) -> seq<'T> -> bool |
Prüft, ob ein Element der Sequenz das angegebene Prädikat erfüllt. |
exists2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool |
Testet, ob ein Paar passender Elemente der Eingabesequenzen dem angegebenen Prädikat entspricht. |
filter : ('T -> bool) -> seq<'T> -> seq<'T> |
Gibt eine neue Auflistung zurück, die nur die Elemente der Auflistung enthält, für die das angegebene Prädikat true zurückgibt. |
find : ('T -> bool) -> seq<'T> -> 'T |
Gibt das erste Element zurück, für das die angegebene Funktion true zurückgibt. |
findIndex : ('T -> bool) -> seq<'T> -> int |
Gibt den Index des ersten Elements zurück, für das die angegebene Funktion true zurückgibt. |
fold : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> 'State |
Wendet eine Funktion auf jedes Element der Auflistung an, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Ist die Eingabefunktion f und sind die Elemente i0...iN, berechnet diese Funktion f (... (f s i0)...) iN. |
forall : ('T -> bool) -> seq<'T> -> bool |
Prüft, ob alle Elemente der Sequenz das angegebene Prädikat erfüllen. |
forall2 : ('T1 -> 'T2 -> bool) -> seq<'T1> -> seq<'T2> -> bool |
Überprüft alle aus den zwei Sequenzen abgerufenen Paare von Elementen, die dem angegebenen Prädikat entsprechen. Wenn eine Sequenz kürzer ist als die andere, werden die verbleibenden Elemente der längeren Sequenz ignoriert. |
groupBy : ('T -> 'Key) -> seq<'T> -> seq<'Key * seq<'T>> |
Wendet eine Funktion zur Generierung von Schlüsseln auf die einzelnen Elemente einer Sequenz an und ergibt eine Sequenz eindeutiger Schlüssel. Jeder eindeutige Schlüssel enthält außerdem eine Sequenz aller Elemente, die mit diesem Schlüssel übereinstimmen. |
Kopf : seq<'T> -> 'T |
Gibt das erste Element der Sequenz zurück. |
init : int -> (int -> 'T) -> seq<'T> |
Generiert eine neue Sequenz, die beim Durchlaufen aufeinander folgende Elemente bis zur angegebenen Anzahl zurückgibt, indem die angegebene Funktion aufgerufen wird. Die Ergebnisse des Funktionsaufrufs werden nicht gespeichert, d. h. die Funktion wird bei Bedarf erneut angewendet, um die Elemente neu zu generieren. An die Funktion wird der Index des generierten Elements übergeben. |
initInfinite : (int -> 'T) -> seq<'T> |
Generiert eine neue Sequenz, die beim Durchlaufen aufeinander folgende Elemente zurückgibt, indem die angegebene Funktion aufgerufen wird. Die Ergebnisse des Funktionsaufrufs werden nicht gespeichert, d. h., die Funktion wird bei Bedarf erneut angewendet, um die Elemente neu zu generieren. An die Funktion wird der Index des generierten Elements übergeben. |
isEmpty : seq<'T> -> bool |
Testet, ob eine Sequenz über Elemente verfügt. |
iter : ('T -> unit) -> seq<'T> -> unit |
Wendet die angegebene Funktion auf jedes Element der Auflistung an. |
iter2 : ('T1 -> 'T2 -> unit) -> seq<'T1> -> seq<'T2> -> unit |
Wendet die angegebene Funktion gleichzeitig auf zwei Auflistungen an. Wenn eine Sequenz kürzer ist als die andere, werden die verbleibenden Elemente der längeren Sequenz ignoriert. |
iteri : (int -> 'T -> unit) -> seq<'T> -> unit |
Wendet die angegebene Funktion auf jedes Element der Auflistung an. Die an die Funktion übergebene Ganzzahl gibt den Index des Elements an. |
length : seq<'T> -> int |
Gibt die Länge der Sequenz zurück. |
map : ('T -> 'U) -> seq<'T> -> seq<'U> |
Wendet die angegebene Funktion auf jedes Element in der Auflistung an und erstellt aus den Ergebnissen eine neue Auflistung. Die angegebene Funktion wird angewendet, wenn Elemente mit der MoveNext-Methode für vom Objekt abgerufene Enumeratoren angefordert werden. |
map2 : ('T1 -> 'T2 -> 'U) -> seq<'T1> -> seq<'T2> -> seq<'U> |
Wendet die angegebene Funktion auf die zusammengehörenden Elementpaare in beiden Sequenzen an und erstellt aus den Ergebnissen eine neue Auflistung. Wenn eine Eingabesequenz kürzer ist als die andere, werden die verbleibenden Elemente der längeren Sequenz ignoriert. |
mapi : (int -> 'T -> 'U) -> seq<'T> -> seq<'U> |
Wendet die angegebene Funktion auf jedes Element in der Auflistung an und erstellt aus den Ergebnissen eine neue Auflistung. Der ganzzahlige Index, der an die Funktion übergeben wird, gibt den Index (beginnend bei 0) des zu transformierenden Elements an. |
max : seq<'T> -> 'T |
Gibt das Element der Sequenz zurück, das bei einem Vergleich mit Operators.max am größten ist. |
maxBy : ('T -> 'U) -> seq<'T> -> 'T |
Gibt das Element der Sequenz zurück, das bei einem Vergleich des Funktionsergebnisses mit Operators.max am größten ist. |
min : seq<'T> -> 'T |
Gibt das Element der Sequenz zurück, das bei einem Vergleich mit Operators.min am kleinsten ist. |
minBy : ('T -> 'U) -> seq<'T> -> 'T |
Gibt das Element der Sequenz zurück, das bei einem Vergleich des Funktionsergebnisses mit Operators.min am kleinsten ist. |
nth : int -> seq<'T> -> 'T |
Berechnet das n-te Element in der Auflistung. |
ofArray : 'T array -> seq<'T> |
Zeigt das angegebene Array als Sequenz an. |
ofList : 'T list -> seq<'T> |
Zeigt die angegebene Liste als Sequenz an. |
pairwise : seq<'T> -> seq<'T * 'T> |
Gibt eine Sequenz der einzelnen Elemente in der Eingabesequenz und des zugehörigen Vorgängers zurück, mit Ausnahme des ersten Elements, das nur als Vorgänger des zweiten Elements zurückgegeben wird. |
pick : ('T -> 'U option) -> seq<'T> -> 'U |
Wendet die angegebene Funktion auf aufeinander folgende Elemente an und gibt den ersten Wert zurück, bei dem die Funktion Some zurückgibt. |
readonly : seq<'T> -> seq<'T> |
Erstellt ein neues Sequenzobjekt, das an das angegebene Sequenzobjekt delegiert wird. Dadurch wird sichergestellt, dass die ursprüngliche Sequenz nicht erneut von einer Typumwandlung erkannt und verändert werden kann. Beispielsweise enthält die zurückgegebene Sequenz bei einem angegebenen Array die Elemente des Arrays; das zurückgegebene Sequenzobjekt kann jedoch nicht in ein Array konvertiert werden. |
reduce : ('T -> 'T -> 'T) -> seq<'T> -> 'T |
Wendet eine Funktion auf jedes Element der Sequenz an, wobei ein Akkumulatorargument in der Berechnung mitgeführt wird. Zunächst wird die Funktion auf die ersten beiden Elemente angewendet. Anschließend wird dieses Ergebnis zusammen mit dem dritten Element usw. an die Funktion übergeben. Abschließend wird das Endergebnis zurückgegeben. |
scan : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> seq<'State> |
Wie Seq.fold, berechnet jedoch auf Anforderung und gibt die Sequenz der Zwischen- und Endergebnisse zurück. |
singleton : 'T -> seq<'T> |
Gibt eine Sequenz zurück, die nur ein Element ergibt. |
skip : int -> seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die eine angegebene Anzahl von Elementen der zugrunde liegenden Sequenz überspringt und dann die verbleibenden Elemente der Sequenz ergibt. |
skipWhile : ('T -> bool) -> seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die beim Durchlaufen die Elemente der zugrunde liegenden Sequenz überspringt, solange das angegebene Prädikat true zurückgibt, und dann die verbleibenden Elemente der Sequenz ergibt. |
sort : seq<'T> -> seq<'T> |
Ergibt eine nach Schlüsseln sortierte Sequenz. |
sortBy : ('T -> 'Key) -> seq<'T> -> seq<'T> |
Wendet eine Schlüsselgenerierungsfunktionalität auf die einzelnen Elemente einer Sequenz an und ergibt eine nach Schlüsseln sortierte Sequenz. Die Schlüssel werden mit einem generischem Vergleich wie in Operators.compare verglichen. |
sum : seq<^T> -> ^T |
Gibt die Summe der Elemente in der Sequenz zurück. |
Gibt die Summe der Ergebnisse zurück, die durch Anwenden der Funktion auf die einzelnen Elemente der Sequenz generiert wird. |
|
take : int -> seq<'T> -> seq<'T> |
Gibt die ersten Elemente der Sequenz bis zu einer angegebenen Zahl zurück. |
takeWhile : ('T -> bool) -> seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die beim Durchlaufen nur so lange Elemente der zugrunde liegenden Sequenz zurückgibt, solange das angegebene Prädikat true zurückgibt. |
toArray : seq<'T> -> 'T [] |
Erstellt ein Array aus der angegebenen Auflistung. |
toList : seq<'T> -> 'T list |
Erstellt eine Liste aus der angegebenen Auflistung. |
truncate : int -> seq<'T> -> seq<'T> |
Gibt eine Sequenz zurück, die bei der Aufzählung nicht mehr als eine angegebene Anzahl von Elementen zurückgibt. |
tryFind : ('T -> bool) -> seq<'T> -> 'T option |
Gibt das erste Element zurück, für das die angegebene Funktion true oder None zurückgibt, wenn kein solches Element vorhanden ist. |
tryFindIndex : ('T -> bool) -> seq<'T> -> int option |
Gibt den Index des ersten Elements in der Sequenz zurück, das das angegebene Prädikat erfüllt, oder None, wenn kein solches Element vorhanden ist. |
tryPick : ('T -> 'U option) -> seq<'T> -> 'U option |
Wendet die angegebene Funktion auf aufeinander folgende Elemente an und gibt den ersten Wert zurück, bei dem die Funktion Some zurückgibt. |
unfold : ('State -> 'T * 'State option) -> 'State -> seq<'T> |
Gibt eine Sequenz zurück, die die von der angegebenen Berechnung generierten Elemente enthält. |
windowed : int -> seq<'T> -> seq<'T []> |
Gibt eine Sequenz zurück, die gleitende Fenster enthaltender Elementen ergibt, die von der Eingabesequenz gezeichnet werden. Jedes Fenster wird als neues Array zurückgegeben. |
zip : seq<'T1> -> seq<'T2> -> seq<'T1 * 'T2> |
Kombiniert die beiden Sequenzen in eine Liste von Paaren. Die beiden Sequenzen müssen nicht gleich lang sein: wenn eine Sequenz erschöpft ist, werden alle verbleibenden Elemente in der anderen Sequenz ignoriert. |
zip3 : seq<'T1> -> seq<'T2> -> seq<'T3> -> seq<'T1 * 'T2 * 'T3> |
Kombiniert die drei Sequenzen in eine Liste von Tripeln. Die beiden Sequenzen müssen nicht gleich lang sein: wenn eine Sequenz erschöpft ist, werden alle verbleibenden Elemente in den anderen Sequenzen ignoriert. |
Plattformen
Windows 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2
Versionsinformationen
F#-Runtime
Unterstützt in: 2.0, 4.0
Silverlight
Unterstützt in: 3