summaryrefslogtreecommitdiffhomepage
path: root/tr-tr/fsharp-tr.html.markdown
blob: 8c47397c27187f0ead828b410589652a0d8ff8cc (plain)
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
---
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.

```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/).