Programmation interactive avec F#

F# Interactive (dotnet fsi) est utilisé pour exécuter du code F# de manière interactive sur la console ou pour exécuter des scripts F#. En d’autres termes, F# interactive exécute une REPL (Lecture, Évaluation, Boucle d’impression) pour F#.

Pour exécuter F# Interactive à partir de la console, exécutez dotnet fsi. Vous trouverez dotnet fsi dans n’importe quel Kit de développement logiciel (SDK) .NET.

Pour plus d’informations sur les options de ligne de commande disponibles, consultez Options interactives F#.

Exécution de code directement dans F# Interactive

Étant donné que F# Interactive est une boucle REPL (lecture-eval-print), vous pouvez exécuter du code de manière interactive. Voici un exemple de session interactive après l’exécution de dotnet fsi à partir de la ligne de commande :

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

For help type #help;;

> let square x = x *  x;;
val square : x:int -> int

> square 12;;
val it : int = 144

> printfn "Hello, FSI!"
- ;;
Hello, FSI!
val it : unit = ()

Vous remarquerez deux choses principales :

1. Tout le code doit être terminé par deux points-virgules (;;) pour être évalué.
2. Le code est évalué et stocké dans une valeur it. Vous pouvez référencer it de manière interactive.

F# Interactive prend également en charge l’entrée multiligne. Vous devez simplement mettre fin à votre soumission avec un point-virgule double (;;). Considérez l’extrait de code suivant qui a été collé dans et évalué par F# Interactive :

> let getOddSquares xs =
-     xs
-     |> List.filter (fun x -> x % 2 <> 0)
-     |> List.map (fun x -> x * x)
-
- printfn "%A" (getOddSquares [1..10]);;
[1; 9; 25; 49; 81]
val getOddSquares : xs:int list -> int list
val it : unit = ()

>

La mise en forme du code est conservée et il existe un point-virgule double (;;) qui termine l’entrée. F# Interactive a ensuite évalué le code et imprimé les résultats !

Script avec F#

L’évaluation interactive du code en F# Interactive peut être un excellent outil d’apprentissage, mais vous constaterez rapidement qu’il n’est pas aussi productif que l’écriture de code dans un éditeur normal. Pour prendre en charge la modification normale du code, vous pouvez écrire des scripts F#.

Les scripts utilisent l’extension de fichier .fsx. Au lieu de compiler du code source, puis d’exécuter ultérieurement l’assembly compilé, vous pouvez simplement exécuter dotnet fsi et spécifier le nom de fichier du script du code source F#, et F# interactive lit le code et l’exécute en temps réel. Par exemple, considérez le script suivant appelé Script.fsx:

let getOddSquares xs =
    xs
    |> List.filter (fun x -> x % 2 <> 0)
    |> List.map (fun x -> x * x)

printfn "%A" (getOddSquares [1..10])

Lorsque ce fichier est créé sur votre ordinateur, vous pouvez l’exécuter avec dotnet fsi et voir la sortie directement dans votre fenêtre de terminal :

dotnet fsi Script.fsx
[1; 9; 25; 49; 81]

Le script F# est pris en charge en mode natif dans Visual Studio et Visual Studio Code.

Référencement de packages dans F# Interactive

Depuis la version 5.0 du langage, F# Interactive prend en charge le référencement de packages par le biais d’un mécanisme d’extensibilité ; Prête à l’emploi, elle peut référencer des packages NuGet avec la syntaxe #r "nuget:" et une version facultative :

#r "nuget: Newtonsoft.Json"
open Newtonsoft.Json

let data = {| Name = "Don Syme"; Occupation = "F# Creator" |}
JsonConvert.SerializeObject(data)

Si aucune version n’est spécifiée, le package non préversion disponible le plus élevé est pris. Pour référencer une version spécifique, introduisez la version par le biais d’une virgule. Cela peut être pratique lors du référencement d’une version préliminaire d’un package. Par exemple, considérez ce script à l’aide d’une préversion de DiffSharp:

