Merge pull request #2245 from zengin/master

[fsharp/tr-tr] Translation of fsharp tutorial to Turkish

1 files changed, 630 insertions, 0 deletions

diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
new file mode 100644
index 00000000..d88e2594
--- /dev/null
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -0,0 +1,630 @@
+---
+language: F#
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
+translators:
+    - ["Mustafa Zengin", "http://zengin.github.com/"]
+filename: learnfsharp-tr.fs
+---
+
+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.
+
+```csharp
+
+// 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/).