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 de opdracht uit dotnet fsi. U vindt dotnet fsi deze in elke .NET SDK.

Zie F# Interactive Options voor 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 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 beëindigd met een dubbele puntkomma (;;) die moet worden geëvalueerd
2. Code wordt geëvalueerd en opgeslagen in een it waarde. U kunt interactief verwijzen it .

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 de code vervolgens 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. Ter ondersteuning van normale codebewerking kunt u F#-scripts schrijven.

Scripts gebruiken de bestandsextensie .fsx. In plaats van broncode te compileren en vervolgens 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 wordt 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, Visual Studio Code en Visual Studio voor Mac.

Verwijzingen naar pakketten in F# Interactive

Notitie

Pakketbeheersysteem is uitbreidbaar.

F# Interactive biedt ondersteuning voor 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 gebruikt. Als u wilt verwijzen naar een specifieke versie, 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 #i opdracht. In het volgende voorbeeld wordt een externe en lokale bron opgegeven:

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

Dit vertelt de oplossingsengine onder de dekking om ook rekening te houden 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 gebruikmaken van frameworkverwijzingen (bijvoorbeeldMicrosoft.NET.Sdk.WebMicrosoft.NET.Sdk.WindowsDesktop). Pakketten zoals Saturnus, Giraf, WinForms zijn niet beschikbaar. Dit wordt bijgehouden in probleem 9417.

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 ook de #r syntaxis gebruiken om een assembly op te geven. Houd rekening met 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 dat als volgt wordt genoemd Script.fsx :

#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 in uw bestand te kopiëren, kunt u het gewoon 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 dit als volgt evalueren Script2.fsx :

dotnet fsi Script2.fsx
144

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

Notitie

De open Script1 declaratie 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 de naam van de impliciete module, wordt de naam van de impliciete module automatisch in hoofdletters geplaatst en moet u dit gebruiken open Script3. Als u een loadable-script wilt gebruiken om constructies in een specifieke naamruimte van de module te definiëren, kunt u een naamruimte van moduledeclaratie opnemen, bijvoorbeeld:

module MyScriptLibrary

fsi Het 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 de evaluatie wordt uitgevoerd, 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 dezelfde argumenten gebruiken System.Environment.GetCommandLineArgs() .

Naslaginformatie over interactieve F#-instructie

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

Richtlijn	Description
#r "nuget:..."	Verwijst naar een pakket van NuGet
#r "assembly-name.dll"	Verwijst naar een assembly op schijf
#load "file-name.fsx"	Hiermee wordt een bronbestand gelezen, gecompileerd en uitgevoerd.
#help	Geeft informatie weer over beschikbare instructies.
#I	Hiermee geeft u een assemblyzoekpad tussen aanhalingstekens.
#quit	Hiermee wordt een interactieve F#-sessie beëindigd.
#time "on" of #time "off"	#time Hiermee schakelt u zelf in of u prestatiegegevens wilt weergeven. Wanneer dit het is "on", meet F# Interactive realtime, CPU-tijd en garbagecollection-informatie voor elke sectie met code die wordt geïnterpreteerd en uitgevoerd.

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 escape-tekens van toepassing. U kunt het @ teken gebruiken om ervoor te zorgen dat F# Interactive een tekenreeks interpreteert die een pad bevat als een exacte tekenreeks. Dit zorgt ervoor dat F# Interactive escape-tekens negeert.

Interactieve en gecompileerde preprocessorrichtlijnen

Wanneer u code compileert in F# Interactive, ongeacht of u interactief of een script uitvoert, wordt het symbool INTERACTIVE gedefinieerd. Wanneer u code compileert in de compiler, wordt het symbool COMPILED 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# Interactive of gebruikt u de toetsen Ctrl+Alt+F. Als u dit doet, wordt het interactieve venster geopend, een taakvenster waarop een F# Interactive-sessie wordt uitgevoerd. U kunt ook code selecteren die u wilt uitvoeren in het interactieve venster en op alt +Enter drukken. 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 door de interpreter afgedrukt.

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

Wanneer F# Interactive wordt uitgevoerd in Visual Studio, wordt dit 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# Interactive-opdrachtregelargumenten (opties) beheren door de instellingen aan te passen. Selecteer Opties in het menu Extra...en vouw vervolgens F#-hulpprogramma's uit. De twee instellingen die u kunt wijzigen, zijn de interactieve F#-opties en de 64-bits F#Interactieve instelling, 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
Interactieve F#-opties	Beschrijft de opdrachtregelsyntaxis en opties voor F# Interactive, fsi.exe.