#r "nuget: DiffSharp-lite, 1.0.0-preview-328097867"
open DiffSharp

// A 1D tensor
let t1 = dsharp.tensor [ 0.0 .. 0.2 .. 1.0 ]

// A 2x2 tensor
let t2 = dsharp.tensor [ [ 0; 1 ]; [ 2; 2 ] ]

// Define a scalar-to-scalar function
let f (x: Tensor) = sin (sqrt x)

printfn $"{f (dsharp.tensor 1.2)}"

Spécification d’une source de package

Vous pouvez également spécifier une source de package avec la commande #i. L’exemple suivant spécifie une source distante et locale :

#i "nuget: https://my-remote-package-source/index.json"
#i """nuget: C:\path\to\my\local\source"""

Cela indique au moteur de résolution sous les couvertures de prendre également en compte les sources distantes et/ou locales ajoutées à un script.

Vous pouvez spécifier autant de références de package que vous le souhaitez dans un script.

Référencement d'assemblies sur disque avec F# Interactive

Sinon, si vous avez un assembly sur le disque et que vous souhaitez référencer cela dans un script, vous pouvez utiliser la syntaxe #r pour spécifier un assembly. Considérez le code suivant dans un projet compilé en MyAssembly.dll:

// MyAssembly.fs
module MyAssembly
let myFunction x y = x + 2 * y

Une fois compilé, vous pouvez le référencer dans un fichier appelé Script.fsx comme suit :

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

La sortie est la suivante :

dotnet fsi Script.fsx
90

Vous pouvez spécifier autant de références d’assembly que vous le souhaitez dans un script.

Chargement d’autres scripts

Lorsque vous créez des scripts, il peut souvent être utile d’utiliser différents scripts pour différentes tâches. Parfois, vous souhaiterez peut-être réutiliser du code d’un script dans un autre. Au lieu de copier-coller son contenu dans votre fichier, vous pouvez simplement le charger et l’évaluer avec #load.

Considérez Script1.fsx :

let square x = x * x

Et le fichier consommateur, Script2.fsx :

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Vous pouvez évaluer Script2.fsx comme suit :

dotnet fsi Script2.fsx
144

Vous pouvez spécifier autant de directives #load que vous le souhaitez dans un script.

module MyScriptLibrary

Utilisation de l’objet fsi dans le code F#

Les scripts F# ont accès à un objet fsi personnalisé qui représente la session interactive F#. Il vous permet de personnaliser des éléments tels que la mise en forme de sortie. Il s’agit également de la façon dont vous pouvez accéder aux arguments de ligne de commande.

L’exemple suivant montre comment obtenir et utiliser des arguments de ligne de commande :

let args = fsi.CommandLineArgs

for arg in args do
    printfn $"{arg}"

Lorsqu’elle est évaluée, elle imprime tous les arguments. Le premier argument est toujours le nom du script évalué :

dotnet fsi Script1.fsx hello world from fsi
Script1.fsx
hello
world
from
fsi

Vous pouvez également utiliser System.Environment.GetCommandLineArgs() pour accéder aux mêmes arguments.

Informations de référence sur les directives F# Interactive

Les directives #r et #load affichées précédemment ne sont disponibles que dans F# Interactive. Il existe plusieurs directives uniquement disponibles dans F# Interactive :

[^1] : Plus d’informations sur les extensions interactives F#.

Lorsque vous spécifiez des fichiers ou des chemins d'accès dans F# Interactive, un littéral de chaîne est attendu. Par conséquent, les fichiers et les chemins doivent être entre guillemets, et les caractères d’échappement habituels s’appliquent. En outre, vous pouvez utiliser le caractère @ pour que F# Interactive interprète une chaîne qui contient un chemin d’accès comme chaîne verbatim. Dans ce cas, F# Interactive ignore les caractères d'échappement.

