Pemrograman interaktif dengan F#

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

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

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

Menjalankan kode langsung di Interaktif F#

Karena Interaktif F# adalah REPL (perulangan baca-evaluasi-cetak), Anda dapat menjalankan kode secara interaktif di dalamnya. Berikut adalah contoh sesi interaktif setelah menjalankan 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.

Interaktif F# juga mendukung input multibaris. Anda hanya perlu mengakhiri pengiriman dengan titik koma ganda (;;). Pertimbangkan cuplikan berikut yang telah ditempelkan dan dievaluasi oleh Interaktif F#:

> 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. Interaktif F# kemudian mengevaluasi kode dan mencetak hasilnya.

Pembuatan skrip dengan F#

Mengevaluasi kode secara interaktif di Interaktif F# dapat menjadi alat pembelajaran yang hebat, tetapi Anda akan langsung tahu bahwa proses ini tidaklah produktif seperti menulis kode di editor normal. Untuk mendukung pengeditan kode normal, Anda dapat menulis skrip F#.

Skrip menggunakan ekstensi file .fsx. Sebagai ganti mengompilasi kode sumber dan kemudian menjalankan rakitan yang dikompilasi, Anda cukup menjalankan dotnet fsi kemudian menentukan nama file skrip yang berisi kode F#, dan interaktif F# akan membaca kode serta menjalankannya secara real time. Misalnya, pertimbangkan kueri SQL berikut bernama Script.fsx:

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

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

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

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

Pembuatan skrip F# didukung secara native di Visual Studio, Visual Studio Code, dan Visual Studio untuk Mac.

Mereferensikan paket di Interaktif F#

Catatan

Sistem pengelolaan paket dapat diperluas.

Interaktif F# mendukung referensi 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. Cara ini 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)}"

Menentukan sumber paket

Anda juga dapat menentukan sumber paket dengan perintah #i. 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"""

Hal ini akan memberi tahu mesin resolusi di bawah penutup untuk juga mempertimbangkan sumber jarak jauh dan/atau lokal yang ditambahkan ke skrip.

Anda dapat menentukan referensi paket sebanyak yang Anda suka di skrip.

Catatan

Saat ini ada batasan untuk skrip yang menggunakan referensi kerangka kerja (misalnya Microsoft.NET.Sdk.Web atau Microsoft.NET.Sdk.WindowsDesktop). Paket seperti Saturn, Giraffe, WinForms tidak tersedia. Hal ini sedang dilacak dalam masalah #9417.

Mereferensikan rakitan pada disk dengan interaktif F#

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

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

Setelah dikompilasi, Anda dapat mereferensikannya dalam file bernama Script.fsx seperti ini:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

Outputnya sebagai berikut:

dotnet fsi Script.fsx
90

Anda dapat menentukan referensi rakitan sebanyak yang Anda ingin di skrip.

Memuat skrip lain

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

Pertimbangkan Script1.fsx berikut:

let square x = x * x

Dan file yang menyerap, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Anda dapat mengevaluasi Script2.fsx seperti berikut:

dotnet fsi Script2.fsx
144

Anda dapat menentukan direktif #load sebanyak yang Anda ingin di skrip.

Catatan

Deklarasi open Script1 diperlukan. Hal 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 maka nama modul yang tersirat secara otomatis dikapitalisasi, dan Anda harus menggunakan open Script3. Jika ingin skrip yang dapat dimuat menentukan konstruksi dalam kumpulan nama XML modul tertentu, Anda dapat menyertakan kumpulan nama XML deklarasi modul, misalnya:

module MyScriptLibrary

Menggunakan objek fsi dalam kode F#

Skrip F# memiliki akses ke objek fsi kustom yang mewakili sesi Interaktif F#. Hal ini memungkinkan Anda untuk menyesuaikan hal-hal seperti pemformatan output. Hal ini juga merupakan cara 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}"

Saat dievaluasi, cara ini mencetak semua argumen. Argumen pertama selalu merupakan nama skrip yang dievaluasi:

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

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

Referensi direktif Interaktif F#

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

Direktif	Deskripsi
#r "nuget:..."	Mereferensikan paket dari NuGet
#r "assembly-name.dll"	Mereferensikan rakitan pada disk
#load "file-name.fsx"	Membaca, mengompilasi, dan menjalankan file sumber.
#help	Menampilkan informasi tentang direktif yang tersedia.
#I	Menentukan jalur pencarian rakitan dalam tanda kutip.
#quit	Mengakhiri sesi Interaktif F#.
#time "on" atau #time "off"	Dengan sendirinya, #time akan beralih untuk menampilkan informasi performa. Saat "on", Interaktif F# akan mengukur informasi real time, waktu CPU, dan pengumpulan sampah untuk setiap bagian kode yang ditafsirkan dan dijalankan.

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

Direktif praprosesor yang dikompilasi dan interaktif

Saat Anda mengompilasi kode di Interaktif F#, apakah Anda menjalankan secara interaktif atau menjalankan skrip, simbol INTERACTIVE akan ditentukan. Saat Anda mengompilasi kode di pengompilasi, simbol COMPILED akan ditentukan. Dengan demikian, jika kode harus berbeda dalam mode yang dikompilasi dan interaktif, Anda dapat menggunakan direktif praprosesor ini dalam kompilasi kondisional untuk menentukan mana yang akan digunakan. Contohnya:

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

Menggunakan Interaktif F# di Visual Studio

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

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

Interaktif F# mencoba mengompilasi kode dan, jika berhasil, kode dijalankan serta tanda tangan jenis dan nilai yang dikompilasi akan dicetak. Jika terjadi kesalahan, penafsir akan mencetak pesan kesalahan.

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

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

Anda dapat mengontrol argumen baris perintah (opsi) Interaktif F# dengan menyesuaikan pengaturan. Pada menu Alat, pilih Opsi..., lalu luaskan Alat F#. Dua pengaturan yang dapat Anda ubah adalah opsi Interaktif F# dan pengaturan Interaktif F# 64-bit, yang hanya relevan jika Anda menjalankan Interaktif F# 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 Interaktif F#, fsi.exe.