Ini membantu melengkapi gambar untuk mengiris skenario dengan array 3D dan 4D.

Pratinjau: indeks terbalik

Microsoft juga memperkenalkan kemampuan untuk menggunakan indeks terbalik, yang dapat digunakan dengan irisan, sebagai pratinjau dalam f# 5. Untuk menggunakannya, cukup tempatkan pratinjau Di file proyek Anda.

Biarkan xs = [1..10] // Dapatkan elemen 1 dari akhir: xs.[^1] // Cara lama untuk mendapatkan dua elemen terakhir Let lasttwooldstyle = xs.[(xs.Panjang-2)..] // cara baru untuk mendapatkan dua elemen terakhir Let lasttwonewstyle = xs.[^1..] lasttwooldstyle = lasttwonewstyle // true 

Anda juga dapat mendefinisikan anggota Anda sendiri melalui ekstensi tipe f# untuk menambah tipe ini untuk mendukung indeks pengiris dan terbalik. Contoh berikut melakukannya dengan tipe rentang:

Buka Jenis Rentang Sistem dengan Anggota SP.Getslice (startidx, endidx) = let s = defaultArg startIdx 0 let e = defaultArg endidx sp sp sp sp sp.Panjang sp.SLICE (S, E - S) SP SP.GetReverseIndex (_, offset: int) = sp.Panjang - Offset Biarkan sp = [| 1; 2; 3; 4; 5 |].Asspan () sp.[..^2] // [| 1; 2; 3 |] 

F# Jenis intrinsik memiliki indeks terbalik yang dibangun. Dalam rilis F#di masa mendatang, kami juga akan mendukung interop penuh dengan sistem.Indeks dan sistem.Kisaran, pada titik mana, fitur tidak akan lagi dalam pratinjau.

Kutipan Kode yang Ditingkatkan

Kutipan Kode F# adalah fitur metaprogram yang memungkinkan Anda memanipulasi struktur kode F# dan mengevaluasinya dalam lingkungan yang Anda pilih. Kemampuan ini sangat penting untuk menggunakan F# sebagai bahasa konstruksi model untuk tugas pembelajaran mesin, di mana model AI dapat berjalan pada perangkat keras yang berbeda, seperti GPU. Sepotong kritis yang hilang dalam teka -teki ini adalah kemampuan untuk dengan setia mewakili informasi kendala tipe f#, seperti yang digunakan dalam aritmatika generik, dalam kutipan f# sehingga evaluator dapat mengetahui untuk menerapkan kendala tersebut di lingkungan yang dievaluasi di dalamnya.

Dimulai dengan F# 5, kendala sekarang dipertahankan dalam kutipan kode, membuka kemampuan untuk perpustakaan tertentu seperti diffsharp untuk menggunakan bagian ini dari sistem tipe f# untuk keuntungannya. Cara sederhana untuk menunjukkan ini adalah kode berikut:

Buka fsharp.Linq.RuntimeHelpers Let eval q = LeafExpressionConverter .Mengevaluasiquotasi q Biarkan inline negasi x = -x // Yang Penting, 'Negasi' memiliki // tanda tangan berikut: // // val inline negate: // x: ^a -> ^a // Ketika ^a: // (anggota statis (~ -): ^a -> a) // Kutipan ini sangat penting untuk keselamatan tipe f# dan sekarang adalah keamanan // sedang // sekarang // adalah safety tipe f# dan sekarang // di sini / / sekarang ada . |> Eval 

Penggunaan operator aritmatika menyiratkan batasan tipe sehingga semua jenis yang diturunkan untuk meniadakan harus mendukung ? operator. Kode ini gagal saat runtime karena kutipan kode tidak menyimpan informasi kendala ini, jadi mengevaluasi itu melempar pengecualian.

Kutipan Kode adalah fondasi untuk beberapa pekerjaan R&D-berat yang dilakukan untuk menggunakan F# sebagai bahasa untuk membuat model AI, dan dengan demikian kemampuan untuk mempertahankan informasi jenis kendala di dalamnya membantu menjadikan F# bahasa yang menarik bagi programmer di ruang ini yang mencari sedikit lebih banyak keamanan dalam kehidupan mereka.

F# 5 memiliki dasar -dasar

F# 5 mungkin tentang membuat interaktivitas dan pemrograman analitik menjadi lebih baik, tetapi pada intinya, F# 5 masih tentang membuat pengkodean sehari -hari dalam kegembiraan F#. F# 5 mencakup beberapa fitur baru yang dapat dinikmati oleh pengembang aplikasi dan penulis perpustakaan.

Dukungan untuk Nameof

First Up adalah fitur yang Datang Pengembang C# . Nama operator mengambil simbol F# sebagai input dan menghasilkan string pada waktu kompilasi yang mewakili simbol itu. Itu mendukung hampir semua konstruksi f#. Nama operator sering digunakan untuk logging diagnostik dalam aplikasi yang sedang berjalan.

#r "Nuget: fsharp.SystemTextJson "Sistem Terbuka.Teks.JSON Open System.Teks.Json.Sistem terbuka serialisasi.Runtime.Modul CompilerServices M = Biarkan F X = Nama x printfn "%s" (m.f 12) printfn "%s" (nameof m) printfn "%s" (nameof m.f) /// Versi Sederhana dari EventStore's API Type RecordEvent = < EventType: string Data: byte[] >/// Jenis beton saya: ketik myevent = | ADATA OF INT | Bdata dari string // gunakan 'nameof' alih -alih string literal dalam ekspresi kecocokan mari deserialize (e: recordedevent): myEvent = cocok e.EventType dengan | Nameof Adata -> JSonserializer.Deserialize e.Data |> Adata | Nama Bdata -> JSonserializer.Deserialize e.Data |> Bdata | t -> failwithf "eventType tidak valid: %s" t 

String interpolasi

Berikutnya adalah fitur yang terlihat dalam bahasa seperti C# dan JavaScript: String Interpolated. String interpolasi memungkinkan Anda untuk membuat interpolasi atau lubang dalam string yang dapat Anda isi dengan ekspresi F#. F# Dukungan string interpolasi yang diketik interpolasi yang identik dengan format yang sama menentukan dalam format sprintf dan cetak. F# string interpolasi juga mendukung string triple-quotes. Sama seperti di C#, semua simbol dalam interpolasi F# dapat dilayari, dapat diganti namanya, dan seterusnya.

// string interpolasi dasar name = "phillip" biarkan usia = 29 let pesan = $ "name :, usia:" // diketik interpolasi // ' %s' mensyaratkan interpolasi untuk menjadi string // ' %d' membutuhkan interpolasi untuk menjadi interpolasi interpolated "name ( %s, usia: %d" // verpolasi interpolated string ( %STREOK "USE/ %di Interpolasi ( %STREOK" USE/ %DEPAN ( %DEPTON "USED" USED "USET" USED "USET" USE ( %DET "/ %. "Nama": "", "usia": "" " 

Selain itu, Anda dapat menulis beberapa ekspresi di dalam string interpolasi, menghasilkan nilai yang berbeda untuk ekspresi interpolasi berdasarkan input ke fungsi. Ini lebih merupakan penggunaan ceruk fitur, tetapi karena interpolasi apa pun dapat menjadi ekspresi F# yang valid, memungkinkan untuk banyak fleksibilitas.

Deklarasi Jenis Terbuka

