F ile etkileşimli programlama#

F# Etkileşimli (dotnet fsi), F# kodunu konsolda etkileşimli olarak çalıştırmak veya F# betiklerini yürütmek için kullanılır. Başka bir deyişle, F# etkileşimli bir şekilde F# için bir REPL (Okuma, Değerlendirme, Yazdırma Döngüsü) yürütür.

F# Interactive'i konsolundan çalıştırmak için komutunu çalıştırın dotnet fsi. Herhangi bir .NET SDK'sında bulabilirsiniz dotnet fsi .

Uyarı

.NET Framework çalışma zamanı altında F# etkileşimli kullanmayı planlıyorsanız, Visual Studio Derleme Araçları'nın veya Visual Studio'nun bir sürümünün yüklü olması gerekir. Komutu bir "Geliştirici Komut İstemi"nden çalıştırın veya 'yi FsiAnyCPU.exe ortam değişkenine ekleyerek komut satırını kullanmadan erişilebilir hale getirin.

Araçlar, F# Etkileşimli çalışma zamanı sürümünü tanımlamayı destekler:

• Visual Studio'da: Menü çubuğunda Araçlar / Seçenekleri'nin ardından F# Araçları / F# Etkileşimli'yi seçin ve .NET Core Betiği Kullan'ı ayarlayın.
• Visual Studio Code'da (iyon uzantısı): Komut paletinde Tercihler: Kullanıcı Ayarlarını açın, ardından Uzantılar / F# / FSharp: Fsi Sdk Dosya Yolu.

Kullanılabilir komut satırı seçenekleri hakkında bilgi için bkz. F# Etkileşimli Seçenekler.

Kodu doğrudan F# Etkileşimli'de yürütme

F# Etkileşimli bir REPL (read-eval-print döngüsü) olduğundan, kodu etkileşimli olarak yürütebilirsiniz. Aşağıda, komut satırından yürütüldikten dotnet fsi sonra etkileşimli oturum örneği verilmiştir:

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

İki ana şey göreceksiniz:

1. Değerlendirilebilmesi için tüm kodun noktalı virgülle (;;) sonlandırılması gerekir
2. Kod değerlendirilir ve bir it değerde depolanır. Etkileşimli olarak it 'ye başvurabilirsiniz.

F# Interactive, çok satırlı girişi de destekler. Gönderiminizi çift noktalı virgülle (;; ) sonlandırmanız yeterlidir. F# Interactive'e yapıştırılan ve F# Etkileşimli tarafından değerlendirilen aşağıdaki kod parçacığını göz önünde bulundurun:

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

>

Kodun biçimlendirmesi korunur ve girişi sonlandıran bir çift noktalı virgül (;;) vardır. F# Interactive daha sonra kodu değerlendirdi ve sonuçları yazdırdı!

F# ile betik yazma

F# Interactive'de kodu etkileşimli olarak değerlendirmek harika bir öğrenme aracı olabilir, ancak bunun normal bir düzenleyicide kod yazmak kadar üretken olmadığını hemen fark edersiniz. Normal kod düzenlemeyi desteklemek için F# betikleri yazabilirsiniz.

Betikler .fsx dosya uzantısını kullanır. Kaynak kodu derleyip daha sonra derlenmiş derlemeyi çalıştırmak yerine dotnet fsi komutunu çalıştırabilir ve betiğin dosya adını belirtebilirsiniz. F# Interactive kodu okur ve gerçek zamanlı olarak yürütür. Örneğin, Script.fsx adlı aşağıdaki betiği göz önünde bulundurun:

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

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

Bu dosya makinenizde oluşturulduğunda dotnet fsi ile çalıştırabilir ve çıktıyı doğrudan terminal pencerenizde görebilirsiniz.

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

Shebang ile Betik Yürütme

F# betiklerini açıkça çağırmadan dotnet fsiyürütülebilir hale getirmek için betiğin üst kısmındaki shebang satırını kullanabilirsiniz. Bu, betiği doğrudan terminalden bir kabuk betiği gibi çalıştırmanıza olanak tanır.

Örneğin, aşağıdaki içeriğe sahip adlı ExecutableScript.fsx bir betik dosyası oluşturun:

