Interactief programmeren met F#

F# Interactive (dotnet fsi) wordt gebruikt om F#-code interactief uit te voeren op de console of om F#-scripts uit te voeren. Met andere woorden, F#interactive voert een REPL (Read, Evaluate, Print Loop) uit voor F#.

Als u F# Interactive wilt uitvoeren vanuit de console, voert u dotnet fsiuit. U vindt dotnet fsi in een .NET SDK.

Notitie

Als u van plan bent om F# interactief te gebruiken onder .NET Framework Runtime, hebt u de Visual Studio Build Tools of een editie van Visual Studio geïnstalleerd en roept u de FsiAnyCPU.exe-opdracht aan vanaf een opdrachtprompt voor ontwikkelaars of maakt u FsiAnyCPU.exe beschikbaar in de omgevingsvariabele van PATH, in plaats van dotnet fsi opdrachtregel.

Tooling ondersteunt het definiëren van F# Interactive runtime-versies.

• In Visual Studio: Tools / Options vervolgens F# Tools / F# Interactiveen pas .NET Core Scriptinggebruiken aan.
• In Visual Studio Code (ionide-extensie): In het opdrachtenpalet Voorkeuren: Gebruikersinstellingen openenen Extensies / F# / FSharp: Fsi Sdk-bestandspad.

Zie F# Interactive Optionsvoor meer informatie over beschikbare opdrachtregelopties.

Code rechtstreeks uitvoeren in F# Interactive

Omdat F# Interactive een REPL (read-eval-print-lus) is, kunt u er interactief code in uitvoeren. Hier volgt een voorbeeld van een interactieve sessie na het uitvoeren van dotnet fsi vanaf de opdrachtregel:

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 = ()

U ziet twee belangrijke dingen:

1. Alle code moet worden afgesloten met een dubbele puntkomma (;;) om geëvalueerd te worden.
2. Code wordt geëvalueerd en opgeslagen in een it-waarde. U kunt interactief naar it verwijzen.

F# Interactive ondersteunt ook invoer met meerdere regels. U hoeft uw inzending alleen te beëindigen met een dubbele puntkomma (;;). Bekijk het volgende fragment dat is geplakt en geëvalueerd door 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 = ()

>

De opmaak van de code blijft behouden en er is een dubbele puntkomma (;;) waarmee de invoer wordt beëindigd. F# Interactive heeft vervolgens de code geëvalueerd en de resultaten afgedrukt!

Scripts uitvoeren met F#

Het interactief evalueren van code in F# Interactive kan een geweldig leerhulpmiddel zijn, maar u zult snel merken dat het niet zo productief is als het schrijven van code in een normale editor. Als u normale codebewerking wilt ondersteunen, kunt u F#-scripts schrijven.

Scripts gebruiken de bestandsextensie .fsx-. In plaats van broncode te compileren en vervolgens later de gecompileerde assembly uit te voeren, kunt u gewoon dotnet fsi- uitvoeren en de bestandsnaam van het script van de F#-broncode opgeven, en F# interactief leest de code en voert deze in realtime uit. Denk bijvoorbeeld aan het volgende script met de naam Script.fsx:

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

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

Wanneer dit bestand op uw computer is gemaakt, kunt u het uitvoeren met dotnet fsi en de uitvoer rechtstreeks in het terminalvenster bekijken:

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

F#-scripts worden systeemeigen ondersteund in Visual Studio en Visual Studio Code.

Verwijzen naar pakketten in F# Interactive

Notitie

Pakketbeheersysteem is uitbreidbaar, zie meer over de plug-ins en uitbreidingsmechanisme.

Sinds 5.0 versie van de taal ondersteunt F# Interactive verwijzingen naar pakketten via een uitbreidbaarheidsmechanisme; Standaard kan het verwijzen naar NuGet-pakketten met de #r "nuget:" syntaxis en een optionele versie:

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

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

Als er geen versie is opgegeven, wordt het hoogst beschikbare niet-preview-pakket genomen. Als u naar een specifieke versie wilt verwijzen, introduceert u de versie via een komma. Dit kan handig zijn wanneer u verwijst naar een preview-versie van een pakket. Denk bijvoorbeeld aan dit script met behulp van een preview-versie van 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)}"

Een pakketbron opgeven

U kunt ook een pakketbron opgeven met de opdracht #i. In het volgende voorbeeld wordt een externe en een lokale bron opgegeven:

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

