Programowanie interakcyjne przy użyciu języka F #

F# Interactive (dotnet fsi) służy do interakcyjnego uruchamiania kodu F# w konsoli lub do wykonywania skryptów języka F#. Innymi słowy, interakcyjny kod F# wykonuje repl (odczyt, ocena, pętla drukowania) dla języka F#.

Aby uruchomić F# Interactive z konsoli programu , uruchom .dotnet fsi Znajdziesz go w dowolnym dotnet fsi zestawie SDK platformy .NET.

Aby uzyskać informacje o dostępnych opcjach wiersza polecenia, zobacz F# Interactive Opcje.

Wykonywanie kodu bezpośrednio w F# Interactive

Ponieważ F# Interactive repl (odczyt-eval-print loop), możesz wykonywać w nim kod interaktywnie. Oto przykład interaktywnej sesji po wykonaniu dotnet fsi z wiersza polecenia:

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

Zauważysz dwie główne rzeczy:

1. Aby można było ocenić cały kod, należy zakończyć go podwójnym średnikiem (;;).
2. Kod jest oceniany i przechowywany w it wartości. Odwołania można odwoływać it się interakcyjnie.

F# Interactive obsługuje również wprowadzanie wielo wierszowe. Wystarczy zakończyć przesyłanie podwójnym średnikiem (;;). Rozważmy następujący fragment kodu, który został wklejony i oceniony przez 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 = ()

>

Formatowanie kodu jest zachowywane, a dane wejściowe są przerywane przez podwójny średnik (;;). F# Interactive następnie ocenić kod i wydrukować wyniki!

Wykonywanie skryptów za pomocą klawisza F #

Interaktywne ocenianie kodu w F# Interactive może być doskonałym narzędziem do nauki, ale szybko przekonasz się, że nie jest on tak produktywny jak pisanie kodu w normalnym edytorze. Aby obsługiwać normalne edytowanie kodu, można pisać skrypty języka F#.

Skrypty używają rozszerzenia pliku fsx. Zamiast kompilować kod źródłowy, a następnie uruchamiać skompilowany zestaw, możesz po prostu uruchomić polecenie dotnet fsi i określić nazwę pliku skryptu kodu źródłowego języka F#, a interaktywny język F# odczytuje kod i wykonuje go w czasie rzeczywistym. Rozważmy na przykład następujący skrypt o nazwie Script.fsx:

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

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

Po utworzeniu tego pliku na maszynie możesz dotnet fsi uruchomić go za pomocą polecenia i wyświetlić dane wyjściowe bezpośrednio w oknie terminalu:

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

Skrypty języka F# są natywnie obsługiwane Visual Studio, Visual Studio Code i Visual Studio dla komputerów Mac.

Odwoływanie się do pakietów w programie F# Interactive

Uwaga

System zarządzania pakietami jest rozszerzalny.

F# Interactive obsługuje odwoływanie NuGet pakietów ze składnią #r "nuget:" i opcjonalną wersją:

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

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

Jeśli wersja nie zostanie określona, zostanie wyświetlony najwyższy dostępny pakiet bez wersji zapoznawczej. Aby odwołać się do określonej wersji, wprowadź wersję za pośrednictwem przecinka. Może to być przydatne podczas odwoływania się do wersji zapoznawczej pakietu. Rozważmy na przykład ten skrypt przy użyciu wersji zapoznawczej 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)}"

Określanie źródła pakietu

Źródło pakietu można również określić za pomocą #i polecenia . W poniższym przykładzie określono źródło zdalne i lokalne:

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

Dzięki temu aparat rozpoznawania będzie pod osłoną uwzględniał również źródła zdalne i/lub lokalne dodane do skryptu.

W skrypcie można określić tyle odwołań do pakietów, ile chcesz.

Uwaga

Obecnie istnieje ograniczenie dotyczące skryptów, które używają odwołań do struktury (np.Microsoft.NET.Sdk.Web lub Microsoft.NET.Sdk.WindowsDesktop). Pakiety, takie jak Giraffe, WinForms, nie są dostępne. Jest to śledzone w problemie nr 9417.

Odwoływanie się do zestawów na dysku za pomocą interakcyjnego języka F#

Alternatywnie, jeśli masz zestaw na dysku i chcesz odwoływać się do tego w skrypcie, #r możesz użyć składni , aby określić zestaw. Rozważmy następujący kod w projekcie skompilowanym w programie MyAssembly.dll:

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

Po skompilowanym pliku można odwoływać się do niego w taki Script.fsx sposób:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

Wynik jest następujący:

dotnet fsi Script.fsx
90

W skrypcie można określić tyle odwołań do zestawu, ile chcesz.

Ładowanie innych skryptów

Podczas wykonywania skryptów często pomocne może być użycie różnych skryptów do różnych zadań. Czasami możesz chcieć ponownie użyć kodu z jednego skryptu w innym. Zamiast kopiować jego zawartość do pliku, możesz po prostu załadować i ocenić ją za pomocą .#load

Rozważ następujące kwestie Script1.fsx:

let square x = x * x

A plik konsumowanie: Script2.fsx

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Możesz ocenić w Script2.fsx ten sposób:

dotnet fsi Script2.fsx
144

W skrypcie #load można określić tyle dyrektyw, ile chcesz.

Uwaga

Deklaracja open Script1 jest wymagana. Wynika to z tego, że konstrukcje w skrypcie języka F# są kompilowane do modułu najwyższego poziomu, który jest nazwą pliku skryptu, w nim znajduje się. Jeśli plik skryptu ma małą nazwę, script3.fsx taką jak , nazwa niejawnego modułu jest automatycznie wielkich liter i należy użyć open Script3. Jeśli skrypt z obciążeniem ma definiować konstrukcje w określonej przestrzeni nazw modułu, możesz dołączyć przestrzeń nazw deklaracji modułu, na przykład:

