F#
Sekvens

Generera sekvenser

Det finns flera sätt att skapa en sekvens.

Du kan använda funktioner från Seq-modulen:

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

Du kan också använda sekvensuttryck:

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

Introduktion till sekvenser

En sekvens är en serie element som kan räknas upp. Det är ett alias av System.Collections.Generic.IEnumrerbar och lat. Den lagrar en serie element av samma typ (kan vara valfritt värde eller objekt, till och med en annan sekvens). Funktioner från Seq.module kan användas för att driva den.

Här är ett enkelt exempel på en sekvensuppräkning:

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

Produktion:

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

Använd en funktion på varje element i en sekvens med Seq.map

Seq.filter

Anta att vi har en sekvens med heltal och vi vill skapa en sekvens som endast innehåller de jämna heltalen. Vi kan få det senare med hjälp av filter för Seq-modulen. filter har typsignaturen ('a -> bool) -> seq<'a> -> seq<'a> ; detta indikerar att den accepterar en funktion som returnerar sant eller falskt (ibland kallat ett predikat) för en given ingång av typen 'a och en sekvens som innefattar värden av typ 'a att ge en sekvens som innefattar värden av typ '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 

Oändliga upprepade sekvenser

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

Upprepande sekvenser kan skapas med hjälp av ett seq {} beräkningsuttryck