Vue d'ensemble

Types et Modules

Collections en F♯ avec leur module associé :

Type F♯	Module	Equivalent BCL	Immutable	Comp. structurelle	Trié par
't array 't[] Array<'t>	Array	≡ Array<T>			Ordre ajout
't list List<'t>	List	≃ Immutable-List<T>			Ordre ajout
ResizeArray (alias)	❌	≡ List<T> ❕			Ordre ajout
't seq seq<'t>	Seq	≡ IEnumerable<T>			Ordre ajout
't set Set<'t>	Set	≃ Immutable-HashSet<T>			Valeur
Map<'K, 'V>	Map	≃ Immutable-Dictionary<K, V>			Clé
dict (cons)	❌	≡ IDictionary<K, V>			Clé
readOnlyDict (cons)	❌	≡ IReadOnly-Dictionary<K, V>			Clé

Homogénéité des fonctions 👍

Communes aux 5 modules :

• empty/isEmpty, exists/forall

• find/tryFind, pick/tryPick, contains (containsKey pour Map)

• map/iter, filter, fold

Communes à Array, List, Seq :

• append/concat, choose, collect

• item, head, last

• take, skip

• ... une centaine de fonctions en tout !

Homogénéité de la syntaxe 👍

Type	Éléments	Range	Comprehension
Array	[∣ 1; 2 ∣]	[∣ 1..5 ∣]	...
List	[ 1; 2 ]	[ 1..5 ]	...
Seq	seq { 1; 2 }	seq { 1..5 }	...
Set	set [ 1; 2 ]	set [ 1..5 ]	...

Piège de la syntaxe ⚠️

Les crochets [] sont utilisés pour :

• Valeur : instance d'une liste [ 1; 2 ] (de type int list)

• Type : tableau int [], par ex. de [| 1; 2 |]

☝ Recommendations

• Bien distinguer type vs valeur ❗

• Préférer écrire int array plutôt que int[]

  • N.B. En console FSI, le type affiché est encore int []

Création par Comprehension

• Syntaxe similaire à boucle for

• Même principe que générateurs en C♯, JS

  • Mot clé yield mais souvent optionnel (F♯ 4.7 / .NET Core 3)

  • Mot clé yield! ≡ yield* JS

  • Fonctionne pour toutes les collections 👍

Exemples :

// Syntaxes équivalentes
seq { for i in 1 .. 10 -> i * i }         // Plutôt obsolète
seq { for i in 1 .. 10 do yield i * i }   // 'yield' explicite
seq { for i in 1 .. 10 do i * i }         // 'yield' omis 👍

// Avec 'if'
let halfEvens =
    [ for i in [1..10] do
        if (i % 2) = 0 then i / 2 ]  // [1; 2; 3; 4; 5]

// 'for' imbriqués
let pairs =
    [ for i in [1..3] do
      for j in [1..3] do
        (i, j) ]              // [(1, 1); (1; 2); (1; 3); (2, 1); ... (3, 3)]

// Même ici les 'yield' peuvent être omis 👍
let twoToNine =
    [ for i in [1; 4; 7] do
        if i > 1 then i
        i + 1
        i + 2 ]  // [2; 3; 4; 5; 6; 7; 8; 9]

yield! permet d'aplatir des collections imbriquées :

let oneToSix =
    [ for i in [1; 3; 5] do
        yield! set [i; i+1] ]