Dans d’autres cas, les guillemets sont facultatifs, en commençant par F# 9.

Directive #help étendue

La directive #help prend désormais en charge l’affichage de la documentation pour des fonctions spécifiques. Vous pouvez transmettre directement le nom de la fonction pour récupérer les détails.

#help List.map;;

La sortie est la suivante :

Description:
Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection.

Parameters:
- mapping: The function to transform elements from the input list.
- list: The input list.

Returns:
The list of transformed elements.

Examples:
let inputs = [ "a"; "bbb"; "cc" ]

inputs |> List.map (fun x -> x.Length)
// Evaluates to [ 1; 3; 2 ]

Full name: Microsoft.FSharp.Collections.ListModule.map
Assembly: FSharp.Core.dll

Cette amélioration facilite l’exploration et la compréhension interactive des bibliothèques F#.

Pour plus d’informations, reportez-vous au blog de développement officiel .

Directives de préprocesseur interactives et compilées

Lorsque vous compilez du code en F# Interactive, que vous exécutiez interactivement ou exécutez un script, le symbole interactive est défini. Lorsque vous compilez du code dans le compilateur, le symbole COMPILÉ est défini. Par conséquent, si le code doit être différent dans les modes compilés et interactifs, vous pouvez utiliser ces directives de préprocesseur pour la compilation conditionnelle pour déterminer qui utiliser. Par exemple:

#if INTERACTIVE
// Some code that executes only in FSI
// ...
#endif

Utilisation de F# Interactive dans Visual Studio

Pour exécuter F# Interactive via Visual Studio, vous pouvez cliquer sur le bouton de barre d’outils approprié intitulé F# Interactive, ou utiliser les touches Ctrl+Alt+F. La fenêtre interactive, fenêtre Outil exécutant une session F# Interactive, s'affiche. Vous pouvez également sélectionner du code que vous souhaitez exécuter dans la fenêtre interactive et appuyer sur la combinaison de touches Alt+Entrée. F# Interactive démarre dans une fenêtre d’outil intitulée F# Interactive. Lorsque vous utilisez cette combinaison de touches, vérifiez que la fenêtre de l’éditeur a le focus.

Que vous utilisiez la console ou Visual Studio, une invite de commandes s’affiche et l’interpréteur attend votre entrée. Vous pouvez entrer du code comme vous le feriez dans un fichier de code. Pour compiler et exécuter le code, entrez deux points-virgules (;;) pour arrêter une ligne ou plusieurs lignes d’entrée.

F# Interactive tente de compiler le code et, s’il réussit, il exécute le code et imprime la signature des types et des valeurs qu’il a compilés. Si des erreurs se produisent, l’interpréteur imprime les messages d’erreur.

Le code entré dans la même session a accès à toutes les constructions entrées précédemment. Vous pouvez donc créer des programmes. Une mémoire tampon étendue dans la fenêtre outil vous permet de copier le code dans un fichier si nécessaire.

Lors de l’exécution dans Visual Studio, F# Interactive s’exécute indépendamment de votre projet. Par exemple, vous ne pouvez pas utiliser de constructions définies dans votre projet dans F# Interactive, sauf si vous copiez le code de la fonction dans la fenêtre interactive.

Vous pouvez contrôler les arguments de ligne de commande interactive F# (options) en ajustant les paramètres. Dans le menu Outils, sélectionnez Options, puis développez Outils F#. Les deux paramètres que vous pouvez modifier sont les options F# Interactive et le paramètre F# Interactive 64 bits, ce qui est pertinent uniquement si vous utilisez F# Interactive sur une machine 64 bits. Ce paramètre détermine si vous souhaitez exécuter la version 64 bits dédiée de fsi.exe ou de fsianycpu.exe, qui utilise l’architecture de l’ordinateur pour déterminer s’il faut s’exécuter en tant que processus 32 bits ou 64 bits.

Articles connexes