Interaktivní programování pomocí F#

F# Interactive (dotnet fsi) slouží ke interaktivnímu spuštění kódu F# v konzole nebo ke spouštění skriptů jazyka F#. Jinými slovy, F# interactive spustí REPL (Read, Evaluate, Print Loop) pro F#.

Pokud chcete spustit F# Interactive z konzoly, spusťte dotnet fsi. V libovolné sadě .NET SDK najdete dotnet fsi.

Informace o dostupných možnostech příkazového řádku najdete v tématu F# Interactive Options.

Spuštění kódu přímo v F# Interactive

Protože F# Interactive je REPL (smyčka read-eval-print), můžete v ní interaktivně spouštět kód. Tady je příklad interaktivní relace po spuštění dotnet fsi z příkazového řádku:

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

Všimněte si dvou hlavních věcí:

1. Veškerý kód musí být ukončen dvojitým středníkem (;;), který se má vyhodnotit.
2. Kód se vyhodnotí a uloží do hodnoty it. Můžete odkazovat na it interaktivně.

F# Interactive také podporuje víceřádkový vstup. Stačí ukončit odeslání dvojitým středníkem (;;). Podívejte se na následující fragment kódu, který byl vložen a vyhodnocen jazykem 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 = ()

>

Formátování kódu je zachováno a vstup ukončuje dvojitý středník (;;). F# Interactive pak vyhodnotil kód a vytiskl výsledky.

Skriptování pomocí F#

Vyhodnocení kódu interaktivně v F# Interactive může být skvělý výukový nástroj, ale rychle zjistíte, že není tak produktivní jako psaní kódu v normálním editoru. Pokud chcete podporovat normální úpravy kódu, můžete psát skripty jazyka F#.

Skripty používají příponu souboru .fsx. Místo kompilace zdrojového kódu a následného spuštění kompilovaného sestavení můžete spustit dotnet fsi a zadat název souboru skriptu zdrojového kódu jazyka F# a jazyk F# interactive kód přečte a spustí ho v reálném čase. Představte si například následující skript s názvem Script.fsx:

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

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

Když se tento soubor vytvoří ve vašem počítači, můžete ho spustit s dotnet fsi a zobrazit výstup přímo v okně terminálu:

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

Skriptování jazyka F# je nativně podporováno v sadě Visual Studio a Visual Studio Code.

Odkazování na balíčky v F# Interactive

Vzhledem k tomu, že verze jazyka 5.0, jazyk F# Interactive podporuje odkazování balíčků prostřednictvím mechanismu rozšiřitelnosti; Kromě toho může odkazovat na balíčky NuGet se syntaxí #r "nuget:" a volitelnou verzí:

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

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

Pokud není zadaná verze, převezme se nejvyšší dostupný balíček bez verze Preview. Pokud chcete odkazovat na konkrétní verzi, představte si verzi čárkou. To může být užitečné při odkazování na verzi Preview balíčku. Představte si například tento skript pomocí verze Preview 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)}"

Určení zdroje balíčku

Zdroj balíčku můžete také zadat pomocí příkazu #i. Následující příklad určuje vzdálený a místní zdroj:

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

To modulu pro řešení v rámci krytů řekne, aby také zohlednil vzdálené a/nebo místní zdroje přidané do skriptu.

Ve skriptu můžete zadat libovolný počet odkazů na balíčky.

Odkazování na sestavení na disku pomocí F# Interactive

Pokud máte na disku sestavení a chcete na ni odkazovat ve skriptu, můžete k určení sestavení použít syntaxi #r. Zvažte následující kód v projektu zkompilovaném do MyAssembly.dll:

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

Po kompilaci na něj můžete odkazovat v souboru s názvem Script.fsx takto:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

Výstup je následující:

dotnet fsi Script.fsx
90

Ve skriptu můžete zadat libovolný počet odkazů na sestavení.

Načítání dalších skriptů

Při skriptování může být často užitečné použít různé skripty pro různé úlohy. Někdy můžete chtít znovu použít kód z jednoho skriptu v jiném. Místo zkopírování obsahu do souboru ho můžete jednoduše načíst a vyhodnotit pomocí #load.

Zvažte následující Script1.fsx:

let square x = x * x

A spotřeba souboru, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Můžete vyhodnotit Script2.fsx takto:

dotnet fsi Script2.fsx
144

Ve skriptu můžete zadat libovolný počet direktiv #load.

module MyScriptLibrary

Použití objektu fsi v kódu jazyka F#

