**F#** ialah sebuah bahasa pengaturcaraan beraneka-paradigma yang dibangunkan oleh Microsoft untuk .NET Framework. Ia merupakan varian bagi ML yang berorientasikan pragmatik. Ia berkongsi bahasa teras dengan OCaml.

Sejarah
-------

F# dilahirkan di Microsoft Research, Cambridge dan bahasa ini mula-mula direka bentuk dan dilaksanakan oleh Don Syme. Andrew Kennedy menyumbang kepada reka bentuk unik ukuran. Bahasa F# dan perkakas Visual F# untuk Windows pula telah dibangunkan oleh Microsoft. F# Software Foundation kemudian membangunkan pengkompil bersumber terbuka dan perkakas untuk F# berasaskan sebahagian daripada keluaran sumber terbuka oleh pasukan Visual F# Microsoft.

Contoh
------

Berikut ialah beberapa contoh ringkas:

```
// Komen untuk atur cara indahnya dunia.
printfn "Indahnya dunia!"

```

Kelas Orang yang pembinanya menerima nama dan umur serta dua sifat.

```
/// This is a documentation comment for a type definition.
type Orang(nama : string, umur : int) =
 member x.Nama = nama
 member x.Umur = umur

```

Contoh ringkas yang selalu digunakan untuk menunjukkan sintaks bahasa-bahasa kefungsian iaitu fungsi faktorial bagi integer 32-bit bukan negatif, di dalam F#:

```
/// Ini komen pendokumenan bagi sebuah fungsi.
let rec factorial n =
 match n with
 | 0 -> 1
 | \_ -> n \* factorial (n - 1)

```

Contoh lelaran (*iteration*):

```
/// Lelaran menggunakan gelung 'for'
let printList lst = 
 for x in lst do 
 printfn "%d" x

/// Lelaran mengunakan fungsi tertib lebih tinggi
let printList2 lst = 
 List.iter (printfn "%d") lst

/// Lelaran menggunakan fungsi rekursif dan pemadanan corak
let rec printList3 lst =
 match lst with 
 | [] -> ()
 | h :: t -> 
 printfn "%d" h
 printList t

```

Contoh Fibonacci:

```
/// Formula Nombor Fibonacci
let rec fib n =
 match n with
 | 0 | 1 -> n
 | \_ -> fib (n - 1) + fib (n - 2)

/// Cara lain - jujukan takterhingga malas bagi nombor Fibonacci
let fibSeq = Seq.unfold (fun (a,b) -> Some(a+b, (b, a+b))) (1,1)

// Papar nombor Fibonacci genap
[1 .. 10]
|> List.map fib
|> List.filter (fun n -> (n % 2) = 0)
|> printList

// Benda yang sama, menggunakan sebutan senarai
[ for i in 1..10 do
 let r = fib i
 if r % 2 = 0 then yield r ]
|> printList

```

Atur cara Windows Forms mudah:

```
// Buka pustaka Windows Forms 
open System.Windows.Forms

// Cipta sebuah tetingkap dan tetapkan beberapa sifat
let form = new Form(Visible=true, TopMost=true, Text="Welcome to F#")

// Cipta sebuah label untuk memaparkan teks di dalam form
let label =
 let x = 3 + (4 \* 5)
 new Label(Text = sprintf "x = %d" x)

// Letakkan label di atas form
form.Controls.Add(label)

// Akhir sekali, jalan form tadi
[<System.STAThread>]
Application.Run(form)

```

Contoh pengaturcaraan selari taksegerak (Tugas CPU dan I/O selari):

```
/// A very naive prime number detector 
let isPrime (n:int) =
 let bound = int (sqrt (float n))
 seq {2 .. bound} |> Seq.forall (fun x -> n % x <> 0) 

// We are using async workflows 
let primeAsync n =
 async { return (n, isPrime n) }

/// Pulangkan nombor perdana antar m dan n menggunakan lebih daripada satu thread
let primes m n =
 seq {m .. n}
 |> Seq.map primeAsync
 |> Async.Parallel
 |> Async.RunSynchronously
 |> Array.filter snd
 |> Array.map fst

// Jalankan ujian 
primes 1000000 1002000
 |> Array.iter (printfn "%d")

```

Rujukan
-------

1. ↑  Syme, Granicz & Cisternino (2007:2) "F# also draws from Haskell particularly with regard to two advanced language features called *sequence expressions* and *workflows*."
2. 1 2 3  "F# Historical Acknowledgements". Dicapai pada 2012-11-24.

Lihat juga
----------

* ML (bahasa pengaturcaraan)
* OCaml

Pautan luar
-----------

* F# di Microsoft Research
* Laman F#
* Panduan cepat pengaturcaraan F# Diarkibkan 2009-09-29 di Wayback Machine