F# selalu memungkinkan Anda untuk membuka namespace atau modul untuk mengekspos konstruksi publiknya. Sekarang, dengan F# 5, Anda dapat membuka jenis apa pun untuk mengekspos konstruksi statis seperti metode statis, bidang statis, sifat statis, dan sebagainya. F# Union and Records juga dapat dibuka. Anda juga dapat membuka tipe generik pada instantiasi jenis tertentu.

sistem jenis terbuka.Matematika biarkan x = min (1.0, 2.0) Modul M = Type DU = A | B | C Biarkan fungsi someother x = x + 1 // buka hanya tipe di dalam modul buka tipe m.Du printfn "%a" a 

Ekspresi komputasi yang ditingkatkan

Ekspresi Komputasi adalah serangkaian fitur yang sangat disukai yang memungkinkan penulis perpustakaan untuk menulis kode ekspresif. Bagi mereka yang berpengalaman dalam teori kategori, mereka juga merupakan cara formal untuk menulis perhitungan monadik dan monoid. F# 5 memperluas ekspresi komputasi dengan dua fitur baru:

• Formulir Aplikasi untuk Ekspresi Komputasi Melalui LET. Dan! kata kunci
• Dukungan yang tepat untuk Operasi Kustom Kelebihan

“Formulir Aplikasi untuk Ekspresi Komputasi” Sedikit seteguk. Saya akan menghindari menyelam ke dalam teori kategori dan sebagai gantinya mengerjakan contoh:

// Pertama, tentukan hasil modul fungsi 'zip' = Biarkan zip x1 x2 = cocok dengan x1, x2 dengan | OK x1res, ok x2res -> ok (x1res, x2res) | Kesalahan E, _ -> Kesalahan E | _, Kesalahan e -> kesalahan e // selanjutnya, tentukan pembangun dengan 'gabungan' dan 'bindreturn' type resultBuilder () = anggota _.Mergesources (T1: Hasil, T2: Hasil) = Hasil.Zip T1 T2 Anggota _.BindReturn (x: hasil, f) = hasil.peta f x let result = resultBuilder () Biarkan jalankan R1 r2 r3 = // dan di sini adalah aplikasi kami! Biarkan res1: hasil = hasil < let! a = r1 and! b = r2 and! c = r3 return a + b - c >Cocokkan res1 dengan | OK X -> printfn " %s adalah: %d" (nama res1) x | Kesalahan E -> printfn " %s adalah: %s" (nameof res1) e 

Sebelum F# 5, masing -masing dan ini! Kata kunci akan dibiarkan! kata kunci. Dan! Kata kunci berbeda karena ekspresi yang mengikutinya harus 100% independen. Itu tidak dapat bergantung pada hasil dari Let sebelumnya! -nilai terikat. Itu berarti kode seperti berikut gagal mengkompilasi:

Biarkan res1: hasil = hasil < let! a = r1 and! b = r2 a // try to pass 'a' and! c = r3 b // try to pass 'b' return a + b - c >

Jadi, mengapa kita membuat kode itu gagal dikompilasi? Beberapa alasan. Pertama, ini menegakkan independensi komputasi pada waktu kompilasi. Kedua, ia membeli sedikit kinerja saat runtime karena memungkinkan kompiler untuk membangun grafik panggilan secara statis. Ketiga, karena setiap perhitungan independen, mereka dapat dieksekusi secara paralel dengan lingkungan apa pun yang mereka jalankan. Terakhir, jika suatu perhitungan gagal, seperti pada contoh sebelumnya di mana seseorang dapat mengembalikan nilai kesalahan alih-alih nilai OK, semuanya tidak berikatan pendek pada kegagalan itu. Formulir Aplikatatif “mengumpulkan” Semua nilai yang dihasilkan dan memungkinkan setiap perhitungan berjalan sebelum menyelesaikan. Jika Anda mengganti masing -masing dan! dengan let! , apa saja yang mengembalikan kesalahan pendek dari fungsi. Perilaku yang berbeda ini memungkinkan penulis perpustakaan dan pengguna untuk memilih perilaku yang tepat berdasarkan skenario mereka.

Jika ini terdengar seperti konsep kecil, tidak apa-apa! Perhitungan aplikasi adalah sedikit konsep canggih dari sudut pandang penulis perpustakaan, tetapi mereka adalah alat yang kuat untuk abstraksi. Sebagai pengguna mereka, Anda tidak perlu mengetahui semua seluk beluk cara kerja mereka; Anda hanya dapat mengetahui bahwa setiap perhitungan dalam ekspresi perhitungan dijamin akan dijalankan secara independen dari yang lain.

Peningkatan lain untuk ekspresi perhitungan adalah kemampuan untuk mendukung kelebihan beban dengan benar untuk operasi kustom dengan nama kata kunci yang sama, dukungan untuk argumen opsional, dan dukungan untuk sistem.Argumen Paramarray. Operasi khusus adalah cara bagi penulis perpustakaan untuk menentukan kata kunci khusus yang mewakili jenis operasi mereka sendiri yang dapat terjadi dalam ekspresi perhitungan. Fitur ini banyak digunakan dalam kerangka kerja seperti Saturnus untuk mendefinisikan DSL ekspresif untuk membangun aplikasi web. Dimulai dengan F# 5, penulis komponen seperti Saturnus dapat membebani operasi kustom mereka tanpa peringatan apa pun, seperti yang ditunjukkan Daftar 1.

Listing 1: Ekspresi Komputasi Dapat Mengurangi Operasi Kustom

ketik inputkind = | Teks Placeholder: Opsi String | Kata Sandi Placeholder: String Opsi Jenis InputOptions = < Label: string option Kind: InputKind Validators: (string ->bool) array> ketik inputBuilder () = anggota t.Hasil (_) = < Label = None Kind = Text None Validators = [||] >[] Anggota ini.Teks (io,?placeholder) = < io with Kind = Text placeholder >[] Anggota ini.Kata sandi (IO,?placeholder) = < io with Kind = Password placeholder >[] Anggota ini.Label (io, label) = < io with Label = Some label >[] Anggota ini.Validator (io, [] validator) = < io with Validators = validators >Biarkan input = inputBuilder () Biarkan name = input < label "Name" text with_validators (String.IsNullOrWhiteSpace >> tidak)> biarkan email = input < label "Email" text "Your email" with_validators (String.IsNullOrWhiteSpace >> tidak) (fun s -> s.Berisi "@")> Biarkan kata sandi = input < label "Password" password "Must contains at least 6 characters, one number and one uppercase" with_validators (String.exists Char.IsUpper) (String.exists Char.IsDigit) (fun s ->S.Panjang> = 6)> 

Dukungan yang tepat untuk kelebihan beban dalam operasi khusus dikembangkan sepenuhnya oleh dua kontributor open source diego Esmerio dan Ryan Riley.

Dengan formulir aplikasi untuk ekspresi perhitungan dan kemampuan untuk membebani operasi kustom, kami senang melihat apa yang dapat dilakukan oleh penulis perpustakaan F#.

Implementasi Antarmuka di berbagai instantiasi generik

Dimulai dengan F# 5, Anda sekarang dapat mengimplementasikan antarmuka yang sama pada instantiasi generik yang berbeda. Fitur ini dikembangkan dalam kemitraan dengan Lukas Rieger, kontributor F# open source.