Skripty jazyka F# mají přístup k vlastnímu objektu fsi, který představuje relaci F# Interactive. Umožňuje přizpůsobit věci, jako je formátování výstupu. Je to také způsob, jak získat přístup k argumentům příkazového řádku.

Následující příklad ukazuje, jak získat a používat argumenty příkazového řádku:

let args = fsi.CommandLineArgs

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

Při vyhodnocování vytiskne všechny argumenty. První argument je vždy název skriptu, který se vyhodnotí:

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

Můžete také použít System.Environment.GetCommandLineArgs() pro přístup ke stejným argumentům.

Referenční informace k direktivě F# Interactive

Direktivy #r a #load, které jsme viděli dříve, jsou dostupné pouze v jazyce F# Interactive. V jazyce F# Interactive je k dispozici výhradně několik specifických direktiv:

[^1]: Další informace o rozšířeních pro F# Interactive .

Při zadávání souborů nebo cest ve F# Interactive se očekává zadání řetězcového literálu. Proto musí být soubory a cesty v uvozovkách a použijí se obvyklé escape sekvence. Znak @ můžete použít k tomu, aby jazyk F# Interactive interpretoval řetězec, který obsahuje cestu jako doslovný řetězec. To způsobí, že F# Interactive ignoruje všechny escape sekvence.

V jiných případech jsou uvozovky volitelné, počínaje F# 9.

Rozšířená direktiva #help

Direktiva #help teď podporuje zobrazení dokumentace pro konkrétní funkce. Název funkce můžete předat přímo k získání podrobností.

#help List.map;;

Výstup je následující:

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

Díky tomuto vylepšení můžete interaktivně prozkoumat a pochopit knihovny jazyka F#.

Další podrobnosti najdete v oficiálním devblogu.

Interaktivní a kompilované direktivy preprocesoru

Při kompilaci kódu v jazyce F# Interactive bez ohledu na to, jestli spouštíte interaktivně nebo spouštíte skript, je definován symbol INTERACTIVE. Při kompilaci kódu v kompilátoru je definován symbol COMPILED. Pokud se tedy kód musí lišit v kompilovaných a interaktivních režimech, můžete použít tyto direktivy preprocesoru pro podmíněnou kompilaci k určení, které použít. Například:

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

Použití F# Interactive v prostředí Visual Studio

Pokud chcete spustit F# Interactive prostřednictvím sady Visual Studio, můžete kliknout na příslušné tlačítko panelu nástrojů s popiskem F# Interactivenebo použít klávesy Ctrl+Alt+F. Tím se otevře interaktivní okno, nástrojové okno se spuštěnou relací F# Interactive. Můžete také vybrat nějaký kód, který chcete spustit v interaktivním okně, a stisknout kombinaci kláves Alt+Enter. F# Interactive začíná v okně nástroje označeném F# Interactive. Při použití této kombinace kláves se ujistěte, že okno editoru má fokus.

Ať už používáte konzolu nebo Sadu Visual Studio, zobrazí se příkazový řádek a interpret čeká na váš vstup. Kód můžete zadat stejně jako v souboru kódu. Pokud chcete kód zkompilovat a spustit, zadejte dva středníky (;;) a ukončete řádek nebo několik řádků vstupu.

F# Interactive se pokusí kód zkompilovat a v případě úspěchu kód spustí a vytiskne podpis typů a hodnot, které zkompiloval. Pokud dojde k chybám, interpret vytiskne chybové zprávy.

Kód zadaný ve stejné relaci má přístup ke všem konstrukcím zadaným dříve, takže můžete vytvářet programy. Pokud je to potřeba, rozsáhlá vyrovnávací paměť v okně nástroje vám umožní zkopírovat kód do souboru.

Při spuštění v sadě Visual Studio běží F# Interactive nezávisle na projektu, takže například nelze použít konstruktory definované v projektu v F# Interactive, pokud kód pro funkci nekopírujete do interaktivního okna.

Argumenty příkazového řádku F# Interactive (možnosti) můžete řídit úpravou nastavení. V nabídce Nástroje vyberte Možnosti...a potom rozbalte nástroje F#. Dvě nastavení, která můžete změnit, jsou možnosti F# Interactive a 64bitové nastavení F# Interactive, které je relevantní jenom v případě, že používáte F# Interactive na 64bitovém počítači. Toto nastavení určuje, zda chcete spustit vyhrazenou 64bitovou verzi fsi.exe nebo fsianycpu.exe, která používá architekturu počítače k určení, zda se má spustit jako 32bitový nebo 64bitový proces.

Související články