Dit zorgt ervoor dat de resolutie-engine achter de schermen ook rekening houdt met de externe en/of lokale bronnen die aan een script zijn toegevoegd.

U kunt zoveel pakketverwijzingen opgeven als u wilt in een script.

Notitie

Er is momenteel een beperking voor scripts die frameworkverwijzingen gebruiken (bijvoorbeeldMicrosoft.NET.Sdk.Web of Microsoft.NET.Sdk.WindowsDesktop). Pakketten zoals Saturnus, Giraf, WinForms zijn niet beschikbaar. Dit wordt bijgehouden in kwestie #9417. WinForms werkt nog steeds in de .NET Framework-versie van F# Interactive.

Als u extra extensies wilt laden naast extensies die zijn geleverd met de SDK en/of met uw hulpprogramma's, gebruikt u de vlag --compilertool:<extensionsfolderpath> als argument voor de interactieve F#-sessie (of in uw hulpprogramma-instellingen).

Verwijzen naar assembly's op schijf met F# interactief

Als u een assembly op schijf hebt en ernaar wilt verwijzen in een script, kunt u de #r syntaxis gebruiken om een assembly op te geven. Bekijk de volgende code in een project dat is gecompileerd in MyAssembly.dll:

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

Zodra het is gecompileerd, kunt u ernaar verwijzen in een bestand met de naam Script.fsx als volgt:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

De uitvoer is als volgt:

dotnet fsi Script.fsx
90

U kunt zoveel assemblyverwijzingen opgeven als u wilt in een script.

Andere scripts laden

Bij het uitvoeren van scripts kan het vaak handig zijn om verschillende scripts voor verschillende taken te gebruiken. Soms wilt u mogelijk code uit het ene script in het andere opnieuw gebruiken. In plaats van de inhoud ervan naar uw bestand te kopiëren, kunt u deze eenvoudig laden en evalueren met #load.

Houd rekening met het volgende Script1.fsx:

let square x = x * x

En het verbruikende bestand, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

U kunt Script2.fsx als volgt evalueren:

dotnet fsi Script2.fsx
144

U kunt in een script zo veel #load instructies opgeven als u wilt.

Notitie

De declaratie open Script1 is vereist. Dit komt doordat constructies in een F#-script worden gecompileerd in een module op het hoogste niveau die de naam is van het scriptbestand waarin het zich bevindt. Als het scriptbestand een kleine naam heeft, zoals script3.fsx, wordt de naam van de impliciete module automatisch in hoofdletters geplaatst en moet u open Script3gebruiken. Als u een laadbaar script wilt gebruiken om constructies te definiëren in een specifieke naamruimte van de module, kunt u een naamruimte met moduledeclaratie opnemen, bijvoorbeeld:

module MyScriptLibrary

Het fsi-object gebruiken in F#-code

F#-scripts hebben toegang tot een aangepast fsi-object dat de F# Interactive-sessie vertegenwoordigt. Hiermee kunt u zaken zoals uitvoeropmaak aanpassen. Het is ook hoe u toegang hebt tot opdrachtregelargumenten.

In het volgende voorbeeld ziet u hoe u opdrachtregelargumenten kunt ophalen en gebruiken:

let args = fsi.CommandLineArgs

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

Wanneer deze wordt geëvalueerd, worden alle argumenten afgedrukt. Het eerste argument is altijd de naam van het script dat wordt geëvalueerd:

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

U kunt ook System.Environment.GetCommandLineArgs() gebruiken om toegang te krijgen tot dezelfde argumenten.

Naslaginformatie over F# Interactive-richtlijnen

De #r- en #load instructies die eerder zijn gezien, zijn alleen beschikbaar in F# Interactive. Er zijn alleen verschillende richtlijnen beschikbaar in F# Interactive:

Richtlijn	Beschrijving
#r "nuget:..."	Verwijst naar een pakket van NuGet
#r "extname:..."	Verwijzen naar een pakket uit extname-extensie[^1] (zoals paket)
#r "assembly-name.dll"	Verwijst naar een assembly op schijf
#load "file-name.fsx"	Leest een bronbestand, compileert het en voert het uit.
#help	Geeft informatie weer over beschikbare instructies of documentatie voor specifieke functies.
#I	Geeft een zoekpad voor de assembly op tussen aanhalingstekens.
#quit	Hiermee wordt een interactieve F#-sessie beëindigd.
#time on of #time off	Op zichzelf schakelt #time of prestatiegegevens moeten worden weergegeven. Wanneer de instelling onis, meet F# Interactive realtime, CPU-tijd en informatie over geheugenvrijgave voor elke codesectie die wordt geïnterpreteerd en uitgevoerd.

