F#
Volgorde

Genereer sequenties

Er zijn meerdere manieren om een reeks te maken.

U kunt functies van de Seq-module gebruiken:

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

U kunt ook een reeks expressie gebruiken:

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

Inleiding tot reeksen

Een reeks is een reeks elementen die kunnen worden opgesomd. Het is een alias van System.Collections.Generic.IE ontelbaar en lui. Het slaat een reeks elementen van hetzelfde type op (kan elke waarde of object zijn, zelfs een andere reeks). Functies van de Seq.module kunnen worden gebruikt om erop te werken.

Hier is een eenvoudig voorbeeld van een reeks opsomming:

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

Output:

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

Pas een functie toe op elk element van een reeks met behulp van Seq.map

Seq.filter

Stel dat we een reeks gehele getallen hebben en dat we een reeks willen maken die alleen de even gehele getallen bevat. We kunnen dit laatste verkrijgen door de filter van de Seq-module te gebruiken. De filter heeft de typeaanduiding ('a -> bool) -> seq<'a> -> seq<'a> ; dit geeft aan dat het een functie accepteert die waar of onwaar retourneert (soms een predikaat genoemd) voor een gegeven invoer van type 'a en een reeks die waarden van type 'a om een reeks op te leveren die waarden van type '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 

Oneindige herhalende reeksen

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

Herhaalde reeksen kunnen worden gemaakt met behulp van een seq {} berekeningsexpressie