F#
Sekwencja

Generuj sekwencje

Istnieje wiele sposobów tworzenia sekwencji.

Możesz używać funkcji z modułu Seq:

// 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

Możesz także użyć wyrażenia sekwencji:

// 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 }
}

Wprowadzenie do sekwencji

Sekwencja to seria elementów, które można wyliczyć. Jest to alias System.Collections.Generic.IEnumerable i leniwy. Przechowuje szereg elementów tego samego typu (może to być dowolna wartość lub obiekt, nawet inna sekwencja). Można na nim obsługiwać funkcje z Seq.module.

Oto prosty przykład wyliczenia sekwencji:

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

Wynik:

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; ...]

Zastosuj funkcję do każdego elementu sekwencji za pomocą Seq.map

Filtr sekw

Załóżmy, że mamy sekwencję liczb całkowitych i chcemy utworzyć sekwencję zawierającą tylko parzyste liczby całkowite. Ten drugi możemy uzyskać za pomocą funkcji filter modułu Seq. Funkcja filter ma podpis typu ('a -> bool) -> seq<'a> -> seq<'a> ; oznacza to, że akceptuje funkcję, która zwraca wartość prawda lub fałsz (czasami nazywaną predykatem) dla danych wejściowych typu 'a oraz sekwencji zawierającej wartości typu 'a aby uzyskać sekwencję zawierającą wartości typu '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 

Nieskończone powtarzające się sekwencje

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

Powtarzające się sekwencje można utworzyć za pomocą wyrażenia obliczeniowego o sekwencji seq {}