F#
Séquence

Générer des séquences

Il existe plusieurs façons de créer une séquence.

Vous pouvez utiliser les fonctions du module 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

Vous pouvez également utiliser l'expression de séquence:

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

Introduction aux séquences

Une séquence est une série d'éléments pouvant être énumérés. C'est un alias de System.Collections.Generic.IEnumerable et lazy. Il stocke une série d'éléments du même type (peut être n'importe quelle valeur ou objet, même une autre séquence). Les fonctions du Seq.module peuvent être utilisées pour y opérer.

Voici un exemple simple d'énumération de séquence:

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

Sortie:

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

Appliquer une fonction à chaque élément d'une séquence en utilisant Seq.map

Seq.filter

Supposons que nous ayons une suite d'entiers et que nous voulons créer une séquence contenant uniquement les entiers pairs. Nous pouvons obtenir ce dernier en utilisant la fonction de filter du module Seq. La fonction de filter a le type signature ('a -> bool) -> seq<'a> -> seq<'a> ; cela indique qu'il accepte une fonction qui retourne true ou false (parfois appelé prédicat) pour une entrée donnée de type 'a et une séquence qui comprend des valeurs de type 'a pour donner une séquence comprenant des valeurs de 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 

Séquences répétées infinies

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

Des séquences répétées peuvent être créées en utilisant une expression de calcul seq {}