Type IA = Abstrak Anggota Dapatkan: Unit -> ?T type myclass () = antarmuka IA dengan anggota x.Get () = 1 antarmuka IA dengan anggota x.Get () = "hello" let mc = myclass () let asint = mc:> ia let asstring = mc:> ia asint.Get () // 1 astring.Get () // "halo" 

Lagi .Peningkatan interop bersih

.Net adalah platform yang berkembang, dengan konsep -konsep baru memperkenalkan setiap rilis dan dengan demikian, lebih banyak peluang untuk beroperasi. Antarmuka di .NET sekarang dapat menentukan implementasi default untuk metode dan properti. F# 5 memungkinkan Anda mengonsumsi antarmuka ini secara langsung. Pertimbangkan kode C# berikut:

menggunakan sistem; namespace csharplibrary < public interface MyDim < public int Z =>0; >> 

Antarmuka ini dapat dikonsumsi secara langsung di F#:

buka csharp // Buat ekspresi objek untuk mengimplementasikan antarmuka biarkan md = < new MyDim >printfn $ "redup dari c#:" 

Konsep lain di .Bersih yang mendapatkan lebih banyak perhatian adalah tipe nilai nullable (sebelumnya disebut tipe nullable). Awalnya dibuat untuk lebih mewakili tipe data SQL, mereka juga mendasar untuk pustaka manipulasi data inti seperti abstraksi bingkai data di Microsoft.Data.Analisis . Untuk membuatnya sedikit lebih mudah untuk berinteraksi dengan perpustakaan ini, Anda menerapkan aturan yang diarahkan tipe baru untuk metode panggilan dan menetapkan nilai ke properti yang merupakan tipe nilai yang dapat dibatalkan. Pertimbangkan sampel berikut menggunakan paket ini dengan Paket Referensi Petunjuk:

#r "Nuget: Microsoft.Data.Analisis "Open System Open Microsoft.Data.Analisis Biarkan datetimes = "datetimes" |> primitivedataframecolumn // berikut ini digunakan untuk gagal mengkompilasi tanggal = datetime.Parse ("2019/01/01") Datetimes.Append (date) // yang sebelumnya sekarang setara dengan: let date = datetime.Parse ("2019/01/01") Biarkan data = nullable (tanggal) datetimes.Tambahkan (data) 

Contoh -contoh ini digunakan untuk mengharuskan Anda secara eksplisit membangun tipe nilai nullable dengan konstruktor tipe nullable seperti yang ditunjukkan contohnya.

Kinerja yang lebih baik

Tim Microsoft telah menghabiskan tahun lalu meningkatkan kinerja kompiler F# baik dalam hal throughput dan kinerja alat di IDE seperti Visual Studio. Peningkatan kinerja ini telah diluncurkan secara bertahap daripada sebagai bagian dari satu rilis besar. Jumlah karya ini yang memuncak dalam F# 5 dapat membuat perbedaan untuk pemrograman F# Everyday. Sebagai contoh, saya telah menyusun basis kode yang sama ? Proyek inti di fsharplus, sebuah proyek yang terkenal menekankan kompiler f# ? tiga kali. Sekali untuk F# 5, sekali untuk F# 4 terbaru.7 dengan .Net Core, dan sekali untuk F# 4 terbaru.5 in .Inti bersih, seperti yang ditunjukkan Tabel 1.

Hasilnya Tabel 1 berasal dari menjalankan dotnet build /clp: performancesunnary dari baris perintah dan melihat total waktu yang dihabiskan dalam tugas FSC, yang merupakan kompiler f#. Hasil mungkin bervariasi pada komputer Anda tergantung pada hal -hal seperti prioritas proses atau pekerjaan latar belakang, tetapi Anda harus melihat penurunan yang kira -kira sama dalam waktu kompilasi.

Kinerja IDE biasanya dipengaruhi oleh penggunaan memori karena IDE, seperti Visual Studio, meng-host kompiler dalam layanan bahasa sebagai proses yang berumur panjang. Seperti proses server lainnya, semakin sedikit memori yang Anda gunakan, semakin sedikit waktu GC dihabiskan untuk membersihkan memori lama dan semakin banyak waktu yang dapat dihabiskan untuk memproses informasi yang berguna. Kami fokus pada dua bidang utama:

• Memanfaatkan file yang dipetakan memori untuk mendukung metadata yang dibaca dari kompiler
• Operasi ulang-ulang yang menemukan simbol di seluruh solusi, seperti menemukan semua referensi dan ganti nama

Hasilnya secara signifikan lebih sedikit penggunaan memori untuk solusi yang lebih besar saat menggunakan fitur IDE. Gambar 5 Menampilkan contoh penggunaan memori saat menjalankan Temukan referensi pada jenis string di Fake, basis kode sumber terbuka yang sangat besar, sebelum perubahan yang kami buat.

Operasi ini juga membutuhkan waktu satu menit dan 11 detik untuk diselesaikan saat dijalankan untuk pertama kalinya.

Dengan F# 5 dan alat F# yang diperbarui untuk Visual Studio, operasi yang sama membutuhkan waktu 43 detik untuk menyelesaikan dan menggunakan lebih dari 500MB lebih sedikit memori, seperti yang ditunjukkan pada Gambar 6.

Contoh dengan hasil yang ditunjukkan Gambar 5 Dan Gambar 6 ekstrem, karena sebagian besar pengembang tidak mencari penggunaan jenis dasar seperti string dalam basis kode yang sangat besar, tetapi ini menunjukkan seberapa jauh kinerja yang lebih baik ketika Anda menggunakan f# 5 dan tooling terbaru untuk f# dibandingkan dengan setahun yang lalu.

Kinerja adalah sesuatu yang terus -menerus dikerjakan, dan perbaikan sering kali berasal dari kontributor open source kami. Beberapa dari mereka termasuk Steffen Forkmann, Eugene Auduchinok, Chet Hust, Saul Rennison, Abel Braaksma, Isaac Abraham, dan banyak lagi. Setiap rilis menampilkan karya luar biasa oleh kontributor open source; Kami sangat berterima kasih atas pekerjaan mereka.

Perjalanan f# yang berkelanjutan dan bagaimana terlibat

Tim Microsoft F# sangat bersemangat untuk merilis F# 5 tahun ini dan kami harap Anda akan menyukainya sama seperti kami. F# 5 mewakili awal dari perjalanan baru bagi kami. Ke depan, kita akan terus meningkatkan pengalaman interaktif untuk menjadikan F# pilihan terbaik untuk notebook dan alat interaktif lainnya. Kami akan masuk lebih dalam dalam desain bahasa dan terus mendukung perpustakaan seperti diffsharp untuk menjadikan F# pilihan yang menarik untuk pembelajaran mesin. Dan seperti biasa, kami akan meningkatkan fundamen kompiler dan perkakas dan menggabungkan fitur bahasa yang dapat dinikmati semua orang.

Kami juga ingin melihat Anda ikut dalam perjalanan. F# sepenuhnya open source, dengan saran bahasa, desain bahasa, dan pengembangan inti semua terjadi di GitHub. Ada beberapa kontributor yang sangat baik saat ini dan kami mencari lebih banyak kontributor yang ingin memiliki kepentingan dalam bagaimana bahasa dan alat F# berevolusi bergerak maju.

Untuk terlibat pada tingkat teknis, lihat tautan berikut:

