Pemrograman interaktif dengan F#

F# Interactive (dotnet fsi) digunakan untuk menjalankan kode F# secara interaktif di konsol, atau untuk menjalankan skrip F#. Dengan kata lain, F# interaktif menjalankan REPL (Baca, Evaluasi, Cetak Perulangan) untuk F#.

Untuk menjalankan F# Interactive dari konsol, jalankan dotnet fsi. Anda akan menemukan dotnet fsi di .NET SDK apa pun.

Nota

Jika Anda ingin menggunakan F# interaktif di bawah runtime .NET Framework, Anda memerlukan Visual Studio Build Tools atau edisi Visual Studio yang diinstal, dan memanggil FsiAnyCPU.exe perintah dari "Developer Command Prompt" atau hanya menyediakan FsiAnyCPU.exe dalam PATH variabel lingkungan, sebagai pengganti dotnet fsi baris perintah.

Tooling mendukung penentukan runtime interaktif versi F#:

• Di Visual Studio: Di bilah menu,Opsi / lalu Alat F# / F# Interaktif, dan sesuaikan Gunakan .NET Core Scripting.
• Di Visual Studio Code (ekstensi ionida): Di palet perintah, Preferensi: Buka Pengaturan Pengguna, lalu Ekstensi / F# / FSharp: Jalur File Fsi Sdk.

Untuk informasi tentang opsi baris perintah yang tersedia, lihat Opsi Interaktif F#.

Menjalankan kode langsung di F# Interactive

Karena F# Interactive adalah REPL (loop baca-eval-print), Anda dapat menjalankan kode secara interaktif di dalamnya. Berikut adalah contoh sesi interaktif setelah dijalankan dotnet fsi dari baris perintah:

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

Anda akan melihat dua hal utama:

1. Semua kode harus dihentikan dengan titik koma ganda (;;) untuk dievaluasi
2. Kode dievaluasi dan disimpan dalam nilai it . Anda dapat mereferensikan it secara interaktif.

F# Interactive juga mendukung input multibaris. Anda hanya perlu mengakhiri pengiriman Anda dengan titik koma ganda (;;). Pertimbangkan cuplikan berikut yang telah ditempelkan dan dievaluasi oleh 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 = ()

>

Pemformatan kode dipertahankan, dan ada titik koma ganda (;;) yang mengakhiri input. F# Interactive kemudian mengevaluasi kode dan mencetak hasilnya!

Pembuatan skrip dengan F#

Mengevaluasi kode secara interaktif di F# Interactive dapat menjadi alat pembelajaran yang hebat, tetapi Anda akan dengan cepat menemukan bahwa kode tersebut tidak produktif seperti menulis kode di editor normal. Untuk mendukung pengeditan kode normal, Anda dapat menulis skrip F#.

Skrip menggunakan ekstensi file .fsx. Alih-alih mengkompilasi kode sumber dan kemudian menjalankan rakitan yang dikompilasi, Anda hanya dapat menjalankan fsi dotnet dan menentukan nama file skrip, dan F# Interactive membaca kode dan menjalankannya secara real time. Misalnya, pertimbangkan skrip berikut yang disebut Script.fsx:

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

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

Ketika file ini dibuat di komputer Anda, Anda dapat menjalankannya dengan dotnet fsi dan melihat output langsung di jendela terminal Anda:

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

Menjalankan Skrip dengan Shebang

Untuk membuat skrip F# dapat dieksekusi tanpa secara eksplisit memanggil dotnet fsi, Anda dapat menggunakan baris shebang di bagian atas skrip. Ini memungkinkan Anda menjalankan skrip langsung dari terminal, seperti skrip shell.

Misalnya, buat file skrip yang disebut ExecutableScript.fsx dengan konten berikut:

#!/usr/bin/env -S dotnet fsi

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

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

1. Jadikan Skrip Dapat Dieksekusi:chmod Gunakan perintah untuk membuat skrip dapat dieksekusi:

   chmod +x ExecutableScript.fsx
   

