F#
Sequenz

Sequenzen erzeugen

Es gibt mehrere Möglichkeiten, eine Sequenz zu erstellen.

Sie können Funktionen aus dem Seq-Modul verwenden:

// Create an empty generic sequence
let emptySeq = Seq.empty 

// Create an empty int sequence
let emptyIntSeq = Seq.empty<int> 

// Create a sequence with one element    
let singletonSeq = Seq.singleton 10 

// Create a sequence of n elements with the specified init function
let initSeq = Seq.init 10 (fun c -> c * 2) 

// Combine two sequence to create a new one
let combinedSeq = emptySeq |> Seq.append singletonSeq

// Create an infinite sequence using unfold with generator based on state
let naturals = Seq.unfold (fun state -> Some(state, state + 1)) 0

Sie können auch Sequenzausdruck verwenden:

// Create a sequence with element from 0 to 10
let intSeq = seq { 0..10 }

// Create a sequence with an increment of 5 from 0 to 50
let intIncrementSeq = seq{ 0..5..50 }

// Create a sequence of strings, yield allow to define each element of the sequence
let stringSeq = seq {
    yield "Hello"
    yield "World"
}

// Create a sequence from multiple sequence, yield! allow to flatten sequences
let flattenSeq = seq {
    yield! seq { 0..10 }
    yield! seq { 11..20 }
}

Einführung in Sequenzen

Eine Sequenz ist eine Reihe von Elementen, die aufgezählt werden können. Es ist ein Alias ​​von System.Collections.Generic.IEnumerable und faul. Es speichert eine Reihe von Elementen desselben Typs (kann ein beliebiger Wert oder ein beliebiges Objekt sein, sogar eine andere Sequenz). Funktionen des Seq.modules können verwendet werden, um darauf zu arbeiten.

Hier ist ein einfaches Beispiel für eine Sequenzaufzählung:

let mySeq = { 0..20 } // Create a sequence of int from 0 to 20
mySeq
|> Seq.iter (printf "%i ") // Enumerate each element of the sequence and print it

Ausgabe:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Seq.map

let seq = seq {0..10}

s |> Seq.map (fun x -> x * 2)

> val it : seq<int> = seq [2; 4; 6; 8; ...]

Wenden Sie mit Seq.map eine Funktion auf jedes Element einer Sequenz an

Seq.filter

Angenommen, wir haben eine Folge von ganzen Zahlen und möchten eine Folge erstellen, die nur die geraden ganzen Zahlen enthält. Letzteres können wir über die filter des Seq-Moduls erhalten. Die filter hat die Typensignatur ('a -> bool) -> seq<'a> -> seq<'a> ; Dies bedeutet, dass es eine Funktion akzeptiert, die wahr oder falsch (manchmal Prädikat) für eine bestimmte Eingabe des Typs 'a zurückgibt 'a und eine Sequenz, die Werte des Typs 'a , um eine Sequenz zu ergeben, die Werte des Typs 'a .

// Function that tests if an integer is even
let isEven x = (x % 2) = 0

// Generates an infinite sequence that contains the natural numbers
let naturals = Seq.unfold (fun state -> Some(state, state + 1)) 0
 
// Can be used to filter the naturals sequence to get only the even numbers
let evens = Seq.filter isEven naturals 

Unendlich wiederholende Sequenzen

let data = [1; 2; 3; 4; 5;]
let repeating = seq {while true do yield! data}

Wiederholte Sequenzen können mit einem Berechnungsausdruck seq {} erstellt werden