• F# Saran Bahasa: https: // github.com/fsharp/fslang-suggestions
• F# Desain Bahasa: https: // github.com/fsharp/fslang-desain
• F# pengembangan: https: // github.com/dotnet/fsharp
• F# berjalan di JavaScript: https: // fable.io/
• F# Tooling untuk Visual Studio Code: http: // ionide.io/
• F# berjalan di Web Assembly: https: // fsbolero.io/

F# Software Foundation juga meng-host komunitas Slack besar, selain menjadi titik utama bagi berbagai sub-komunitas untuk berbagi informasi satu sama lain. Gratis untuk bergabung, jadi pergilah ke situs web di sini untuk mempelajari lebih lanjut: http: // fondasi.fsharp.org/bergabung

Ingin memiliki suara di mana f# pergi selanjutnya dan bagaimana melakukannya? Bergabunglah dengan kami. Kami ingin bekerja sama.

Jupyter Notebooks

Jupyter Notebooks adalah alat pemrograman interaktif yang memungkinkan Anda mencampur markdown dan kode dalam dokumen. Kode dapat dieksekusi dalam buku catatan, seringkali untuk menghasilkan data atau bagan terstruktur yang berjalan seiring dengan penjelasan.

Jupyter Notebooks dimulai sebagai Ipython, alat pemrograman interaktif untuk program Python. Telah berkembang untuk mendukung banyak bahasa yang berbeda dan sekarang menjadi salah satu alat utama yang digunakan oleh para ilmuwan data dalam pekerjaan mereka. Itu juga digunakan sebagai alat pendidikan.

Tabel 1: Kompilasi waktu untuk fsharplus.Dll di seluruh versi F#

F# Pemrograman Bahasa: Sejarah, Manfaat, dan Kemungkinan Masa Depan