2. Jalankan Skrip Secara Langsung: Sekarang, Anda dapat menjalankan skrip langsung dari terminal:

   ./ExecutableScript.fsx
   

Catatan: Fungsionalitas Shebang (#!) khusus untuk sistem seperti Unix seperti Linux dan MacOS. Di Windows, Anda dapat menjalankan skrip menggunakan dotnet fsi Script.fsx langsung di terminal atau prompt perintah.

Fitur ini memungkinkan pengalaman yang lebih mulus saat bekerja dengan skrip F# di lingkungan seperti Linux dan macOS.

Pembuatan skrip F# didukung secara asli di Visual Studio dan Visual Studio Code.

Mereferensikan paket di F# Interactive

Nota

Sistem manajemen paket dapat diperluas, lihat lebih lanjut tentang plugin dan mekanisme ekstensi.

Sejak rilis 5.0 dari bahasa, F# Interactive mendukung referensi paket melalui mekanisme ekstensibilitas; secara default, ini dapat mereferensikan paket NuGet dengan sintaks #r "nuget:" dan versi opsional:

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

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

Jika versi tidak ditentukan, paket non-pratinjau tertinggi yang tersedia akan diambil. Untuk mereferensikan versi tertentu, perkenalkan versi melalui koma. Ini bisa berguna saat mereferensikan versi pratinjau paket. Misalnya, pertimbangkan skrip ini menggunakan versi pratinjau 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)}"

Secara default, #r "nuget: ...." tidak menggunakan target build dari paket yang dirujuk selama pemulihan. Opsi usepackagetargets ini memungkinkan Anda untuk menggunakan target build tersebut saat dibutuhkan. Hanya tambahkan usepackagetargets=true jika paket yang direferensikan ditulis untuk mengharuskannya selama pemulihan. Contoh:

// load fsharp.data nugetpackage and consume buildtargets from fsharp.data package during restore.
#r "nuget:fsharp.data,usepackagetargets=true"
#r "nuget:fsharp.data,6.6.0,usepackagetargets=false"
#r "nuget:fsharp.data,6.6.0,usepackagetargets=true"

Menentukan sumber paket

Anda juga dapat menentukan sumber paket dengan #i perintah . Contoh berikut menentukan sumber jarak jauh dan lokal:

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

Ini memberi tahu mesin resolusi untuk memperhitungkan sumber jarak jauh dan/atau lokal yang ditambahkan ke skrip.

Anda dapat menentukan sumber paket sebanyak yang Anda suka dalam skrip.

Penting

Jalur relatif saat ini tidak didukung dengan arahan #i . Anda harus menggunakan jalur absolut untuk sumber paket lokal. Batasan ini dilacak dalam dotnet/fsharp#12969.

Solusi sementara: Anda dapat secara terprogram membangun jalur absolut menggunakan __SOURCE_DIRECTORY__ dan System.IO.Path.Combine(), lalu menggunakan interpolasi string untuk meneruskannya ke arahan #i . Contohnya:

let localSource = System.IO.Path.Combine(__SOURCE_DIRECTORY__, "relative/path/to/my/local/source")
#i $"""nuget: {localSource}"""

Nota

Saat ini ada batasan untuk skrip yang menggunakan referensi kerangka kerja (misalnyaMicrosoft.NET.Sdk.Web atau Microsoft.NET.Sdk.WindowsDesktop). Paket seperti Saturnus, Giraffe, WinForms tidak tersedia. Ini sedang dilacak dalam masalah #9417. WinForms, masih berfungsi di versi .NET Framework F# Interactive.

Untuk memuat ekstensi tambahan selain yang disertakan dengan SDK dan/atau dengan alat Anda, gunakan flag --compilertool:<extensionsfolderpath> sebagai argumen untuk sesi F# Interactive (atau dalam pengaturan alat Anda).

Mereferensikan rakitan pada disk dengan interaktif F#

