Une list en F# est une collection immuable de zéro ou plusieurs valeurs. Les valeurs d'une liste doivent toutes avoir le même type. Comme les listes sont immuables, une fois qu'une liste a été construite, sa valeur ne peut plus jamais changer. Toute fonction ou tout opérateur qui semble modifier une liste (par exemple en y ajoutant un élément) renvoie en réalité une nouvelle liste.
Une liste peut être définie comme suit :
let empty = []
let singleValue = [5]
let threeValues = ["a"; "b"; "c"]
La façon la plus courante d'ajouter un élément à une liste est d'utiliser l'opérateur :: (cons) :
let twoToFour = [2; 3; 4]
let oneToFour = 1 :: twoToFour
// => [1; 2; 3; 4]
Une liste F# a une tête (le premier élément) et une queue (tout ce qui suit le premier élément). La queue d'une liste est elle-même une liste.
Les listes se manipulent soit avec les fonctions et opérateurs définis dans le module List, soit manuellement à l'aide du filtrage par motif avec les motifs list et cons :
let describe list =
match list with
| [] -> "Empty list"
| head::tail -> sprintf "Non-empty list with head: %d" head
describe [] // => "Empty list"
describe [1] // => "Non-empty with head: 1"
describe [5; 7; 9] // => "Non-empty with head: 5"
Tu peux aussi ignorer une valeur lors du filtrage par motif ; lorsque tu ne te soucies pas d'une valeur dans un cas précis (autrement dit, tu ne vas pas l'utiliser), tu peux utiliser un tiret bas ('_') pour le signaler :
let describe list =
match list with
| [] -> "Empty list"
| [x] -> "List with one item"
| [_; y] -> "List with two items (first item ignored)"
| _ -> "List with many items (all items ignored)"
describe [] // => "Empty list"
describe [1] // => "List with one item"
describe [5; 7] // => "List with two items (first item ignored)"
describe [5; 7; 9] // => "List with many items (all items ignored)"
Le '_' seul doit toujours venir en dernier lors du filtrage par motif ; toute valeur qui ne correspond à aucun des autres cas sera traitée par ce cas.
Dans cet exercice, tu vas écrire du code pour garder la trace d'un tableau de langages de programmation que tu veux apprendre sur Exercism.
Tu as six tâches, qui consistent toutes à manipuler des tableaux.
Pour garder la trace des langages que tu veux apprendre, tu vas devoir créer un nouveau tableau. Définis la liaison newList qui contient un nouveau tableau vide.
newList
// => []
Pour l'instant, tu as une feuille de papier sur laquelle sont listés les langages que tu veux apprendre : F#, Clojure et Haskell. Définis la liaison existingList pour représenter ce tableau.
existingList
// => ["F#"; "Clojure"; "Haskell"]
Au fur et à mesure que tu explores Exercism et que tu découvres des langages plus intéressants, tu veux les ajouter à ton tableau. Implémente la fonction addLanguage pour ajouter un nouveau langage au début de ton tableau.
addLanguage "TypeScript" ["JavaScript"; "CoffeeScript"]
// => ["TypeScript"; "JavaScript"; "CoffeeScript"]
Compter les langages un par un n'est pas pratique. Implémente la fonction countLanguages pour compter le nombre de langages de ton tableau.
countLanguages ["C#"; "Racket"; "Rust"; "Ruby"]
// => 4
À un moment donné, tu réalises que ton tableau est en fait dans l'ordre inverse ! Implémente la fonction reverseList pour inverser ton tableau.
reverseList ["Prolog"; "C"; "Idris"; "Assembly"]
// => ["Assembly"; "Idris"; "C"; "Prolog"]
Même si tu aimes tous les langages, F# occupe une place particulière dans ton cœur. À ce titre, un tableau de langages te passionne vraiment si :
Implémente la fonction excitingList pour vérifier si un tableau de langages est passionnant :
excitingList ["Nim"; "F#"]
// => true
Inscris-toi sur Exercism pour apprendre et maîtriser F# avec 18 concepts148 exercices, et un vrai mentorat humain, le tout gratuitement.