Pengembang nescient mungkin membuat kesalahan dengan mengucapkan nama sebagai f ‘Hash’ Tapi itu akan mendapatkan beberapa mata mencemooh dari yang mahir di pengembang’komunitas s. F tajam (karena # diucapkan sebagai tajam) adalah bahasa pemrograman open-source, sangat diketik, multi-paradigma. Bahasa pemrograman multi-paradigma termasuk pemrograman fungsional, imperatif dan berorientasi objek

Setiap bahasa pemrograman dapat jatuh ke dalam salah satu dari dua kategori; sangat diketik dan diketik dengan lemah.

Bahasa yang sangat diketik memiliki peraturan yang sangat keras kepala pada waktu kompilasi, menyiratkan bahwa kesalahan dan pengecualian lebih mungkin terjadi. Mayoritas peraturan ini mempengaruhi nilai pengembalian, penugasan variabel, dan panggilan fungsi.

Sementara bahasa yang diketik dengan lemah adalah sebaliknya dan memiliki aturan pengetikan longgar yang dapat menghemat hasil yang tidak terduga atau dapat menyebabkan konversi jenis implisit saat runtime.

Multi-paradigma mengacu pada dukungan lebih dari satu paradigma pemrograman untuk memungkinkan programmer memilih gaya pemrograman yang paling cocok dan konstruksi bahasa terkait untuk proyek yang diberikan.

Ini sering digunakan sebagai CLI lintas platform (infrastruktur bahasa umum) dan juga dapat menghasilkan kode javascript dan GPU (unit pemrosesan grafis).

Ini dikembangkan oleh F# Software Foundation dan Microsoft bersama dengan kontributor terbuka lainnya.

Sejarah Singkat

F# pertama kali muncul pada tahun 2005 ketika dikembangkan oleh Microsoft Research. Awalnya, itu adalah a .Net (diucapkan sebagai DOT NET) Implementasi OCAML karena menggabungkan kekuatan dan sintaksis bahasa fungsional dengan ribuan fungsi perpustakaan yang tersedia dengan .Bahasa bersih.

Sejak 2005, F# telah melalui banyak perubahan yang dibutuhkan dan pengembang membuat berbagai versi yang membuatnya lebih baik dari yang pertama. Meluncurkan di bawah lisensi Apache, menjadikan bahasa pemrograman bersumber terbuka yang berarti dapat dimodifikasi, didistribusikan dan digunakan tanpa membayar kepada pengembang asli.

Versi pertama yang diluncurkan pada tahun 2005 hanya kompatibel dengan windows dan digunakan a .Net 1.0 hingga 3.5 runtime. Pangkalan platform sempit adalah kelemahan terbesar dari versi ini. Masalah ini ditangani dalam versi berikutnya yang dikembangkan dengan penambahan OS X dan Linux ke platform yang didukung di versi 2.0 yang diluncurkan pada 2010.
Pada 2012, F# melihat penambahan JavaScript dan GPU di platform yang didukung. Versi terbaru diluncurkan pada 2015 yaitu 4.0.

Masa depan f#

Banyak orang mengklaim bahwa F# adalah salah satu bahasa pemrograman yang paling tidak populer, diremehkan dan kurang terwakili. Tapi ada sisi lain dari ceritanya. Menurut StackOverflow. F# telah terpilih sebagai bahasa yang terkait dengan gaji bergaji tertinggi secara global.

Survei yang sama menunjukkan bahwa F# tidak’t muncul dalam 25 bahasa pemrograman teratas yang digunakan di seluruh dunia. Bahasa tetap di pinggiran meskipun memiliki komunitas yang sangat aktif.

Tapi mengapa pengembang suka bekerja dengan f# jika itu’S sangat tidak populer? Dibuat dan dikelola oleh Don Syme, F# telah relatif tangguh dengan beberapa yang diasumsikan pelengkap yang diadopsi oleh bahasa FP serupa seperti Scala. Perlawanan ini mempertahankan aksesibilitas bagi pengembang dari dunia luar yang mungkin tertarik berkecimpung dalam pemrograman fungsional.

F# sangat bermanfaat ketika datang ke pengembangan berbasis data dan domain. Sekarang juga dapat dikompilasi ke dalam javascript yang merupakan dunia’S Bahasa Paling Populer. Dengan tautan ini aman, ia juga memiliki akses ke JavaScript’Perpustakaan dan basis perangkat yang luas.

F# telah membuat tanda ketika datang ke kecerdasan buatan, pembelajaran mesin, dan analisis data terkait. Itu adalah tujuan penciptaan f#. Karena skala besar dan pengaruh yang diharapkan, kecerdasan buatan akan memiliki ekosistem bahasa dan teknologi secara umum, memiliki bahasa yang sangat cocok untuk tempat pengembangan di dalamnya posisi yang kuat untuk tumbuh dengan cepat dan bahkan menantang bahasa populer seperti JavaScript dan Python di masa depan.

Apa yang berhenti f#’Pertumbuhan S?

Meskipun sepertinya fakta yang keras untuk dicerna, kesalahan untuk ini terutama disebabkan oleh penciptanya, yaitu Microsoft. Mereka telah membatasi popularitas F# membiarkan C# berkembang di luar sana. Microsoft telah membuat F# lebih rendah dari C#.

Ada gerakan siklik untuk itu. Beberapa pekerjaan yang ada untuk F# karena ada beberapa pengembang f# di luar sana dan ada lebih sedikit pengembang F# di luar sana karena ada lebih sedikit pekerjaan f# di luar sana. Tapi perlahan tapi pasti, tren ini berubah.

Jet.com adalah perusahaan besar pertama yang mengadopsi penggunaan f#. Kemudian, Kaggle dan banyak perusahaan keuangan dan asuransi juga mengikuti.

Pengembang F# tidak memiliki upaya untuk membuatnya lebih populer dan dengan fitur-fitur sebagai bahasa multi-paradigma yang sangat digunakan dalam AI, hal terbaik yang harus dilakukan adalah fokus pada manfaat inti dari F# yang merupakan runtime yang lebih pendek, lebih sedikit bug, dan produktivitas yang lebih tinggi. Jika dipromosikan dengan menyoroti fitur -fitur ini, mungkin membantu F# memanjat tangga popularitas lebih cepat dari sebelumnya.

Apakah F# benar -benar memiliki keuntungan apa pun dibandingkan C#?

Sudah akrab dengan C#? Kemudian pelajari cara memprogram game pelarian Anda sendiri menggunakan C#.

• F# membuat banyak tugas pemrograman umum lebih sederhana. Ini mensyaratkan hal -hal seperti membuat dan menggunakan definisi tipe yang kompleks, melakukan pemrosesan daftar, mesin negara, kesetaraan dan perbandingan, dan banyak lagi.
• Tanpa titik koma, kurung keriting dan semacamnya, dalam f# Anda hampir tidak perlu menentukan jenis objek karena adanya sistem inferensi tipe yang kuat. Dibutuhkan lebih sedikit baris kode untuk menyelesaikan masalah itu juga
• F# adalah bahasa fungsional, tetapi itu mendukung gaya lain yang dan’T benar sekali, membuatnya lebih mudah untuk berinteraksi dengan ranah database, situs web, dan sebagainya yang tidak murni. Secara khusus, F# dirancang sebagai bahasa hibrida/oo fungsional, sehingga dapat melakukan segalanya sebagai C#. Meskipun f# dengan mulus terintegrasi dengan .Ekosistem bersih yang memungkinkan Anda mengakses semua pihak ketiga .Alat dan perpustakaan bersih.
• F# adalah bagian dari Visual Studio yang memungkinkan Anda mendapatkan editor yang baik dengan dukungan Intellisense, debugger dan banyak plugin untuk tes unit, kontrol sumber, dan tugas pengembangan lainnya.

F# masa depan

Mirip dengan async < >memblokir tetapi menangkap hasil untuk konsumsi di masa depan. Struktur ini bisa sangat berguna untuk melakukan beberapa operasi pengembalian hasil secara paralel ketika hasilnya tidak diperlukan segera. Misalnya, melakukan beberapa operasi baca/transformasi atau pra-populasi cache dengan nilai yang belum dihitung. Perpustakaan Paralel Tugas Microsoft .Net 4.0 termasuk implementasi di masa depan sehingga versi ini hanya diperlukan pada sebelumnya .Versi bersih. Komentar, saran, dan perbaikan selalu diterima.

 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 

membuka Sistem membuka Sistem.ComponentModel membuka Sistem.Threading /// mengeksekusi perhitungan dalam pekerja latar belakang dan menyinkronkan pada hasil hasil. Itu /// Perhitungan dimulai segera dan memanggil blok 'Nilai' sampai hasilnya siap. jenis Masa depan'T>(F : satuan -> 'T) = /// hasil perhitungan pada pintu keluar normal. membiarkan yg mungkin berubah hasil :'T pilihan = Tidak ada /// hasil jika pengecualian dilemparkan. membiarkan yg mungkin berubah ext : Pengecualian pilihan = Tidak ada membiarkan Syncroot = baru Obyek() /// objek pulsa digunakan untuk menunggu sampai hasilnya siap. EnsurePulse () digunakan sehingga kami /// tidak perlu membuat objek jika hasilnya dilakukan sebelum dibutuhkan. membiarkan yg mungkin berubah detak : ManualResetEvent = batal membiarkan jawab() = kunci Syncroot (seru () -> cocok detak dengan | batal -> detak  baru ManualResetEvent(PALSU); | _ -> () detak) /// Peringatan: Hubungi Setelah Kunci di Syncroot Sudah Diadakan. Pulsa pemberitahuan menunggu. Aman jika /// dipanggil setelah 'pulsa' dibuat tetapi sebelum waitone dipanggil. membiarkan NotifyWaiters() = jika detak <> batal Kemudian detak.Mengatur() |> mengabaikan membiarkan bekerja = baru Pekerja latar() /// di runworkerasync (), jalankan fungsi yang ditentukan dan hasil penyimpanan. Semua pengecualian harus /// terperangkap. Mengerjakan bekerja.Bekerja.Menambahkan( seru args -> mencoba hasil  Beberapa( F()) dengan e -> ext  Beberapa e kunci Syncroot ( seru () -> NotifyWaiters())) /// Mulai segera/ secara otomatis. Mengerjakan bekerja.Runworkerasync() /// Mengembalikan nilai perhitungan, memblokir jika hasilnya belum siap. anggota T.Nilai = // Jika tersedia, kita dapat segera mengembalikannya. cocok hasil dengan | Beberapa X -> X | Tidak ada Kapan ext.Issome -> mengangkat (Pilihan.mendapatkan ext) | Tidak ada -> membiarkan P = jawab() // Periksa lagi jika itu berubah saat kami mendapatkan objek tunggu. cocok hasil dengan | Beberapa X -> X | Tidak ada -> // bebas kunci tidak apa-apa karena jika denyut nadi.Set () metode dipanggil antara saat kita // diperiksa 'hasil' dan hubungi WaitOne di sini, WaitOne akan segera kembali. P.WaitOne(1000000000) |> mengabaikan cocok hasil dengan | Beberapa X -> X | Tidak ada -> jika ext.Issome Kemudian mengangkat (Pilihan.mendapatkan ext) kalau tidak Failwith "Perhitungan di masa depan gagal." /// mengembalikan true jika perhitungan selesai, salah jika tidak. anggota T.ISComplete = cocok hasil dengan | Beberapa X -> BENAR | Tidak ada Kapan Pilihan.Issome ext -> BENAR | Tidak ada -> PALSU 

sistem namespace

sistem namespace.ComponentModel

sistem namespace.Threading

Beberapa item
ketik masa depan =
Baru: f: (unit -> 't) -> masa depan
Anggota ISComplete: Bool
Nilai Anggota: 'T

Nama Lengkap: Script.Masa depan

Mengeksekusi perhitungan dalam pekerja latar belakang dan menyinkronkan pada hasil pengembalian. Itu
Perhitungan dimulai segera dan memanggil blok 'nilai' sampai hasilnya siap.

val f: (unit -> 't)

ketik unit = unit

Nama Lengkap: Microsoft.Fsharp.Inti.satuan

Hasil Val Mutable: 'T Opsi

Hasil perhitungan pada pintu keluar normal.

Ketik Opsi T = Opsi

Nama Lengkap: Microsoft.Fsharp.Inti.pilihan

Opsi Kasus Union.Tidak ada: Opsi

Val Mutable Ext: Opsi Pengecualian

Hasil jika pengecualian dilemparkan.

Beberapa item
ketik pengecualian =
Baru: Unit -> Exception + 2 Overloads
Data Anggota: Idiksi
Anggota getBaseException: unit -> pengecualian
Anggota getObjectData: info: serialisasiinfo * konteks: streamingcontext -> unit
anggota getType: unit -> ketik
Helplink Anggota: String with Get, Set
Anggota InnerException: Pengecualian
Pesan Anggota: String
Sumber Anggota: String with Get, Set
Stacktrace Anggota: String
.

Nama Lengkap: Sistem.Pengecualian

--------------------
Exception (): Unit
Pengecualian (pesan: string): unit
Pengecualian (Pesan: String, InnerException: EXN): Unit

Val Syncroot: Objek

Beberapa item
ketik objek =
Baru: Unit -> Obj
Anggota Equals: Obj: Obj -> Bool
anggota getHashCode: unit -> int
anggota getType: unit -> ketik
anggota tostring: unit -> string
Anggota Statis Sama: OBJA: OBJ * OBJB: OBJ -> BOOL
Referensi Anggota Statis Diperimakan: OBJA: OBJ * OBJB: OBJ -> BOOL

Nama Lengkap: Sistem.Obyek

Val Mutable Pulse: ManualResetEvent

Objek pulsa digunakan untuk menunggu sampai hasilnya siap. EnsurePulse () digunakan sehingga kami
tidak harus membuat objek jika hasilnya dilakukan sebelum dibutuhkan.

Beberapa item
ketik manualResetEvent =
mewarisi Eventwaithandle
Baru: InitialState: Bool -> ManualResetEvent

Nama Lengkap: Sistem.Threading.ManualResetEvent

--------------------
ManualResetEvent (InitialState: Bool): Unit

Val EnsurePulse: (Unit -> ManualResetEvent)

Val Lock: LockObject: 'Lock -> Action: (Unit ->' t) -> 't (membutuhkan jenis referensi)

Nama Lengkap: Microsoft.Fsharp.Inti.Operator.kunci

Val NotifyWaiters: (Unit -> Unit)

PERINGATAN: Hubungi begitu kunci di Syncroot sudah diadakan. Pulsa pemberitahuan menunggu. Aman jika
Dipanggil setelah 'pulsa' dibuat tetapi sebelum WaitOne dipanggil.

Eventwaithandle.Set (): bool

val abaikan: nilai: 't -> unit

Nama Lengkap: Microsoft.Fsharp.Inti.Operator.mengabaikan

pekerjaan val: pekerja latar belakang

Beberapa item
ketik latar belakang pekerja =
Komponen mewarisi
BARU: Unit -> latar belakang pekerja
Anggota CancelAsync: Unit -> Unit
Anggota CancellationPending: Bool
Anggota Isbusy: Bool
Reportprogress anggota: Persentprogress: int -> unit + 1 kelebihan beban
Anggota runworkerasync: unit -> unit + 1 kelebihan
anggota workerreportsprogress: bool dengan get, set
Anggota WorkersupportScancellation: Bool with Get, Set
Acara Dowork: DoworkEventhandler
Acara ProgressChanged: ProgressChangedEventHandler
.

Nama Lengkap: Sistem.ComponentModel.Pekerja latar

Acara Latar Belakang.Dowork: Ievent

Anggota iobservable.Tambahkan: Callback 🙁 'T -> Unit) -> Unit

val args: doworkeventargs

Opsi Kasus Union.Beberapa: nilai: 't -> opsi

Val E: exn

Pekerja latar.Runworkerasync (): unit
Pekerja latar.Runworkerasync (argumen: obj): unit

Val T: Masa Depan

masa depan anggota.Nilai: 't

Nama Lengkap: Script.Masa depan`1.Nilai

Di runworkerasync (), jalankan fungsi yang ditentukan dan hasil penyimpanan. Semua pengecualian harus
terjebak.
Mulailah segera / secara otomatis.
Mengembalikan nilai perhitungan, memblokir jika hasilnya belum siap.

opsi properti.Issome: Bool

Val Raise: exn: Exception -> 't

Nama Lengkap: Microsoft.Fsharp.Inti.Operator.mengangkat

Val Get: Opsi: 'T Opsi ->' t

Nama Lengkap: Microsoft.Fsharp.Inti.Pilihan.mendapatkan

Val P: ManualResetEvent

Waithandle.Waitone (): bool
Waithandle.WaitOne (Timeout: TimeSpan): Bool
Waithandle.WaitOne (MillisecondStimeout: int): bool
Waithandle.WaitOne (Timeout: TimeSpan, ExitContext: Bool): Bool
Waithandle.WaitOne (MillisecondStimeout: int, ExitContext: bool): bool

val failwith: pesan: string -> 't

Nama Lengkap: Microsoft.Fsharp.Inti.Operator.Failwith

masa depan anggota.ISComplete: Bool

Nama Lengkap: Script.Masa depan`1.ISComplete

Mengembalikan true jika perhitungan selesai, salah jika tidak.

Val Issome: Opsi: Opsi T -> Bool

Nama Lengkap: Microsoft.Fsharp.Inti.Pilihan.Issome

Salin Tautan Salin Sumber Raw View Kode Uji Versi Baru

Informasi lebih lanjut

Membangun fungsional .Aplikasi bersih: Panduan untuk memilih antara F# vs C#

Efisiensi adalah segalanya di dunia pengembangan aplikasi. Pengembang dan organisasi yang bisa membuat produk ke pasar lebih cepat dan memberikan penyegaran yang lebih cepat akan selalu memiliki keunggulan atas kompetisi.

Jadi semua orang selalu mencari cara untuk mengurangi waktu pengembangan, waktu yang dihabiskan untuk debugging dan pengujian, dan waktu mendorong rilis yang sudah selesai untuk pelanggan.

Pemrograman fungsional terus digunakan beberapa dekade yang lalu tetapi kehilangan tanah dengan cepat untuk bahasa pemrograman yang berorientasi objek, yang segera menjadi standar de facto.

Konten yang disponsori terkait

Sponsor terkait

Kode, menggunakan, dan skala Java dengan cara Anda.
Microsoft Azure mendukung beban kerja Anda dengan pilihan berlimpah, apakah Anda sedang mengerjakan aplikasi Java, server aplikasi, atau kerangka kerja. Belajarlah lagi.

Namun dalam beberapa tahun terakhir, telah terjadi kebangkitan yang menarik dalam pemrograman fungsional sebagai cara untuk meningkatkan efisiensi pengembangan dan membangun aplikasi yang lebih stabil dan kuat.

C# dan F# adalah bahasa dengan basis pengguna yang tumbuh yang mendekati pemrograman fungsional dengan cara yang berbeda secara fundamental: C# sebagai tambahan untuk paradigma imperatif yang melekat dan f# sebagai paradigma utamanya.

Artikel ini menyelidiki bahasa mana yang melakukan pekerjaan terbaik untuk pengembang yang ingin menempatkan pemrograman fungsional untuk tim dan proyek mereka.

Perdebatan tentang pemrograman fungsional vs yang berorientasi objek

Untuk memahami perdebatan, kita harus mulai pada tingkat yang sedikit lebih tinggi dengan perbedaan antara paradigma pemrograman imperatif dan deklaratif.

• Pemrograman Imperatif: Pendekatan pemrograman berbasis proses, di mana pengembang menentukan bagaimana mencapai hasil langkah demi langkah. Pemrograman imperatif berfokus pada perubahan keadaan dan keadaan program. Bahasa pemrograman yang berorientasi objek seperti Java dan C ++ umumnya mengikuti paradigma imperatif.
• Pemrograman deklaratif: Pendekatan pemrograman berorientasi hasil, di mana pengembang menentukan jenis hasil yang diinginkan. Pemrograman deklaratif adalah stateless dan ordo eksekusi agnostik. Bahasa pemrograman fungsional seperti Lisp, Python, Haskell, dan F# ikuti paradigma pemrograman deklaratif.

Tetapi ini merupakan penyederhanaan yang berlebihan untuk mencoba dan membagi semua bahasa pemrograman yang ada ke dalam kategori -kategori ini, karena beberapa bahasa menawarkan aspek masing -masing. Mereka adalah bahasa hibrida atau multi-paradigma.

Misalnya, meskipun Java dan C ++ secara tradisional termasuk dalam klasifikasi imperatif, mereka juga memiliki aspek fungsional. Hal yang sama berlaku untuk C#. Demikian pula, meskipun F# dianggap sebagai bahasa fungsional, ia juga memiliki kemampuan imperatif.

Lihatlah daftar sepuluh bahasa teratas yang digunakan pengembang. Anda akan melihat bahwa mereka mencakup sebagian besar bahasa hibrida, dengan beberapa berfokus pada imperatif dan yang lainnya lebih dominan fungsional.

Javascript, yang telah memegang posisi teratas dalam survei ini selama satu dekade, adalah bahasa multi-paradigma, menawarkan kedua fitur imperatif dan berorientasi objek dan fitur fungsional.

Mengingat kisaran adopsi, akan sangat membantu untuk mempertimbangkan berbagai manfaat yang disajikan setiap paradigma dan berbagai kasus penggunaan di mana masing -masing unggul.

Pemrograman Imperatif: Manfaat dan Kasus Penggunaan

Di antara manfaat utama dari paradigma imperatif adalah bahwa kode yang ditulis menggunakannya umumnya mudah dipahami dan dapat dengan mudah dibaca. Selain itu, mengingat deskripsi alur kerja yang cermat yang dibutuhkan pemrograman imperatif, bahkan pengembang pemula merasa mudah diikuti.

Tetapi tingkat detail pemrograman imperatif membutuhkan juga dilengkapi dengan kerugian. Misalnya, dalam aplikasi yang lebih kompleks, kode dapat dengan cepat menjadi kembung. Saat ukuran kode meningkat, kemudahan membaca dan pemahaman dengan cepat jatuh.

Selain itu, seiring dengan meningkatnya kode, potensi bug dan kesalahan meningkat. Dengan demikian, pengembang yang bekerja dengan bahasa imperatif sering menemukan diri mereka menghabiskan banyak waktu untuk men -debug dan pengujian, menunda rilis produk.

Meskipun demikian, pemrograman imperatif tetap sangat populer dan memiliki berbagai kasus penggunaan. Aplikasi tradisional untuk pemrograman imperatif meliputi:

• Hypertext dan Hypermedia
• Sistem Manajemen Database Objek (ODBMS)
• Sistem klien-server
• Sistem real-time
• Kecerdasan buatan, pembelajaran mesin, dan jaringan saraf
• Otomatisasi

Pemrograman Fungsional: Kasing Manfaat dan Penggunaan

Manfaat pemrograman fungsional lebih banyak di sisi efisiensi persamaan. Kode fungsional, sementara kurang mudah dibaca dan dipahami pada pandangan pertama, cenderung lebih dekat dengan bug-bebas (i.e., Tidak ada efek samping untuk perubahan negara), mengurangi waktu pengembang yang dihabiskan untuk debugging dan pengujian.

Lebih sedikit bug juga cocok untuk aplikasi yang lebih aman, membatasi permukaan serangan untuk penjahat cyber untuk mengurangi kemungkinan serangan ransomware, malware, atau suntikan SQL.

Pemrograman fungsional juga lebih baik pada pemrosesan paralel dan evaluasi malas. Selain itu, kode fungsional lebih modular dan dapat digunakan kembali, mengurangi kebutuhan akan kode yang berlebihan. Set kode yang lebih kecil lebih mudah dipelihara dan dapat lebih tinggi berkinerja lebih tinggi. Namun, kode fungsional bisa intensif memori, menghilangkan manfaat kecepatan dari ukuran kode yang dikurangi dan benar -benar mengarah pada penurunan kinerja keseluruhan.

Pemrograman fungsional sangat populer di kalangan ilmuwan akademisi dan data, karena efektif dalam menangani manipulasi set data besar.

Mengingat fokusnya pada pemrosesan paralel dan keabadian, pemrograman fungsional sangat berguna untuk:

• Ilmu Data
• Aplikasi spreadsheet
• Aplikasi Keuangan dan Risiko
• Pemrosesan batch

Pemrograman Fungsional: C# vs F#

C# dan F# adalah bahasa yang telah mendapatkan popularitas dalam beberapa tahun terakhir. Meskipun mereka berdua multi-paradigma, fokus utama mereka berbeda, dengan C# mengandalkan prinsip-prinsip penting yang berorientasi objek dan mengandalkan prinsip-prinsip fungsional. Tetapi apakah yang satu mengungguli yang lain ketika datang ke pemrograman fungsional?

Apa itu C#, dan siapa yang menggunakannya?

C# adalah bahasa multi-paradigma, berorientasi objek yang pertama kali dirilis oleh Microsoft sekitar 20 tahun yang lalu. Seperti yang dapat Anda lihat dari statistik penggunaan di atas, itu adalah bahasa kedelapan yang paling populer di kalangan pengembang pada tahun 2022, dengan hampir sepertiga pengembang menggunakannya. Ini juga memiliki skor kepuasan tinggi, dengan dua pertiga pengguna C# mengatakan mereka suka menggunakannya.

C# menemukan banyak kegunaan dalam pengembangan layanan web dan cloud, serta pengembangan game. Perusahaan dari Microsoft ke TrustPilot ke StackOverflow membuat aplikasi dan layanan dengan C#.

Pemrograman fungsional di C#

Meskipun C# terutama berorientasi objek dan berubah-ubah/stateful, ia memang memiliki kemampuan fungsional. Berikut adalah beberapa cara untuk mengimplementasikan paradigma fungsional di C#.

Buat kekekalan

Karena tipe data di C# secara inheren dapat berubah, ketika Anda ingin menggunakan prinsip pemrograman fungsional, Anda perlu membuat kekekalan. Dan ini lebih rumit daripada sekadar mengandalkan tipe data yang tidak dapat diubah di F#. Secara khusus, untuk membuat tipe yang tidak dapat diubah di C#, Anda harus membuat tipe baca-saja, menghapus properti setter, menggunakan konstruktor untuk memberikan parameter, dan kemudian membuat instance baru setiap kali perubahan keadaan diperlukan, alih-alih bermutasi instance yang ada yang ada.

Gunakan Ekspresi Linq dan Lambda

Microsoft Membangun Kerangka Kerja Linq (Bahasa Terpadu) khusus untuk memperkenalkan fitur pemrograman fungsional ke dalam C#. LINQ menyediakan fungsi untuk beroperasi pada daftar atau urutan, termasuk pemetaan (pilih), penyortiran (orderby), dan penyaringan (di mana). Masing -masing ekspresi ini memiliki fungsi untuk argumen. Ekspresi membuat instance baru dari urutan alih -alih bermutasi urutan yang ada. LINQ sangat berguna untuk menanyakan set data, apakah tabel SQL, data XML, atau sumber lain.

Linq juga memungkinkan penggunaan ekspresi lambda, yang pada dasarnya adalah fungsi anonim. Fungsi anonim adalah aspek kunci dari pemrograman fungsional. Ekspresi lambda dapat bertindak sebagai argumen untuk fungsi lain dalam kode, membuat fungsi tingkat tinggi, fitur umum lain dari pemrograman fungsional.

Gunakan rantai metode

Fitur F# yang umum digunakan adalah operator pipa, yang melewati hasil satu fungsi ke fungsi lain. Pipelining tidak dibangun menjadi C, tetapi pengembang dapat meniru pipa dalam situasi tertentu menggunakan rantai metode, atau antarmuka yang lancar. Ini dapat dilakukan dengan menggunakan fungsionalitas StringBuilder di C#.

Rantai metode juga memungkinkan Anda untuk mereplikasi fitur umum lain dari pemrograman fungsional, kari. Kari memungkinkan fungsi dengan beberapa argumen untuk menerima argumen tersebut pada waktu yang berbeda. Pada dasarnya, dalam pemrograman fungsional, jika suatu fungsi tidak menerima semua input yang diperlukan, ia mengembalikan fungsi baru dengan input yang hilang sebagai argumennya.

Dalam C#, Anda menerapkan kari dengan rantai metode untuk menguraikan argumen multi-fungsi menjadi urutan bersarang dari beberapa fungsi argumen tunggal. Namun, ini tidak rapi atau seefisien di f#.

Ini hanyalah beberapa cara pengembang C# yang terampil dapat menerapkan prinsip pemrograman fungsional di C#. Dan sementara mereka mungkin memerlukan lebih banyak usaha daripada hanya menggunakan F#, bagi para pengembang yang menginginkan semua fitur lain yang ditawarkan C#, mereka adalah alternatif yang layak.

Apa itu f#, dan siapa yang menggunakannya?

Awalnya dirilis oleh Microsoft untuk platform Windows pada tahun 2005, F# adalah bahasa pemrograman yang sebagian besar fungsional. Ini diperluas untuk mencakup platform Linux dan MacOS pada tahun 2010, dan kemudian JavaScript pada 2013. Juga, pada tahun 2013, Yayasan Perangkat Lunak F# diluncurkan untuk mendukung Microsoft dalam pengembangannya dan F# dan komunitas F#.

Sejak awal, komunitas F# telah tumbuh dengan mantap, jika perlahan. Sekarang termasuk grup GitHub serta banyak proyek komunitas yang berbeda, dari javascript transpiler (fable) hingga manajer paket (Paket) hingga perpustakaan pengembangan web (Suave) dan banyak lagi.

Meskipun usianya, F# masih memiliki ruang besar untuk diadopsi. Statistik penggunaan umum agak sulit didapat, tetapi survei 2021 oleh jetbrains lebih dari 30000 pengembang mengindikasikan bahwa hanya 1% yang baru -baru ini menggunakan f# atau berencana untuk melakukannya dalam waktu dekat. Sebagai perbandingan, 21% baru -baru ini menggunakan C#, dan 4% berencana untuk segera menggunakannya. Dan F# memiliki peringkat kepuasan yang sedikit lebih rendah daripada C#, meskipun lebih dari 60% pengembang mengatakan mereka suka menggunakannya.

Saat ini, ada kurang dari 100 perusahaan yang diketahui menggunakan f# dalam produksi, meskipun mereka menyertakan beberapa nama terkenal seperti Walmart dan Huddle.

Beberapa pengembang menggunakan F# sebagai pelengkap C#, daripada mengandalkan kemampuan fungsional yang ada secara asli di C#. Karena keduanya dikompilasi .Net Net Intermediate Languages ​​(IL), dimungkinkan untuk menggunakan keduanya dalam proyek yang sama.

Bahasa mana yang memiliki keunggulan untuk pemrograman fungsional?

Sepertinya ini harus menjadi pertanyaan yang sangat sederhana untuk dijawab: F# berfungsi pertama, sedangkan C# sangat penting pertama, jadi keunggulan masuk ke f#. Dan di level tertinggi, pernyataan ini benar. Tetapi pengembangan aplikasi, seperti kehidupan, jarang cukup sederhana untuk penerapan umum kebenaran tingkat tinggi.

Pertanyaan yang lebih baik untuk ditanyakan adalah bahasa mana yang tepat untuk Anda, tim Anda, dan proyek yang sedang Anda kerjakan saat ini. Dan ini adalah pertanyaan yang jauh lebih kompleks untuk dijawab.

Memilih bahasa yang tepat untuk pemrograman fungsional

Saat memilih antara C# dan F# untuk kebutuhan pemrograman fungsional Anda, ada beberapa pertimbangan yang harus menjadi faktor dalam keputusan Anda:

• Apa kebutuhan proyek? Set fitur spesifik dari aplikasi Anda mungkin membawa Anda jauh dalam proses pengambilan keputusan. Misalnya, jika fitur terpenting dari aplikasi Anda berputar di sekitar elemen antarmuka pengguna, dengan hanya manipulasi data kecil, maka Anda mungkin ingin fokus pada C#. Tetapi jika aplikasi Anda intensif data dan elemen UI kurang penting, Anda mungkin akan condong ke arah f#.
• Apa tingkat kenyamanan Anda dengan setiap bahasa? Jika aplikasi Anda akan mendapat manfaat dari pemrograman fungsional, tetapi Anda&rsquo;T cukup berpengalaman dengan C# untuk dengan mudah menangani manipulasi yang diperlukan untuk membuat tipe abadi dan menerjemahkan dari deklarasi ke ekspresi, maka Anda harus mempertimbangkan f#.
• Bagaimana tim Anda akan berurusan dengan berbagai bahasa? Saat bekerja dengan tim pengembangan, Anda perlu mempertimbangkan keahlian dan pengalaman setiap anggota tim. Anda mungkin memiliki satu pengembang f# yang sangat terampil, tetapi yang lain dengan sedikit atau tanpa paparan ke f#. Ini dapat menyebabkan kesulitan bagi anggota tim dalam bekerja dengan kode yang ditulis oleh pengembang lain.
• Adalah pendekatan multi-bahasa yang terbaik? Apakah tim pengembangan Anda cukup terampil untuk membuat C# dan F# bekerja bersama pada proyek yang sama? Apakah ada alasan bahwa salah satu dari bahasa ini tidak sendirian&rsquo;T cukup mengatasi semua kebutuhan aplikasi Anda? Tapi pikirkan dengan cermat sebelum mengambil pendekatan ini - Anda hanya boleh melakukannya jika lebih efisien dan lebih efektif daripada menggunakan kedua bahasa secara terpisah.

Kesimpulan

Ketika proyek pengembangan menuntut pemrograman fungsional, ada banyak opsi yang tersedia untuk tim pengembangan, dari bahasa fungsional murni hingga bahasa multi-paradigma seperti C# dan F#. Membuat pilihan terbaik di antara opsi yang bersaing yang baik tidak selalu sederhana, tetapi waktu yang diinvestasikan dalam membuat keputusan itu akan dihargai dengan peningkatan efisiensi pengembangan dan produk yang lebih baik.