Atau, jika Anda memiliki rakitan pada disk dan ingin mereferensikan itu dalam skrip, Anda dapat menggunakan #r sintaks untuk menentukan assembly. Pertimbangkan kode berikut dalam proyek yang dikompilasi menjadi MyAssembly.dll:

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

Setelah dikompilasi, Anda dapat mereferensikannya dalam file yang disebut Script.fsx seperti:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

Outputnya adalah sebagai berikut:

dotnet fsi Script.fsx
90

Anda dapat menentukan referensi rakitan sebanyak yang Anda suka dalam skrip.

Memuat skrip lain

Saat membuat skrip, sering kali berguna untuk menggunakan skrip yang berbeda untuk tugas yang berbeda. Terkadang Anda mungkin ingin menggunakan kembali kode dari satu skrip di skrip lain. Daripada menyalin-menempelkan kontennya ke dalam file Anda, Anda cukup memuat dan mengevaluasinya dengan #load.

Pertimbangkan hal berikut Script1.fsx:

let square x = x * x

Dan file yang menggunakan, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Anda dapat mengevaluasi Script2.fsx seperti itu:

dotnet fsi Script2.fsx
144

Anda dapat menentukan arahan sebanyak #load yang Anda suka dalam skrip.

Nota

Deklarasi open Script1 diperlukan. Ini karena konstruksi dalam skrip F# dikompilasi ke dalam modul tingkat atas yang merupakan nama file skrip tempatnya berada. Jika file skrip memiliki nama huruf kecil seperti script3.fsx nama modul tersirat secara otomatis dikapitalisasi, dan Anda harus menggunakan open Script3. Jika Anda ingin skrip yang dapat dimuat untuk menentukan konstruksi di namespace modul tertentu, Anda dapat menyertakan namespace deklarasi modul, misalnya:

module MyScriptLibrary

fsi Menggunakan objek dalam kode F#

Skrip F# memiliki akses ke objek kustom fsi yang mewakili sesi Interaktif F#. Ini memungkinkan Anda untuk menyesuaikan hal-hal seperti pemformatan output. Ini juga bagaimana Anda dapat mengakses argumen baris perintah.

Contoh berikut menunjukkan cara mendapatkan dan menggunakan argumen baris perintah:

let args = fsi.CommandLineArgs

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

Ketika dievaluasi, ia mencetak semua argumen. Argumen pertama selalu nama skrip yang dievaluasi:

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

Anda juga dapat menggunakan System.Environment.GetCommandLineArgs() untuk mengakses argumen yang sama.

Referensi direktif interaktif F#

Arahan #r dan #load yang terlihat sebelumnya hanya tersedia di F# Interactive. Ada beberapa direktif yang hanya tersedia di F# Interactive:

Direktif	Deskripsi
#r "nuget:..."	Mereferensikan paket dari NuGet
#r "extname:..."	Mereferensikan paket dari extname ekstensi[^1] (seperti paket)
#r "assembly-name.dll"	Mereferensikan rakitan pada disk
#load "file-name.fsx"	Membaca file sumber, mengkompilasinya, dan menjalankannya.
#help	Menampilkan informasi tentang arahan atau dokumentasi yang tersedia untuk fungsi tertentu.
#I	Menentukan jalur pencarian rakitan dalam tanda kutip.
#quit	Mengakhiri sesi F# Interactive.
#time on atau #time off	Dengan sendirinya, #time beralih apakah akan menampilkan informasi performa. Saat on aktif, F# Interaktif mengukur informasi waktu nyata, waktu CPU, dan informasi pengumpulan sampah untuk setiap bagian kode yang ditafsirkan dan dijalankan.

[^1]: Selengkapnya tentang ekstensi Interaktif F#.

Saat Anda menentukan file atau jalur di F# Interactive, string literal diharapkan. Oleh karena itu, file dan jalur harus dalam tanda kutip, dan karakter escape biasa berlaku. Anda dapat menggunakan @ karakter untuk menyebabkan F# Interactive menginterpretasikan string yang berisi jalur sebagai string verbatim. Hal ini menyebabkan F# Interactive mengabaikan karakter escape apa pun.

