Prérequis et mise en place

Le problème que ce module résout

En C#, pour tester une ligne de logique — savoir si x % 2 = 0 renvoie bien ce que vous croyez, ou vérifier la signature d'une méthode LINQ — il faut un projet, une méthode Main, dotnet run, et attendre la compilation complète. Même avec un test unitaire déjà en place, c'est un aller-retour complet à chaque essai.

F# propose un raccourci qui n'a pas d'équivalent direct côté C# : une session interactive, dotnet fsi, dans laquelle vous tapez une expression et obtenez sa valeur et son type immédiatement, sans projet, sans compilation préalable. C'est l'outil que vous allez utiliser pour tous les exercices de ce parcours — pas un gadget annexe, mais le poste de travail principal des sept modules qui suivent.

Vérifier que le SDK .NET est disponible

dotnet fsi fait partie du SDK .NET : si dotnet fonctionne déjà pour vos projets C#, vous l'avez déjà. Vérifiez tout de même quelles versions sont installées :

dotnet --list-sdks

Sortie attendue — une ou plusieurs lignes de ce type :

8.0.100 [/usr/share/dotnet/sdk]
9.0.306 [/usr/share/dotnet/sdk]
10.0.100 [/usr/share/dotnet/sdk]

Peu importe le nombre de versions ou laquelle est la plus récente : ce qui compte est qu'au moins une ligne s'affiche, sans message d'erreur du type « commande introuvable ». Si c'est le cas, votre installation existante suffit pour tout ce parcours ; aucune version particulière de F# n'est requise séparément, elle est livrée avec le SDK .NET lui-même.

Démarrer une première session

Dans un terminal, lancez :

dotnet fsi

Après quelques secondes de démarrage, vous obtenez une invite qui attend votre saisie (le numéro de version affiché peut différer du vôtre, ce n'est pas significatif) :

Microsoft (R) F# Interactive version 11.0.0.0 for F# 5.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

>

C'est un REPL — Read, Evaluate, Print, Loop : vous tapez une expression, elle est évaluée immédiatement, et le résultat s'affiche. Contrairement à un projet C# compilé, rien n'a besoin d'être structuré en méthodes ou en classe au préalable.

La règle du ;;

Une règle unique gouverne tout ce que vous taperez dans dotnet fsi : chaque bloc de code doit se terminer par un double point-virgule ;; pour être évalué. Tant que vous ne l'avez pas tapé, fsi considère que vous êtes encore en train d'écrire une saisie multi-lignes et attend la suite.

Exercice — votre première commande en fsi

Dans la session fsi restée ouverte, tapez exactement ceci puis validez :

let square x = x * x;;

Sortie attendue — fsi affiche le type qu'il a déduit pour la fonction que vous venez de créer (le format exact, avec ou sans espace autour des :, dépend légèrement de la version, mais le sens est le même) :

val square: x: int -> int

Maintenant, appelez cette fonction :

square 12;;

Sortie attendue :

val it: int = 144

it est un nom spécial que fsi attribue au résultat de la dernière expression évaluée quand vous ne lui avez pas donné de nom vous-même. Vous pouvez le réutiliser dans la ligne suivante si besoin — ce n'est qu'une commodité de session interactive, pas une construction que vous retrouverez dans du code F# compilé.

Quitter la session

Quand vous avez terminé, tapez :

#quit;;

ou fermez le terminal directement — aucune de vos définitions n'a besoin d'être sauvegardée pour la suite de ce parcours : vous relancerez simplement dotnet fsi à chaque module.

Ce que vous venez de faire

Vous avez vérifié que le SDK .NET nécessaire est disponible sur votre machine, démarré une session dotnet fsi, défini votre première fonction F# et observé la manière dont fsi affiche le type inféré et le résultat d'une évaluation. C'est le geste que vous répéterez à chaque module de ce parcours.

Au module suivant, vous creusez ce que fsi vient de vous montrer à demi-mot : comment let lie un nom à une valeur ou une fonction, et comment le compilateur déduit un type comme x: int -> int sans que vous l'ayez écrit nulle part.