learnxinyminutes-docs/tr-tr/fsharp-tr.html.markdown

---
language: F#
contributors:
    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
translators:
    - ["Mustafa Zengin", "http://zengin.github.com/"]
filename: learnfsharp-tr.fs
lang: tr-tr
---

F# fonksiyonel ve nesne yönelimli, genel amaçlı bir programlama dilidir. Bedava ve açık kaynaklıdır ve Linux, Mac, Windows ve dahasında çalışır.

Hataları derleme zamanında yakalayan çok güçlü bir tip sistemine sahiptir, ancak tip çıkarımı yaptığından dinamik bir dil gibi görünür.

F#'ın söz dizimi C-stili dillerden farklıdır:

* Küme parantezi kod bloklarını ayırmak için kullanılmaz. Bunun yerine Python'da olduğu gibi girinti kullanılır.
* Parametreleri birbirinden ayırmak için virgül yerine boşluk karakteri kullanılır.

Aşağıdaki kodu denemek istiyorsanız, [tryfsharp.org](http://www.tryfsharp.org/Create)'a gidin be interaktif REPL'e kodu yapıştırın.

```fsharp
// tek satır yorumlar ikili bölme işareti ile başlar
(* çok satırlı yorumlar ( * . . . * ) ikilisini kullanır

-çok satırlı yorumun sonu- *)

// ================================================
// Temel Söz Dizimi
// ================================================

// ------ "Değişkenler" (tam da değil) ------
// "let" anahtar kelimesi (değişmez) değer tanımlar
let tamsayım = 5
let ondalığım = 3.14
let stringim = "merhaba"           // tip bilgisi olmamasına dikkat

// ------ Listeler ------
let ikidenBeşe = [2; 3; 4; 5]      // Köşeli parantezler listeleri oluşturur,
                                   // değerler ise noktalı virgülle ayrılır.
let birdenBeşe = 1 :: ikidenBeşe   // :: yeni birinci elemanı olan bir liste oluşturur.
// Sonuç: [1; 2; 3; 4; 5]
let sıfırdanBeşe = [0; 1] @ ikidenBeşe  // @ iki listeyi birbirine ekler.

// ÖNEMLİ: virgüller hiçbir zaman ayraç olarak kullanılmaz, sadece noktalı virgüller!

// ------ Fonksiyonlar ------
// "let" anahtar kelimesi isimlendirilmiş fonksiyonları da tanımlar.
let kare x = x * x          // Parantez kullanılmadığına dikkat.
kare 3                      // Şimdi fonksiyonu uygulayın. Yine parantez yok.

let topla x y = x + y       // topla (x,y) kullanmayın! Bu tamamen başka bir anlama geliyor.
topla 2 3                   // Şimdi fonksiyonu uygulayın.

// çok satırlı bir fonksiyon tanımlamak için sadece girinti kullanın. Noktalı virgül gerekmez.
let çiftler liste =
   let çiftMi x = x % 2 = 0     // "çiftMi"yi alt fonksiyon olarak tanımlayın
   List.filter çiftMi liste     // List.filter 'boolean bir fonksiyon' ve
                                // 'üzerinde çalışılacak bir liste' parametrelerinden oluşan
                                // bir kütüphane fonksiyonu
                              
çiftler birdenBeşe              // Şimdi fonksiyonu uygula.

// Parantezleri önceliği netleştirmek için kullanabilirsiniz. Bu örnek
// "map"i önce iki argümana, sonra sonuç üzerinde "ekle" uyguluyor.
// Parantezler olmasaydı, "List.map" List.sum'ın ilk argümanı olurdu.
let yüzeKadarKarelerinToplamı =
   List.sum ( List.map kare [1..100] )

// Bir operasyonun sonucunu bir sonrakine "|>" kullanarak besleyebilirsin.
// Veri beslemek F#'ta UNIX'te olduğu gibi yaygındır..

// Burada yüzeKadarKarelerinToplamı fonksiyonunun veri beslemeyle yazılmış hali var:
let veriBeslemeyleYüzeKadarKarelerinToplamı =
   [1..100] |> List.map kare |> List.sum  // "kare" önceden tanımlanmıştı

// Lambda'ları (anonim fonksiyonları) "fun" anahtar kelimesiyle tanımlayabilirsin
let funlaYüzeKadarKarelerinToplamı =
   [1..100] |> List.map (fun x -> x * x) |> List.sum

// F#'ta "return" anahtar kelimesi yoktur. Bir fonksiyon
// her zaman son kullanılan ifadeyi döndürür.

// ------ Kalıp eşleştirme ------
// Match..with.. çok güçlü bir case/switch türevidir.
let basitKalıpEşleştirme =
   let x = "a"
   match x with
    | "a" -> printfn "x a'dır"
    | "b" -> printfn "x b'dir"
    | _ -> printfn "x başka bir şeydir"   // alt çizgi bütün kalıplarla eşleşir

// F# varsayılan olarak null'lara izin vermez -- Option tipini kullanıp
// kalıp eşleştirme yapmalısın.
// Some(..) ve None, Nullable tipler gibidir.
let geçerliDeğer = Some(99)
let geçersizDeğer = None

// Bu örnekte, match..with "Some" ve "None"la eşleştirme yapıyor,
// ve ayrıca "Some" içerisindeki değeri de çıkarıyor.
let optionKalıpEşleştirme input =
   match input with
    | Some i -> printfn "input is an int=%d" i
    | None -> printfn "input is missing"

optionKalıpEşleştirme geçerliDeğer
optionKalıpEşleştirme geçersizDeğer

// ------ Yazdırma ------
// printf/printfn fonksiyonları C#'taki 
// Console.Write/WriteLine fonksiyonlarına benzer.
printfn "Bir tamsayı %i, bir ondalık %f, bir boolean %b yazdırma" 1 2.0 true
printfn "Bir string %s, ve jenerik bir tip %A" "merhaba" [1; 2; 3; 4]

// sprintf/sprintfn fonksiyonları ise veriyi string'e
// çevirmek içindir, C#'taki String.Format gibi.

// ================================================
// Fonksiyonlar hakkında dahası
// ================================================

// F# gerçek bir fonksiyonel dildir. Fonksiyonlar birinci
// sınıf varlıklardır ve güçlü yapılar oluşturmak için
// birleştirilebilirler.

// Modüller fonksiyonları gruplamak için kullanılır.
// Her bir modül için girinti gerekir.
module FonksiyonOrnekleri =

    // Temel bir ekleme fonksiyonu tanımla
    let topla x y = x + y

    // Bir fonksiyonun temel kullanımı
    let a = topla 1 2
    printfn "1 + 2 = %i" a

    // Parametreleri kaynaklamak için parçalı uygulama
    let kırkİkiEkle = topla 42
    let b = kırkİkiEkle 1
    printfn "42 + 1 = %i" b

    // Fonksiyonları birleştirmek için kompozisyon
    let birEkle = topla 1
    let ikiEkle = topla 2
    let üçEkle = birEkle >> ikiEkle
    let c = üçEkle 7
    printfn "3 + 7 = %i" c

    // Yüksek dereceli fonksiyonlar
    [1..10] |> List.map üçEkle |> printfn "yeni liste: %A"

    // Fonksiyonlar listesi ve dahası
    let altıEkle = [birEkle; ikiEkle; üçEkle] |> List.reduce (>>)
    let d = altıEkle 7
    printfn "1 + 2 + 3 + 7 = %i" d

// ================================================
// Listeler ve kolleksiyonlar
// ================================================

// Üç çesit sıralı fonksiyon vardır:
// * Listeler en temel değiştirilemez kolleksiyonlardır.
// * Diziler değiştirilebilir ve gerektiğinde daha verimlidirler.
// * Seriler tembel (lazy evaluation) ve sonsuzdurlar (Enumeratörler gibi). 
// 
// Değiştirilmez map'ler ve kümeler ve bütün .NET kolleksiyonları
// diğer kolleksiyon türleridir.

module ListeÖrnekleri =

    // listeler köşeli parantez kullanır
    let liste1 = ["a"; "b"]
    let liste2 = "c" :: liste1    // :: başa eleman ekler
    let liste3 = liste1 @ liste2   // @ listeleri birbirine ekler

    // Liste comprehension'ları (jeneratörler olarak da bilinir)
    let kareler = [for i in 1..10 do yield i * i]

    // asal sayı jeneratörü
    let rec elek = function
        | (p::xler) -> p :: elek [ for x in xler do if x % p > 0 then yield x ]
        | []      -> []
    let asallar = elek [2..50]
    printfn "%A" asallar

    // Listelerle kalıp eşleştirme
    let listeEşleyici liste =
        match liste with
        | [] -> printfn "liste boş"
        | [birinci] -> printfn "listede sadece bir eleman var: %A " birinci
        | [birinci; ikinci] -> printfn "liste: %A ve %A" birinci ikinci
        | _ -> printfn "listede ikiden fazla eleman var"

    listeEşleyici [1; 2; 3; 4]
    listeEşleyici [1; 2]
    listeEşleyici [1]
    listeEşleyici []

    // Listeleri kullanarak recursion
    let rec ekle liste =
        match liste with
        | [] -> 0
        | x::xler -> x + ekle xler
    ekle [1..10]

    // -----------------------------------------
    // Standart kütüphane fonksiyonları
    // -----------------------------------------

    // map
    let üçEkle x = x + 3
    [1..10] |> List.map üçEkle

    // filter
    let çift x = x % 2 = 0
    [1..10] |> List.filter çift

    // ve dahası -- dökümantasyona bakınız

module DiziÖrnekleri =

    // Diziler köşeli parantezle birlikte çubuk karakterini kullanır
    let dizi1 = [| "a"; "b" |]
    let birinci = dizi1.[0]        // nokta kullanarak indeks erişimi

    // Diziler için kalıp eşleştirme listlerle aynıdır
    let diziEşleştirici liste =
        match liste with
        | [| |] -> printfn "dizi boş"
        | [| birinci |] -> printfn "dizide sadece bir eleman var: %A " birinci
        | [| birinci; ikinci |] -> printfn "dizi: %A ve %A" birinci ikinci
        | _ -> printfn "dizide ikiden fazla eleman var"

    diziEşleştirici [| 1; 2; 3; 4 |]

    // Listede olduğu gibi kütüphane fonksiyonları

    [| 1..10 |]
    |> Array.map (fun i -> i + 3)
    |> Array.filter (fun i -> i % 2 = 0)
    |> Array.iter (printfn "değer: %i. ")


module SeriÖrnekleri =

    // seriler kıvrık parantez kullanır
    let seri1 = seq { yield "a"; yield "b" }

    // seriler yield'ı kullanabilir
    // ve alt seriler barındırabilir
    let garip = seq {
        // "yield" bir eleman ekliyor
        yield 1; yield 2;

        // "yield!" bütün bir alt seriyi ekliyor
        yield! [5..10]
        yield! seq {
            for i in 1..10 do
              if i % 2 = 0 then yield i }}
    // test
    garip |> Seq.toList


    // Seriler "unfold" kullanılarak oluşturulabilir
    // Fibonacci serisi örneği
    let fib = Seq.unfold (fun (birinci,ikinci) ->
        Some(birinci + ikinci, (ikinci, birinci + ikinci))) (0,1)

    // test
    let fib10 = fib |> Seq.take 10 |> Seq.toList
    printf "ilk 10 fibonacci sayısı: %A" fib10


// ================================================
// Veri Tipleri
// ================================================

module VeriTipiÖrnekleri =

    // Bütün veriler varsayılan olarak değiştirilemezdir.

    // -- Tuple oluşturmak için virgül kullan
    let ikiliTuple = 1, 2
    let üçlüTuple = "a", 2, true
    
    // Tuple'lar çabuk ve kolay anonim tiplerdir.
    // paketi açmak için kalıp eşleştirme kullan
    let x, y = ikiliTuple  // x = 1, y = 2

    // ------------------------------------
    // Record tipi isimlendirilmiş alanlara sahiptir
    // ------------------------------------

    // "type" ile kıvrık parantezleri record tipi oluşturmak için kullan
    type Kişi = {Ad:string; Soyad:string}

    // "let" ile kıvrık parantezi record tipi oluşturmak için kullan
    let kişi1 = {Ad="Falanca"; Soyad="Kişi"}

    // paketi açmak için kalıp eşleştirme kullan
    let {Ad = Ad} = kişi1    // birinci="John"

    // ------------------------------------
    // Union tipleri (değişkenler olarak da bilinir) birden fazla
    // seçeneğe sahiptir. Belli bir zamanda sadece bir tanesi geçerlidir.
    // ------------------------------------

    // "type" ile çubuk karakterini union tipi tanımlamak için kullan
    type Sıcaklık =
        | Santigrat of float
        | Fahrenhayt of float

    // Seçeneklerden birini kullan
    let derece1 = Fahrenhayt 98.6
    let derece2 = Santigrat 37.0

    // Paketi açmak için bütün seçenekler üzerinde kalıp eşleştirme kullan
    let dereceYazdır = function
       | Santigrat t -> printfn "%f C" t
       | Fahrenhayt t -> printfn "%f F" t

    dereceYazdır derece1
    dereceYazdır derece2

    // ------------------------------------
    // Yinelgen (Recursive) tipler
    // ------------------------------------

    // Tipler alt sınıflar oluşturmadan karmaşık şekillerde
    // yinelgen olarak birleştirilebilirler.
    type Çalışan =
      | İşçi of Kişi
      | Yönetici of Çalışan list

    let falancaKişi = {Ad="Falanca"; Soyad="Kişi"}
    let işçi = İşçi falancaKişi

    // ------------------------------------
    // Tipleri Kullanarak Modelleme
    // ------------------------------------

    // Union tipleri bayrak kullanmadan durum modelleme için harikadır.
    type EpostaAdresi =
        | GeçerliEpostaAdresi of string
        | GeçersizEpostaAdresi of string

    let epostaGöndermeyiDene eposta =
        match eposta with                     // kalıp eşleştirme kullan
        | GeçerliEpostaAdresi adres -> ()     // gönder
        | GeçersizEpostaAdresi adres -> ()    // gönderme

    // Union tiplerin record tiplerle birleşimi
    // domain driven design için iyi bir temel oluşturur.
    // Domain'i yansıtan yüzlerce ufak tip oluşturabilirsiniz.

    type Ürün = { ÜrünKodu: string; Miktar: int }
    type Ödeme = Ödeme of float
    type AktifSepetVerisi = { ÖdenmemişÜrünler: Ürün list }
    type ÖdenmişSepetVerisi = { ÖdenmişÜrünler: Ürün list; Ödeme: Ödeme}

    type AlışverişSepeti =
        | BosSepet  // veri yok
        | AktifSepet of AktifSepetVerisi
        | ÖdenmişSepet of ÖdenmişSepetVerisi

    // ------------------------------------
    // Tipler için içgüdüsel davranış
    // ------------------------------------

    // Çekirdek tipler kendinden çok kullanışlı özelliklere sahiptir
    // Ek kodlama gerektirmez
    // * Değişmezlik
    // * Debug ederken yazdırma
    // * Eşitlik ve kıyaslama
    // * Serialization

    // %A kullanarak yazdırma
    printfn "ikiliTuple=%A,\nKişi=%A,\Sıcaklık=%A,\nÇalışan=%A"
             ikiliTuple kişi1 derece1 işçi

    // Eşitlik ve kıyaslama içgüdüseldir.
    // İskambil kartlarıyla bir örnek
    type Simge = Sinek | Karo | Maça | Kupa
    type Sıra = İki | Üç | Dört | Beş | Altı | Yedi | Sekiz
                | Dokuz | On | Bacak | Kız | Papaz | As

    let el = [ Sinek, As; Kupa, Üç; Kupa, As;
                 Maça, Bacak; Karo, İki; Karo, As ]

    // Sıralama
    List.sort el |> printfn "artarak dizilen el: %A"
    List.max el |> printfn "en yüksek kart: %A"
    List.min el |> printfn "en düşük kart: %A"


// ================================================
// Aktif Kalıplar
// ================================================

module AktifKalıpÖrnekleri =

    // F# "aktif kalıplar" denen bir kalıp eşleştirmeye sahiptir.
    // Kalıplar dinamik bir şekilde tespit edilip eşleştirilebilir.

    // Aktif kalıplar için söz dizimi (| ... |) şeklindedir

    // Örneğin, karakter tiplerini eşleyen bir "aktif" kalıp tanımlayın...
    let (|Rakam|Harf|Boşluk|Diğer|) karakter =
       if System.Char.IsDigit(karakter) then Rakam
       else if System.Char.IsLetter(karakter) then Harf
       else if System.Char.IsWhiteSpace(karakter) then Boşluk
       else Diğer

    // ... daha sonra eşleme mantığı çok daha net yapmak için bunu kullanın
    let karakterYazdır karakter =
      match karakter with
      | Rakam -> printfn "%c bir rakamdır" karakter
      | Harf -> printfn "%c bir harftir" karakter
      | Boşluk -> printfn "%c bir boşluktur" karakter
      | _ -> printfn "%c başka bir şeydir" karakter

    // Bir liste yazdırma
    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter karakterYazdır

    // -----------------------------------
    // Aktif Kalıpları Kullanarak FizzBuzz
    // -----------------------------------

    // Parçalı eşleşen kalıplar da oluşturabilirsiniz
    // Tanımda alt çizgi karakterini kullanın ve eşleşince Some döndürün.
    let (|ÜçünKatı|_|) i = if i % 3 = 0 then Some ÜçünKatı else None
    let (|BeşinKatı|_|) i = if i % 5 = 0 then Some BeşinKatı else None

    // Ana fonksiyon
    let fizzBuzz i =
      match i with
      | ÜçünKatı & BeşinKatı -> printf "FizzBuzz, "
      | ÜçünKatı -> printf "Fizz, "
      | BeşinKatı -> printf "Buzz, "
      | _ -> printf "%i, " i

    // test
    [1..20] |> List.iter fizzBuzz

// ================================================
// Sadelik
// ================================================

module AlgoritmaÖrnekleri =

    // F#'ın sinyal/gürültü oranı yüksektir, dolayısıyla
    // kod algoritmayla hemen hemen aynı görünür.

    // ------ Örnek: karelerToplami fonksiyonunu tanımla ------
    let karelerToplamı n =
       [1..n]                 // 1) 1'den n'e kadar bütün sayıları al
       |> List.map kare       // 2) hepsinin karesini al
       |> List.sum            // 3) sonuçları topla

    // test
    karelerToplamı 100 |> printfn "kareler toplamı = %A"

    // ------ Örnek: bir sıralama fonksiyonu tanımla ------
    let rec sırala liste =
       match liste with
       // Liste boşsa
       | [] ->
            []                              // boş listeyi döndür
       // Liste boş değilse
       | ilkEleman::diğerElemanlar ->       // İlk elemanı al
            let küçükElemanlar =            // Daha küçük elemanları 
                diğerElemanlar              // diğerlerinden ayır
                |> List.filter (fun e -> e < ilkEleman)
                |> sırala                   // ve sırala
            let büyükElemanlar =            // Daha büyük elemanları
                diğerElemanlar              // diğerlerinden ayır
                |> List.filter (fun e -> e >= ilkEleman)
                |> sırala                   // ve sırala
            // 3 parçayı birbirine ekle ve listeyi döndür
            List.concat [küçükElemanlar; [ilkEleman]; büyükElemanlar]

    // test
    sırala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sırala = %A"

// ================================================
// Eşzamansız kod
// ================================================

module EşzamansızÖrneği =

    // F# "pyramid of doom" durumuyla karşılaştırmayacak şekilde
    // içgüdüsel eşzamansız özelliklere sahiptir.
    //
    // Bir sonraki örnek bir web sayfasını paralel bir şekilde indirir.

    open System.Net
    open System
    open System.IO
    open Microsoft.FSharp.Control.CommonExtensions

    // İçeriği eşzamansız bir şekilde getir
    let eşzamansızUrlGetir url =
        async {   // "async" anahtar kelimesi ve kıvrık parantez
                  // "async (eşzamansız)" nesneyi oluşturur
            let istek = WebRequest.Create(Uri(url))
            use! cevap = istek.AsyncGetResponse()
                // use! eşzamansız atamadır
            use akış = cevap.GetResponseStream()
                // "use" kullanılan bloğun dışına çıkınca
                // close()'u otomatik olarak tetikler
            use okuyucu = new IO.StreamReader(akış)
            let html = okuyucu.ReadToEnd()
            printfn "İndirme tamamlandı: %s" url
            }

    // İndirmek için bir web sitesi listesi
    let siteler = ["http://www.bing.com";
                 "http://www.google.com";
                 "http://www.microsoft.com";
                 "http://www.amazon.com";
                 "http://www.yahoo.com"]

    // İndir
    siteler
    |> List.map eşzamansızUrlGetir  // eşzamansız görevlerden oluşan bir liste yap
    |> Async.Parallel               // bu görevleri paralel çalışacak şekilde ayarla
    |> Async.RunSynchronously       // başlat

// ================================================
// .NET uyumluluğu
// ================================================

module NetUyumlulukÖrnekleri =

    // F#, C#'ın yapabildiği hemen herşeyi yapabilir,
    // ve .NET ve Mono kütüphaneleriyle tereyağından kıl çeker gibi çalışır.

    // ------- var olan kütüphane fonksiyonları ile çalışma -------

    let (i1başarılı, i1) = System.Int32.TryParse("123");
    if i1başarılı then printfn "%i olarak dönüştürüldü" i1 else printfn "dönüştürme başarısız"

    // ------- Arayüzleri yol üstünde tanımlayın! -------

    // IDisposable'ı sağlayan yeni bir nesne oluştur
    let kaynakOluştur isim =
       { new System.IDisposable
         with member this.Dispose() = printfn "%s atıldı" isim }

    let kaynakKullanVeAt =
        use r1 = kaynakOluştur "birinci kaynak"
        printfn "birinci kaynağı kullanıyor"
        for i in [1..3] do
            let kaynakİsmi = sprintf "\tiç kaynak %d" i
            use geçici = kaynakOluştur kaynakİsmi
            printfn "\t%s ile bir şey yap" kaynakİsmi
        use r2 = kaynakOluştur "ikinci kaynak"
        printfn "ikinci kaynağı kullanıyor"
        printfn "bitti."

    // ------- Nesne yönelimli kod -------

    // F# aynı zamanda tam bir nesne yönelimli dildir.
    // Sınıfları, kalıtımı ve sanal metotları destekler.

    // Genel tipli bir arayüz
    type IEnumerator<'a> =
        abstract member Şimdiki : 'a
        abstract SonrakineGeç : unit -> bool

    // Sanal metotları olan soyut temel sınıflar
    [<AbstractClass>]
    type Şekil() =
        // sadece okunabilir özellikler
        abstract member Genişlik : int with get
        abstract member Yükseklik : int with get
        // sanal olmayan metot
        member this.ÇevreleyenAlan = this.Yükseklik * this.Genişlik
        // temel uygulamasıyla bir sanal metot
        abstract member Yazdır : unit -> unit
        default this.Yazdır () = printfn "Ben bir şekil (önümden çekil!)"

    // Somut bir sınıfın soyut sınıftan kalıtımı
    type Dikdörtgen(x:int, y:int) =
        inherit Şekil()
        override this.Genişlik = x
        override this.Yükseklik = y
        override this.Yazdır ()  = printfn "Ben bir dikdörtgenim"

    // test
    let r = Dikdörtgen(2, 3)
    printfn "Genişlik: %i" r.Genişlik
    printfn "Çevreleyen Alan: %i" r.ÇevreleyenAlan
    r.Yazdır()

    // ------- ekleme metotları -------

    // C#'ta olduğu gibi F# da var olan sınıfları ekleme metotları ile genişletebilir.
    type System.String with
       member this.StartsWithA = this.StartsWith "A"

    // test
    let s = "Ahmet"
    printfn "'%s' 'A' ile başlar = %A" s s.StartsWithA

    // ------- olaylar -------

    type Butonum() =
        let tıklamaOlayı = new Event<_>()

        [<CLIEvent>]
        member this.OnClick = tıklamaOlayı.Publish

        member this.DenemeOlayı(arg) =
            tıklamaOlayı.Trigger(this, arg)

    // test
    let butonum = new Butonum()
    butonum.OnClick.Add(fun (sender, arg) ->
            printfn "arg=%O ile beraber bir tıklama olayı" arg)

    butonum.DenemeOlayı("Merhaba Dünya!")
```

## Daha fazla bilgi

F# hakkında daha fazla demo için [Try F#](http://www.tryfsharp.org/Learn) sitesine gidin, veya benim (yazarın) [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) serimi okuyun.

F# hakkında daha fazla bilgi için: [fsharp.org](http://fsharp.org/).