Untuk kasus lain, tanda kutip bersifat opsional, dimulai dengan F# 9.

Direktif #help yang diperluas

Direktif #help sekarang mendukung menampilkan dokumentasi untuk fungsi tertentu. Anda dapat meneruskan nama fungsi secara langsung untuk mengambil rincian.

#help List.map;;

Outputnya adalah sebagai berikut:

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

Penyempurnaan ini memudahkan Anda menjelajahi dan memahami pustaka F# secara interaktif.

Untuk detail selengkapnya, lihat devblog resmi.

Direktif pra-prosesor interaktif dan dikompilasi

Saat Anda mengkompilasi kode di F# Interactive, apakah Anda berjalan secara interaktif atau menjalankan skrip, simbol INTERACTIVE ditentukan. Saat Anda mengkompilasi kode di pengkompilasi, simbol COMPILED ditentukan. Dengan demikian, jika kode perlu berbeda dalam mode yang dikompilasi dan interaktif, Anda dapat menggunakan arahan pra-pemrosesan ini untuk kompilasi bersyarat untuk menentukan mana yang akan digunakan. Contohnya:

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

Menggunakan F# Interactive di Visual Studio

Untuk menjalankan F# Interactive melalui Visual Studio, Anda dapat mengklik tombol toolbar yang sesuai berlabel F# Interactive, atau menggunakan tombol Ctrl+Alt+F. Melakukan ini akan membuka jendela interaktif, jendela alat yang menjalankan sesi F# Interaktif. Anda juga dapat memilih beberapa kode yang ingin Anda jalankan di jendela interaktif dan menekan kombinasi tombol Alt+Enter. F# Interactive dimulai di jendela alat berlabel F# Interactive. Saat Anda menggunakan kombinasi kunci ini, pastikan bahwa jendela editor memiliki fokus.

Baik Anda menggunakan konsol atau Visual Studio, perintah akan muncul dan penerjemah menunggu input Anda. Anda dapat memasukkan kode seperti yang Anda lakukan dalam file kode. Untuk mengkompilasi dan menjalankan kode, masukkan dua titik koma (;;) untuk mengakhiri baris atau beberapa baris input.

F# Interactive mencoba mengkompilasi kode dan, jika berhasil, kode dijalankan dan mencetak tanda tangan jenis dan nilai yang dikompilasinya. Jika terjadi kesalahan, penerjemah mencetak pesan kesalahan.

Kode yang dimasukkan dalam sesi yang sama memiliki akses ke konstruksi apa pun yang dimasukkan sebelumnya, sehingga Anda dapat membangun program. Buffer ekstensif di jendela alat memungkinkan Anda menyalin kode ke dalam file jika diperlukan.

Saat dijalankan di Visual Studio, F# Interactive berjalan secara independen dari proyek Anda, jadi, misalnya, Anda tidak dapat menggunakan konstruksi yang ditentukan dalam proyek Anda di F# Interactive kecuali Anda menyalin kode untuk fungsi ke jendela interaktif.

Anda dapat mengontrol argumen baris perintah (opsi) F# Interaktif dengan menyesuaikan pengaturan. Pada menu Alat , pilih Opsi..., lalu perluas Alat F#. Dua pengaturan yang dapat Anda ubah adalah opsi Interaktif F# dan pengaturan Interaktif F# 64-bit , yang hanya relevan jika Anda menjalankan F# Interactive pada komputer 64-bit. Pengaturan ini menentukan apakah Anda ingin menjalankan versi 64-bit khusus fsi.exe atau fsianycpu.exe, yang menggunakan arsitektur komputer untuk menentukan apakah akan berjalan sebagai proses 32-bit atau 64-bit.

Artikel terkait

Judul	Deskripsi
Opsi Interaktif F#	Menjelaskan sintaks baris perintah dan opsi untuk F# Interactive, fsi.exe.