module MyScriptLibrary

Używanie obiektu fsi w kodzie F#

Skrypty języka F# mają dostęp do niestandardowego obiektu fsi reprezentującego F# Interactive sesji. Umożliwia dostosowywanie elementów, takich jak formatowanie danych wyjściowych. Jest to również sposób uzyskiwania dostępu do argumentów wiersza polecenia.

W poniższym przykładzie pokazano, jak pobrać i użyć argumentów wiersza polecenia:

let args = fsi.CommandLineArgs

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

Po ocenie wszystkie argumenty są wypisyty. Pierwszy argument to zawsze nazwa ocenianego skryptu:

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

Możesz również użyć polecenia , System.Environment.GetCommandLineArgs() aby uzyskać dostęp do tych samych argumentów.

F# Interactive dyrektywy

Wcześniej #r widoczne dyrektywy i #load są dostępne tylko w F# Interactive. Istnieje kilka dyrektyw dostępnych tylko w F# Interactive:

Dyrektywy	Opis
#r "nuget:..."	Odwołuje się do pakietu z NuGet
#r "assembly-name.dll"	Odwołuje się do zestawu na dysku
#load "file-name.fsx"	Odczytuje plik źródłowy, kompiluje go i uruchamia.
#help	Wyświetla informacje o dostępnych dyrektywach.
#I	Określa ścieżkę wyszukiwania zestawu w cudzysłowie.
#quit	Kończy sesję F# Interactive użytkownika.
#time "on" lub #time "off"	Samodzielnie przełącza, #time czy mają być wyświetlane informacje o wydajności. Gdy jest, "on"F# Interactive mierzy informacje o czasie rzeczywistym, czasie procesora CPU i odśmiecaniu pamięci dla każdej sekcji kodu, która jest interpretowana i wykonywana.

Po określeniu plików lub ścieżek w F# Interactive jest oczekiwany literał ciągu. W związku z tym pliki i ścieżki muszą znajdować się w cudzysłowie i mają zastosowanie zwykłe znaki ucieczki. Możesz użyć znaku , @ aby F# Interactive interpretować ciąg zawierający ścieżkę jako ciąg dosłowny. Powoduje to F# Interactive wszystkich znaków ucieczki.

Interaktywne i skompilowane dyrektywy preprocesora

Podczas kompilowania kodu w F# Interactive, niezależnie od tego, czy uruchamiasz skrypt interaktywnie, czy skrypt, definiowany jest symbol INTERACTIVE . Podczas kompilowania kodu w kompilatorze jest definiowany symbol SKOMPILOWANY . W związku z tym, jeśli kod musi się różnić w trybach skompilowanym i interaktywnym, można użyć tych dyrektyw preprocesora do kompilacji warunkowej, aby określić, którego z nich użyć. Na przykład:

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

Korzystanie F# Interactive w programie Visual Studio

Aby uruchomić F# Interactive za pośrednictwem Visual Studio, możesz kliknąć odpowiedni przycisk paska narzędzi z etykietą F# Interactive lub użyć klawiszy Ctrl+Alt+F. Spowoduje to otwarcie okna interaktywnego, czyli okna narzędzi z F# Interactive sesji. Możesz również wybrać kod, który chcesz uruchomić w oknie interaktywnym, i naciśnij kombinację klawiszy Alt+Enter. F# Interactive uruchamia się w oknie narzędzi z etykietą F# Interactive. Korzystając z tej kombinacji klawiszy, upewnij się, że okno edytora ma fokus.

Niezależnie od tego, czy używasz konsoli, czy Visual Studio, zostanie wyświetlony wiersz polecenia, a interpreter oczekuje na dane wejściowe. Możesz wprowadzić kod tak samo jak w pliku kodu. Aby skompilować i wykonać kod, wprowadź dwa średniki (;;), aby zakończyć wiersz lub kilka wierszy danych wejściowych.

F# Interactive próbuje skompilować kod i, jeśli to się powiedzie, wykonuje kod i drukuje podpis typów i wartości, które skompilował. Jeśli wystąpią błędy, interpreter drukuje komunikaty o błędach.

Kod wprowadzony w tej samej sesji ma dostęp do wszystkich konstrukcji wprowadzonych wcześniej, dzięki czemu można tworzyć programy. Rozbudowany bufor w oknie narzędzi umożliwia skopiowanie kodu do pliku w razie potrzeby.

Po uruchomieniu w programie Visual Studio program F# Interactive działa niezależnie od projektu, więc na przykład nie można używać konstrukcji zdefiniowanych w projekcie w programie F# Interactive chyba że skopiujemy kod funkcji do okna interaktywnego.

Możesz kontrolować F# Interactive wiersza polecenia (opcje), dostosowując ustawienia. W menu Narzędzia wybierz pozycję Opcje..., a następnie rozwiń pozycję Narzędzia języka F#. Dwa ustawienia, które można zmienić, to opcje F# Interactive i 64-bitowe ustawienie F# Interactive , które ma zastosowanie tylko w przypadku uruchamiania programu F# Interactive na maszynie 64-bitowej. To ustawienie określa, czy chcesz uruchomić dedykowaną 64-bitową wersję programu fsi.exe , czyfsianycpu.exe, która używa architektury komputera do określenia, czy ma być uruchamiany jako proces 32-bitowy, czy 64-bitowy.

Pokrewne artykuły:

Tytuł	Opis
Opcje interakcyjne F#	Opisuje składnię wiersza polecenia i opcje dla F# Interactive, fsi.exe.