#!/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. Betiği Yürütülebilir Yap:chmod Betiği yürütülebilir yapmak için komutunu kullanın:

   chmod +x ExecutableScript.fsx
   

2. Betiği Doğrudan Çalıştırın: Artık betiği doğrudan terminalden yürütebilirsiniz:

   ./ExecutableScript.fsx
   

Not: Shebang işlevselliği (#!), Linux ve MacOS gibi Unix benzeri sistemlere özgüdür. Windows'da komut dosyalarını doğrudan terminalde veya komut isteminde kullanarak dotnet fsi Script.fsx yürütebilirsiniz.

Bu özellik, Linux ve macOS gibi ortamlarda F# betikleriyle çalışırken daha sorunsuz bir deneyim sağlar.

F# betiği , Visual Studio ve Visual Studio Code'da yerel olarak desteklenir.

F# Interactive'de paketlere referans verme

Uyarı

Paket yönetim sistemi genişletilebilir, eklentiler ve uzantı mekanizması hakkında daha fazla bilgi edinin.

Dilin 5.0 sürümünden bu yana, F# Interactive genişletilebilirlik mekanizması aracılığıyla paketlere başvurmayı destekler; standart olarak #r "nuget:" söz dizimiyle ve isteğe bağlı bir sürümle NuGet paketlerine başvurabilir.

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

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

Sürüm belirtilmezse, en yüksek kullanılabilir önizleme dışı paket alınır. Belirli bir sürüme başvurmak için, sürümü virgülle tanıtın. Bu, bir paketin önizleme sürümüne başvururken kullanışlı olabilir. Örneğin, DiffSharp'ın önizleme sürümünü kullanarak bu betiği göz önünde bulundurun:

#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)}"

Varsayılan olarak, #r "nuget: ...." geri yükleme sırasında başvurulan paketten derleme hedeflerini kullanmaz. usepackagetargets seçeneği gerektiğinde bu derleme hedeflerinin kullanılmasını sağlar. Başvuruda bulunan paketin geri yükleme sırasında usepackagetargets=true eklenmesini gerektirecek şekilde yazıldığı durumda yalnızca usepackagetargets=true ekleyin. Örnekler:

// 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"

Paket kaynağı belirtme

Komutuyla #i bir paket kaynağı da belirtebilirsiniz. Aşağıdaki örnekler uzak ve yerel kaynakları belirtir:

#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"

Bu, çözüm motoruna betiklere eklenen uzak ve/veya yerel kaynakları dikkate almasını söyler.

Betikte istediğiniz kadar paket kaynağı belirtebilirsiniz.

Önemli

Göreli yollar, şu anda #i yönergesi ile desteklenmemektedir. Yerel paket kaynakları için mutlak yollar kullanmanız gerekir. Bu sınırlama dotnet/fsharp#12969'da izlenir.

Geçici çözüm:__SOURCE_DIRECTORY__ ve System.IO.Path.Combine() kullanarak program aracılığıyla mutlak bir yol oluşturabilir ve ardından dize yerleştirme yöntemini kullanarak #i yönergesine geçirebilirsiniz. Örneğin:

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

Uyarı

Şu anda çerçeve referansları (örneğin Microsoft.NET.Sdk.Web veya Microsoft.NET.Sdk.WindowsDesktop) kullanan betikler için bir sınırlama vardır. Satürn, Zürafa, WinForms gibi paketler kullanılamaz. Bu konu #9417'de izleniyor. WinForms, F# Interactive'in .NET Framework sürümünde çalışmaya devam eder.

SDK ve/veya araçlarınızla birlikte gönderilen uzantıların yanına ek uzantıları yüklemek için, --compilertool:<extensionsfolderpath> bayrağını F# Etkileşimli oturumu içinde veya araç ayarlarınızda bağımsız değişken olarak kullanın.

F# Interactive ile diskteki derlemelere başvurma

Alternatif olarak, diskte bir derlemeniz varsa ve buna bir betikte başvurmak istiyorsanız, derleme belirtmek için söz dizimini #r kullanabilirsiniz. içinde derlenmiş MyAssembly.dllbir projede aşağıdaki kodu göz önünde bulundurun:

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

Derledikten sonra şuna benzer bir Script.fsx dosyada başvurabilirsiniz:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

Çıktı aşağıdaki şekilde olacaktır:

dotnet fsi Script.fsx
90

Betikte istediğiniz kadar derleme referansı belirtebilirsiniz.

Diğer betikleri yükleme

Betik oluştururken genellikle farklı görevler için farklı betikler kullanmak yararlı olabilir. Bazen bir betikteki kodu başka bir betikte yeniden kullanmak isteyebilirsiniz. İçeriğini dosyanıza kopyalayıp yapıştırmak yerine ile yükleyip değerlendirebilirsiniz #load.

Aşağıdakileri Script1.fsxgöz önünde bulundurun:

let square x = x * x

Ve tüketen dosya, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

Şu şekilde değerlendirebilirsiniz Script2.fsx :

dotnet fsi Script2.fsx
144

Bir betikte istediğiniz kadar #load yönerge belirtebilirsiniz.

Uyarı

Bildirim open Script1 gereklidir. Bunun nedeni, bir F# betiğindeki yapıların içinde olduğu betik dosyasının adı olan üst düzey bir modülde derlenmiş olmasıdır. Eğer betik dosyası script3.fsx gibi küçük harfli bir ada sahipse, varsayılan modül adı otomatik olarak büyük harfe çevrilir ve open Script3 kullanmanız gerekir. Bir loadable-betiğin belirli bir modül ad alanında yapı tanımlamasını istiyorsanız, modül bildiriminin ad alanını ekleyebilirsiniz, örneğin:

module MyScriptLibrary

fsi nesnesinin F# kodunda kullanılması

F# betiklerinin F# Etkileşimli oturumunu temsil eden özel fsi bir nesneye erişimi vardır. Çıkış biçimlendirmesi gibi öğeleri özelleştirmenize olanak tanır. Komut satırı bağımsız değişkenlerine de bu şekilde erişebilirsiniz.

Aşağıdaki örnek, komut satırı argümanlarının nasıl alınıp kullanılacağını göstermektedir.

let args = fsi.CommandLineArgs

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

Değerlendirildiğinde, tüm bağımsız değişkenleri yazdırır. İlk bağımsız değişken her zaman değerlendirilen betiğin adıdır:

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

Aynı bağımsız değişkenlere erişmek için de kullanabilirsiniz System.Environment.GetCommandLineArgs() .

F# Etkileşimli komut referansı

Daha önce görülen #r ve #load yönergeleri yalnızca F# etkileşimli'de kullanılabilir. Yalnızca F# Interactive'de kullanılabilen birkaç yönerge vardır:

Yönerge	Açıklama
#r "nuget:..."	NuGet'ten bir pakete başvurur
#r "extname:..."	extname uzantısından[^1] bir pakete başvurma (örneğin paket)
#r "assembly-name.dll"	Disk üzerindeki bir derlemeye başvurur
#load "file-name.fsx"	Kaynak dosyayı okur, derler ve çalıştırır.
#help	Belirli işlevler için kullanılabilir yönergeler veya belgeler hakkındaki bilgileri görüntüler.
#I	Tırnak içinde bir derleme dosyası arama yolu belirtir.
#quit	F# Etkileşimli oturumlarını sonlandırır.
#time on veya #time off	Tek başına, #time performans bilgilerinin görüntülenip görüntülenmeyeceğini değiştirir. on olduğunda, F# Etkileşimli, yorumlanan ve yürütülen kodun her bölümü için gerçek zamanlı, CPU süresini ve çöp toplama bilgilerini ölçer.

[^1]: F# Etkileşimli uzantıları hakkında daha fazla bilgi.

F# Etkileşimli'de dosya veya yol belirttiğinizde dize değişmez değeri beklenir. Bu nedenle, dosyaların ve yolların tırnak işareti içinde yer alması ve standart kaçış karakterlerinin geçerli olması gerekir. F# Etkileşimli'nin bir yolu içeren bir dizeyi harfi harfine bir dize olarak yorumlamasını sağlamak için @ karakterini kullanabilirsiniz. Bu durum, F# Interactive'in kaçış karakterlerini yoksaymasına neden olur.

Diğer durumlarda, F# 9'dan başlayarak tırnak işaretleri isteğe bağlıdır.

Genişletilmiş #help yönergesi

Yönerge #help artık belirli işlevlere yönelik belgelerin görüntülenmesini destekliyor. Ayrıntıları almak için işlevin adını doğrudan geçirebilirsiniz.

#help List.map;;

Çıktı aşağıdaki şekilde olacaktır:

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

Bu geliştirme, F# kitaplıklarını etkileşimli olarak keşfetmeyi ve anlamayı kolaylaştırır.

Daha fazla ayrıntı için resmi devblog'a bakın.

Etkileşimli ve derlenmiş ön işlemci yönergeleri

F# Interactive'de kodları derlerken, etkileşimli çalıştırdığınızda veya bir betik çalıştırırken, ETKILEŞIMLI simgesi kullanılır. Derleyicide kod derlediğinizde DERLENEN simgesi tanımlanır. Bu nedenle, kodun derlenmiş ve etkileşimli modlarda farklı olması gerekiyorsa, hangilerinin kullanılacağını belirlemek üzere koşullu derleme için bu önişlemci yönergelerini kullanabilirsiniz. Örneğin:

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

Visual Studio'da F# Interactive kullanma

F# Etkileşimli'yi Visual Studio aracılığıyla çalıştırmak için F# Etkileşimli etiketli uygun araç çubuğu düğmesine tıklayabilir veya Ctrl+Alt+F tuşlarını kullanabilirsiniz. Etkileşimli pencereyi açmak, F# Etkileşimli oturumu çalıştıran bir araç penceresini açar. Ayrıca etkileşimli pencerede çalıştırmak istediğiniz bazı kodları seçebilir ve Alt+Enter tuş bileşimine basabilirsiniz. F# Etkileşimli, F# Etkileşimli etiketli bir araç penceresinde başlar. Bu tuş bileşimini kullandığınızda, odağın düzenleyici penceresinde olduğundan emin olun.

konsolunu veya Visual Studio'yu kullanıyor olun, bir komut istemi görüntülenir ve yorumlayıcı girişinizi bekler. Kodu bir kod dosyasına girdiğiniz gibi girebilirsiniz. Kodu derlemek ve yürütmek için, bir satırı veya birkaç giriş satırını sonlandırmak için iki noktalı virgül (;;) girin.

F# Etkileşimli, kodu derlemeyi dener ve başarılı olursa kodu yürütür ve derlediği türlerin ve değerlerin imzasını yazdırır. Hatalar oluşursa, yorumlayıcı hata iletilerini yazdırır.

Aynı oturumda girilen kodun daha önce girilen tüm yapılara erişimi vardır, böylece program oluşturabilirsiniz. Araç penceresindeki kapsamlı arabellek, gerekirse kodu bir dosyaya kopyalamanızı sağlar.

Visual Studio'da çalıştırıldığında, F# Etkileşimli projenizden bağımsız olarak çalışır; bu nedenle, örneğin, işlevin kodunu etkileşimli pencereye kopyalamadığınız sürece F# Etkileşimli'de projenizde tanımlanan yapıları kullanamazsınız.

Ayarları ayarlayarak F# Etkileşimli komut satırı bağımsız değişkenlerini (seçenekler) denetleyebilirsiniz. Araçlar menüsünde Seçenekler...'yi seçin ve F# Araçları'nı genişletin. Değiştirebileceğiniz iki ayar F# Etkileşimli seçenekleri ve 64 bit F# Etkileşimli ayarıdır. Bu ayar yalnızca 64 bit makinede F# Etkileşimli çalıştırıyorsanız geçerlidir. Bu ayar, 32 bit veya 64 bit işlem olarak çalıştırılıp çalıştırılmayacağını belirlemek için makine mimarisini kullanan fsi.exe veya fsianycpu.exeayrılmış 64 bit sürümünü çalıştırmak isteyip istemediğinizi belirler.

İlgili makaleler

Başlık	Açıklama
F# Interactive Seçenekleri	F# Etkileşimli fsi.exeiçin komut satırı sözdizimi ve seçeneklerini tanımlar.