[^1]: Meer informatie over F# Interactieve extensies.

Wanneer u bestanden of paden opgeeft in F# Interactive, wordt een letterlijke tekenreeks verwacht. Daarom moeten bestanden en paden tussen aanhalingstekens staan en zijn de gebruikelijke escapetekens van toepassing. U kunt het @ teken gebruiken om ervoor te zorgen dat F# Interactive een tekenreeks interpreteert die een pad bevat als een verbatimtekenreeks. Dit zorgt ervoor dat F# Interactive escape-tekens negeert.

Voor andere gevallen zijn aanhalingstekens optioneel, te beginnen met F# 9.

Uitgebreide #help richtlijn

De #help-instructie ondersteunt nu het weergeven van documentatie voor specifieke functies. U kunt de naam van de functie rechtstreeks doorgeven om details op te halen.

#help List.map;;

De uitvoer is als volgt:

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

Deze verbetering maakt het eenvoudiger om F#-bibliotheken interactief te verkennen en te begrijpen.

Raadpleeg de officiële devblogvoor meer informatie.

Interactieve en gecompileerde preprocessorrichtlijnen

Wanneer u code compileert in F# Interactive, of u nu interactief of een script uitvoert, wordt het symbool INTERACTIVE gedefinieerd. Wanneer u code compileert in de compiler, wordt het symbool GECOMPILEERD gedefinieerd. Als code dus anders moet zijn in gecompileerde en interactieve modi, kunt u deze preprocessorrichtlijnen voor voorwaardelijke compilatie gebruiken om te bepalen welke code moet worden gebruikt. Bijvoorbeeld:

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

F# Interactive gebruiken in Visual Studio

Als u F# Interactive wilt uitvoeren via Visual Studio, klikt u op de juiste werkbalkknop met het label F# Interactiveof gebruikt u de toetsen Ctrl+Alt+F. Als u dit doet, wordt het interactieve venster geopend, een hulpprogrammavenster met een F# Interactive-sessie. U kunt ook een aantal code selecteren die u in het interactieve venster wilt uitvoeren en op de toetsencombinatie Alt+Enterdrukken. F# Interactive wordt gestart in een taakvenster met het label F# Interactive. Wanneer u deze toetsencombinatie gebruikt, moet u ervoor zorgen dat het editorvenster de focus heeft.

Of u nu de console of Visual Studio gebruikt, er wordt een opdrachtprompt weergegeven en de interpreter wacht op uw invoer. U kunt net als in een codebestand code invoeren. Als u de code wilt compileren en uitvoeren, voert u twee puntkomma's (;;) in om een regel of meerdere regels invoer te beëindigen.

F# Interactive probeert de code te compileren en, indien geslaagd, voert de code uit en drukt de handtekening af van de typen en waarden die zijn gecompileerd. Als er fouten optreden, worden de foutberichten afgedrukt door de interpreter.

Code die in dezelfde sessie is ingevoerd, heeft toegang tot alle constructies die eerder zijn ingevoerd, zodat u programma's kunt opbouwen. Met een uitgebreide buffer in het hulpprogrammavenster kunt u de code indien nodig naar een bestand kopiëren.

Bij uitvoering in Visual Studio wordt F# Interactive onafhankelijk van uw project uitgevoerd. U kunt dus geen constructies gebruiken die zijn gedefinieerd in uw project in F# Interactive, tenzij u de code voor de functie kopieert naar het interactieve venster.

U kunt de F# Interactieve opdrachtregelargumenten (opties) beheren door de instellingen aan te passen. Selecteer in het menu ExtraOpties...en vouw F# Extrauit. De twee instellingen die u kunt wijzigen, zijn de interactieve F#-opties en de instelling 64-bits F# Interactive, die alleen relevant is als u F# Interactive uitvoert op een 64-bits computer. Met deze instelling bepaalt u of u de toegewezen 64-bits versie van fsi.exe of fsianycpu.exewilt uitvoeren, die gebruikmaakt van de computerarchitectuur om te bepalen of deze moet worden uitgevoerd als een 32-bits of 64-bits proces.

Verwante artikelen

Titel	Beschrijving
F# Interactieve opties	Beschrijft opdrachtregelsyntaxis en opties voor de F# Interactive, fsi.exe.