2016-04-25 05:57:21 +00:00
---
language: F#
contributors:
- ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
translators:
- ["Mustafa Zengin", "http://zengin.github.com/"]
2016-04-26 05:34:41 +00:00
filename: learnfsharp-tr.fs
2016-04-25 05:57:21 +00:00
---
2016-04-25 23:02:07 +00:00
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.
2016-04-25 05:57:21 +00:00
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
2016-04-26 05:34:41 +00:00
// tek satı r yorumlar ikili bölme işareti ile başlar
(* çok satı rlı yorumlar ( * . . . * ) ikilisini kullanı r
2016-04-25 05:57:21 +00:00
-ç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
2016-04-26 05:34:41 +00:00
let tamsayı m = 5
let ondalı ğı m = 3.14
let stringim = "merhaba" // tip bilgisi olmaması na dikkat
2016-04-25 05:57:21 +00:00
// ------ Listeler ------
2016-04-26 05:34:41 +00:00
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.
2016-04-25 05:57:21 +00:00
// Sonuç: [1; 2; 3; 4; 5]
2016-04-26 05:34:41 +00:00
let sı fı rdanBeşe = [0; 1] @ ikidenBeşe // @ iki listeyi birbirine ekler.
2016-04-25 05:57:21 +00:00
// ÖNEMLİ: virgüller hiçbir zaman ayraç olarak kullanı lmaz, sadece noktalı virgüller!
// ------ Fonksiyonlar ------
// "let" anahtar kelimesi isimlendirilmiş fonksiyonları da tanı mlar.
2016-04-26 02:22:56 +00:00
let kare x = x * x // Parantez kullanı lmadı ğı na dikkat.
2016-04-26 05:34:41 +00:00
kare 3 // Şimdi fonksiyonu uygulayı n. Yine parantez yok.
2016-04-25 05:57:21 +00:00
2016-04-26 02:22:56 +00:00
let topla x y = x + y // topla (x,y) kullanmayı n! Bu tamamen başka bir anlama geliyor.
2016-04-26 05:34:41 +00:00
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
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
çiftler birdenBeşe // Şimdi fonksiyonu uygula.
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
// 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] )
2016-04-25 05:57:21 +00:00
// Bir operasyonun sonucunu bir sonrakine "|>" kullanarak besleyebilirsin.
// Veri beslemek F#'ta UNIX'te olduğu gibi yaygı ndı r..
2016-04-26 05:34:41 +00:00
// 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ı
2016-04-25 05:57:21 +00:00
// Lambda'ları (anonim fonksiyonları ) "fun" anahtar kelimesiyle tanı mlayabilirsin
2016-04-26 05:34:41 +00:00
let funlaYüzeKadarKarelerinToplamı =
[1..100] |> List.map (fun x -> x * x) |> List.sum
2016-04-25 05:57:21 +00:00
// 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.
2016-04-26 05:34:41 +00:00
let basitKalı pEşleştirme =
2016-04-25 05:57:21 +00:00
let x = "a"
match x with
2016-04-26 02:22:56 +00:00
| "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
2016-04-25 05:57:21 +00:00
// 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.
2016-04-26 05:34:41 +00:00
let geçerliDeğer = Some(99)
let geçersizDeğer = None
2016-04-25 05:57:21 +00:00
// Bu örnekte, match..with "Some" ve "None"la eşleştirme yapı yor,
// ve ayrı ca "Some" içerisindeki değeri de çı karı yor.
2016-04-26 05:34:41 +00:00
let optionKalı pEşleştirme input =
2016-04-25 05:57:21 +00:00
match input with
| Some i -> printfn "input is an int=%d" i
| None -> printfn "input is missing"
2016-04-26 05:34:41 +00:00
optionKalı pEşleştirme geçerliDeğer
optionKalı pEşleştirme geçersizDeğer
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ------ Yazdı rma ------
// printf/printfn fonksiyonları C#'taki
// Console.Write/WriteLine fonksiyonları na benzer.
2016-04-26 05:34:41 +00:00
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]
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// sprintf/sprintfn fonksiyonları ise veriyi string'e
// çevirmek içindir, C#'taki String.Format gibi.
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-25 23:02:07 +00:00
// Fonksiyonlar hakkı nda dahası
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-25 23:02:07 +00:00
// 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.
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Modüller fonksiyonları gruplamak için kullanı lı r.
// Her bir modül için girinti gerekir.
2016-04-26 02:22:56 +00:00
module FonksiyonOrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Temel bir ekleme fonksiyonu tanı mla
2016-04-26 02:22:56 +00:00
let topla x y = x + y
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Bir fonksiyonun temel kullanı mı
2016-04-26 02:22:56 +00:00
let a = topla 1 2
2016-04-25 05:57:21 +00:00
printfn "1 + 2 = %i" a
2016-04-25 23:02:07 +00:00
// Parametreleri kaynaklamak için parçalı uygulama
2016-04-26 05:34:41 +00:00
let kı rkİkiEkle = topla 42
let b = kı rkİkiEkle 1
2016-04-25 05:57:21 +00:00
printfn "42 + 1 = %i" b
2016-04-25 23:02:07 +00:00
// Fonksiyonları birleştirmek için kompozisyon
2016-04-26 02:22:56 +00:00
let birEkle = topla 1
let ikiEkle = topla 2
2016-04-26 05:34:41 +00:00
let üçEkle = birEkle >> ikiEkle
let c = üçEkle 7
2016-04-25 05:57:21 +00:00
printfn "3 + 7 = %i" c
2016-04-25 23:02:07 +00:00
// Yüksek dereceli fonksiyonlar
2016-04-26 05:34:41 +00:00
[1..10] |> List.map üçEkle |> printfn "yeni liste: %A"
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Fonksiyonlar listesi ve dahası
2016-04-26 05:34:41 +00:00
let altı Ekle = [birEkle; ikiEkle; üçEkle] |> List.reduce (>>)
let d = altı Ekle 7
2016-04-25 05:57:21 +00:00
printfn "1 + 2 + 3 + 7 = %i" d
// ================================================
2016-04-25 23:02:07 +00:00
// Listeler ve kolleksiyonlar
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-25 23:02:07 +00:00
// Üç ç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.
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
module ListeÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// listeler köşeli parantez kullanı r
2016-04-26 02:22:56 +00:00
let liste1 = ["a"; "b"]
let liste2 = "c" :: liste1 // :: başa eleman ekler
let liste3 = liste1 @ liste2 // @ listeleri birbirine ekler
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Liste comprehension'ları (jeneratörler olarak da bilinir)
2016-04-26 02:22:56 +00:00
let kareler = [for i in 1..10 do yield i * i]
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// asal sayı jeneratörü
2016-04-26 02:22:56 +00:00
let rec elek = function
| (p::xler) -> p :: elek [ for x in xler do if x % p > 0 then yield x ]
2016-04-25 05:57:21 +00:00
| [] -> []
2016-04-26 02:22:56 +00:00
let asallar = elek [2..50]
printfn "%A" asallar
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Listelerle kalı p eşleştirme
2016-04-26 05:34:41 +00:00
let listeEşleyici liste =
2016-04-26 02:22:56 +00:00
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"
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
listeEşleyici [1; 2; 3; 4]
listeEşleyici [1; 2]
listeEşleyici [1]
listeEşleyici []
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Listeleri kullanarak recursion
2016-04-26 02:22:56 +00:00
let rec ekle liste =
match liste with
2016-04-25 05:57:21 +00:00
| [] -> 0
2016-04-26 02:22:56 +00:00
| x::xler -> x + ekle xler
ekle [1..10]
2016-04-25 05:57:21 +00:00
// -----------------------------------------
2016-04-25 23:02:07 +00:00
// Standart kütüphane fonksiyonları
2016-04-25 05:57:21 +00:00
// -----------------------------------------
// map
2016-04-26 05:34:41 +00:00
let üçEkle x = x + 3
[1..10] |> List.map üçEkle
2016-04-25 05:57:21 +00:00
// filter
2016-04-26 05:34:41 +00:00
let çift x = x % 2 = 0
[1..10] |> List.filter çift
2016-04-25 05:57:21 +00:00
2016-04-26 02:22:56 +00:00
// ve dahası -- dökümantasyona bakı nı z
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
module DiziÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Diziler köşeli parantezle birlikte çubuk karakterini kullanı r
2016-04-26 02:22:56 +00:00
let dizi1 = [| "a"; "b" |]
let birinci = dizi1.[0] // nokta kullanarak indeks erişimi
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Diziler için kalı p eşleştirme listlerle aynı dı r
2016-04-26 05:34:41 +00:00
let diziEşleştirici liste =
2016-04-26 02:22:56 +00:00
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"
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
diziEşleştirici [| 1; 2; 3; 4 |]
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Listede olduğu gibi kütüphane fonksiyonları
2016-04-25 05:57:21 +00:00
[| 1..10 |]
|> Array.map (fun i -> i + 3)
|> Array.filter (fun i -> i % 2 = 0)
2016-04-26 02:22:56 +00:00
|> Array.iter (printfn "değer: %i. ")
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
module SeriÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// seriler kı vrı k parantez kullanı r
2016-04-26 02:22:56 +00:00
let seri1 = seq { yield "a"; yield "b" }
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// seriler yield'ı kullanabilir
// ve alt seriler barı ndı rabilir
2016-04-26 02:22:56 +00:00
let garip = seq {
2016-04-25 23:02:07 +00:00
// "yield" bir eleman ekliyor
2016-04-25 05:57:21 +00:00
yield 1; yield 2;
2016-04-25 23:02:07 +00:00
// "yield!" bütün bir alt seriyi ekliyor
2016-04-25 05:57:21 +00:00
yield! [5..10]
yield! seq {
for i in 1..10 do
if i % 2 = 0 then yield i }}
// test
2016-04-26 02:22:56 +00:00
garip |> Seq.toList
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Seriler "unfold" kullanı larak oluşturulabilir
// Fibonacci serisi örneği
2016-04-26 02:22:56 +00:00
let fib = Seq.unfold (fun (birinci,ikinci) ->
Some(birinci + ikinci, (ikinci, birinci + ikinci))) (0,1)
2016-04-25 05:57:21 +00:00
// test
let fib10 = fib |> Seq.take 10 |> Seq.toList
2016-04-26 02:22:56 +00:00
printf "ilk 10 fibonacci sayı sı : %A" fib10
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-25 23:02:07 +00:00
// Veri Tipleri
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-26 05:34:41 +00:00
module VeriTipiÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Bütün veriler varsayı lan olarak değiştirilemezdir.
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
// -- Tuple oluşturmak için virgül kullan
let ikiliTuple = 1, 2
let üçlüTuple = "a", 2, true
2016-04-25 23:02:07 +00:00
// Tuple'lar çabuk ve kolay anonim tiplerdir.
// paketi açmak için kalı p eşleştirme kullan
2016-04-26 02:22:56 +00:00
let x, y = ikiliTuple // x = 1, y = 2
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Record tipi isimlendirilmiş alanlara sahiptir
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// "type" ile kı vrı k parantezleri record tipi oluşturmak için kullan
2016-04-26 05:34:41 +00:00
type Kişi = {Ad:string; Soyad:string}
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// "let" ile kı vrı k parantezi record tipi oluşturmak için kullan
2016-04-26 05:34:41 +00:00
let kişi1 = {Ad="Falanca"; Soyad="Kişi"}
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// paketi açmak için kalı p eşleştirme kullan
2016-04-26 05:34:41 +00:00
let {Ad = Ad} = kişi1 // birinci="John"
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Union tipleri (değişkenler olarak da bilinir) birden fazla
2016-04-26 05:34:41 +00:00
// seçeneğe sahiptir. Belli bir zamanda sadece bir tanesi geçerlidir.
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// "type" ile çubuk karakterini union tipi tanı mlamak için kullan
2016-04-26 05:34:41 +00:00
type Sı caklı k =
2016-04-26 02:22:56 +00:00
| Santigrat of float
| Fahrenhayt of float
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Seçeneklerden birini kullan
2016-04-26 02:22:56 +00:00
let derece1 = Fahrenhayt 98.6
let derece2 = Santigrat 37.0
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Paketi açmak için bütün seçenekler üzerinde kalı p eşleştirme kullan
2016-04-26 05:34:41 +00:00
let dereceYazdı r = function
2016-04-26 02:22:56 +00:00
| Santigrat t -> printfn "%f C" t
| Fahrenhayt t -> printfn "%f F" t
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
dereceYazdı r derece1
dereceYazdı r derece2
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Yinelgen (Recursive) tipler
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-26 05:34:41 +00:00
// 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
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
let falancaKişi = {Ad="Falanca"; Soyad="Kişi"}
let işçi = İşçi falancaKişi
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Tipleri Kullanarak Modelleme
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Union tipleri bayrak kullanmadan durum modelleme için harikadı r.
2016-04-26 02:22:56 +00:00
type EpostaAdresi =
2016-04-26 05:34:41 +00:00
| GeçerliEpostaAdresi of string
| GeçersizEpostaAdresi of string
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
let epostaGöndermeyiDene eposta =
match eposta with // kalı p eşleştirme kullan
| GeçerliEpostaAdresi adres -> () // gönder
| GeçersizEpostaAdresi adres -> () // gönderme
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
// Union tiplerin record tiplerle birleşimi
// domain driven design için iyi bir temel oluşturur.
2016-04-25 23:02:07 +00:00
// Domain'i yansı tan yüzlerce ufak tip oluşturabilirsiniz.
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
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}
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
type Alı şverişSepeti =
2016-04-26 02:22:56 +00:00
| BosSepet // veri yok
| AktifSepet of AktifSepetVerisi
2016-04-26 05:34:41 +00:00
| ÖdenmişSepet of ÖdenmişSepetVerisi
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Tipler için içgüdüsel davranı ş
2016-04-25 05:57:21 +00:00
// ------------------------------------
2016-04-25 23:02:07 +00:00
// Çekirdek tipler kendinden çok kullanı şlı özelliklere sahiptir
2016-04-26 05:34:41 +00:00
// Ek kodlama gerektirmez
2016-04-25 23:02:07 +00:00
// * Değişmezlik
// * Debug ederken yazdı rma
// * Eşitlik ve kı yaslama
2016-04-25 05:57:21 +00:00
// * Serialization
2016-04-25 23:02:07 +00:00
// %A kullanarak yazdı rma
2016-04-26 05:34:41 +00:00
printfn "ikiliTuple=%A,\nKişi=%A,\Sı caklı k=%A,\nÇalı şan=%A"
ikiliTuple kişi1 derece1 işçi
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Eşitlik ve kı yaslama içgüdüseldir.
// İskambil kartları yla bir örnek
2016-04-26 05:34:41 +00:00
type Simge = Sinek | Karo | Maça | Kupa
type Sı ra = İki | Üç | Dört | Beş | Altı | Yedi | Sekiz
| Dokuz | On | Bacak | Kı z | Papaz | As
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
let el = [ Sinek, As; Kupa, Üç; Kupa, As;
Maça, Bacak; Karo, İki; Karo, As ]
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Sı ralama
2016-04-26 05:34:41 +00:00
List.sort el |> printfn "artarak dizilen el: %A"
2016-04-26 02:22:56 +00:00
List.max el |> printfn "en yüksek kart: %A"
List.min el |> printfn "en düşük kart: %A"
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-25 23:02:07 +00:00
// Aktif Kalı plar
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-26 05:34:41 +00:00
module AktifKalı pÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// F# "aktif kalı plar" denen bir kalı p eşleştirmeye sahiptir.
// Kalı plar dinamik bir şekilde tespit edilip eşleştirilebilir.
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Aktif kalı plar için söz dizimi (| ... |) şeklindedir
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Örneğin, karakter tiplerini eşleyen bir "aktif" kalı p tanı mlayı n...
2016-04-26 05:34:41 +00:00
let (|Rakam|Harf|Boşluk|Diğer|) karakter =
2016-04-26 02:22:56 +00:00
if System.Char.IsDigit(karakter) then Rakam
else if System.Char.IsLetter(karakter) then Harf
2016-04-26 05:34:41 +00:00
else if System.Char.IsWhiteSpace(karakter) then Boşluk
else Diğer
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ... daha sonra eşleme mantı ğı çok daha net yapmak için bunu kullanı n
2016-04-26 05:34:41 +00:00
let karakterYazdı r karakter =
2016-04-26 02:22:56 +00:00
match karakter with
| Rakam -> printfn "%c bir rakamdı r" karakter
| Harf -> printfn "%c bir harftir" karakter
2016-04-26 05:34:41 +00:00
| Boşluk -> printfn "%c bir boşluktur" karakter
2016-04-26 02:22:56 +00:00
| _ -> printfn "%c başka bir şeydir" karakter
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Bir liste yazdı rma
2016-04-26 05:34:41 +00:00
['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter karakterYazdı r
2016-04-25 05:57:21 +00:00
// -----------------------------------
2016-04-25 23:02:07 +00:00
// Aktif Kalı pları Kullanarak FizzBuzz
2016-04-25 05:57:21 +00:00
// -----------------------------------
2016-04-26 05:34:41 +00:00
// Parçalı eşleşen kalı plar da oluşturabilirsiniz
2016-04-25 23:02:07 +00:00
// Tanı mda alt çizgi karakterini kullanı n ve eşleşince Some döndürün.
2016-04-26 05:34:41 +00:00
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
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Ana fonksiyon
2016-04-25 05:57:21 +00:00
let fizzBuzz i =
match i with
2016-04-26 05:34:41 +00:00
| ÜçünKatı & BeşinKatı -> printf "FizzBuzz, "
| ÜçünKatı -> printf "Fizz, "
| BeşinKatı -> printf "Buzz, "
2016-04-25 05:57:21 +00:00
| _ -> printf "%i, " i
// test
[1..20] |> List.iter fizzBuzz
// ================================================
2016-04-25 23:02:07 +00:00
// Sadelik
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-26 05:34:41 +00:00
module AlgoritmaÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// F#'ı n sinyal/gürültü oranı yüksektir, dolayı sı yla
// kod algoritmayla hemen hemen aynı görünür.
2016-04-25 05:57:21 +00:00
2016-04-26 02:22:56 +00:00
// ------ Örnek: karelerToplami fonksiyonunu tanı mla ------
2016-04-26 05:34:41 +00:00
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
2016-04-25 05:57:21 +00:00
// test
2016-04-26 05:34:41 +00:00
karelerToplamı 100 |> printfn "kareler toplamı = %A"
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ------ Örnek: bir sı ralama fonksiyonu tanı mla ------
2016-04-26 05:34:41 +00:00
let rec sı rala liste =
2016-04-26 02:22:56 +00:00
match liste with
2016-04-25 23:02:07 +00:00
// Liste boşsa
2016-04-25 05:57:21 +00:00
| [] ->
2016-04-26 05:34:41 +00:00
[] // boş listeyi döndür
2016-04-25 23:02:07 +00:00
// Liste boş değilse
2016-04-26 05:34:41 +00:00
| ilkEleman::diğerElemanlar -> // İlk elemanı al
let küçükElemanlar = // Daha küçük elemanları
diğerElemanlar // diğerlerinden ayı r
2016-04-26 02:22:56 +00:00
|> List.filter (fun e -> e < ilkEleman )
2016-04-26 05:34:41 +00:00
|> sı rala // ve sı rala
let büyükElemanlar = // Daha büyük elemanları
diğerElemanlar // diğerlerinden ayı r
2016-04-26 02:22:56 +00:00
|> List.filter (fun e -> e >= ilkEleman)
2016-04-26 05:34:41 +00:00
|> sı rala // ve sı rala
2016-04-25 23:02:07 +00:00
// 3 parçayı birbirine ekle ve listeyi döndür
2016-04-26 05:34:41 +00:00
List.concat [küçükElemanlar; [ilkEleman]; büyükElemanlar]
2016-04-25 05:57:21 +00:00
// test
2016-04-26 05:34:41 +00:00
sı rala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sı rala = %A"
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-26 02:22:56 +00:00
// Eşzamansı z kod
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-26 05:34:41 +00:00
module Eşzamansı zÖrneği =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// F# "pyramid of doom" durumuyla karşı laştı rmayacak şekilde
2016-04-26 05:34:41 +00:00
// içgüdüsel eşzamansı z özelliklere sahiptir.
2016-04-25 05:57:21 +00:00
//
2016-04-25 23:02:07 +00:00
// Bir sonraki örnek bir web sayfası nı paralel bir şekilde indirir.
2016-04-25 05:57:21 +00:00
open System.Net
open System
open System.IO
open Microsoft.FSharp.Control.CommonExtensions
2016-04-26 02:22:56 +00:00
// İçeriği eşzamansı z bir şekilde getir
2016-04-26 05:34:41 +00:00
let eşzamansı zUrlGetir url =
2016-04-25 23:02:07 +00:00
async { // "async" anahtar kelimesi ve kı vrı k parantez
2016-04-26 02:22:56 +00:00
// "async (eşzamansı z)" nesneyi oluşturur
let istek = WebRequest.Create(Uri(url))
use! cevap = istek.AsyncGetResponse()
// use! eşzamansı z atamadı r
2016-04-26 05:34:41 +00:00
use akı ş = cevap.GetResponseStream()
2016-04-25 23:02:07 +00:00
// "use" kullanı lan bloğun dı şı na çı kı nca
// close()'u otomatik olarak tetikler
2016-04-26 05:34:41 +00:00
use okuyucu = new IO.StreamReader(akı ş)
2016-04-26 02:22:56 +00:00
let html = okuyucu.ReadToEnd()
printfn "İndirme tamamlandı : %s" url
2016-04-25 05:57:21 +00:00
}
2016-04-25 23:02:07 +00:00
// İndirmek için bir web sitesi listesi
2016-04-26 02:22:56 +00:00
let siteler = ["http://www.bing.com";
2016-04-25 05:57:21 +00:00
"http://www.google.com";
"http://www.microsoft.com";
"http://www.amazon.com";
"http://www.yahoo.com"]
2016-04-25 23:02:07 +00:00
// İndir
2016-04-26 02:22:56 +00:00
siteler
2016-04-26 05:34:41 +00:00
|> 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
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-25 23:02:07 +00:00
// .NET uyumluluğu
2016-04-25 05:57:21 +00:00
// ================================================
2016-04-26 05:34:41 +00:00
module NetUyumlulukÖrnekleri =
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// F#, C#'ı n yapabildiği hemen herşeyi yapabilir,
// ve .NET ve Mono kütüphaneleriyle tereyağı ndan kı l çeker gibi çalı şı r.
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ------- var olan kütüphane fonksiyonları ile çalı şma -------
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
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"
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
// ------- Arayüzleri yol üstünde tanı mlayı n! -------
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// IDisposable'ı sağlayan yeni bir nesne oluştur
2016-04-26 05:34:41 +00:00
let kaynakOluştur isim =
2016-04-25 05:57:21 +00:00
{ new System.IDisposable
2016-04-26 05:34:41 +00:00
with member this.Dispose() = printfn "%s atı ldı " isim }
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
let kaynakKullanVeAt =
use r1 = kaynakOluştur "birinci kaynak"
printfn "birinci kaynağı kullanı yor"
2016-04-25 05:57:21 +00:00
for i in [1..3] do
2016-04-26 05:34:41 +00:00
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."
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ------- Nesne yönelimli kod -------
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// F# aynı zamanda tam bir nesne yönelimli dildir.
// Sı nı fları , kalı tı mı ve sanal metotları destekler.
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
// Genel tipli bir arayüz
2016-04-25 05:57:21 +00:00
type IEnumerator< 'a> =
2016-04-26 05:34:41 +00:00
abstract member Şimdiki : 'a
abstract SonrakineGeç : unit -> bool
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Sanal metotları olan soyut temel sı nı flar
2016-04-25 05:57:21 +00:00
[< AbstractClass > ]
2016-04-26 05:34:41 +00:00
type Şekil() =
2016-04-25 23:02:07 +00:00
// sadece okunabilir özellikler
2016-04-26 05:34:41 +00:00
abstract member Genişlik : int with get
abstract member Yükseklik : int with get
2016-04-25 23:02:07 +00:00
// sanal olmayan metot
2016-04-26 05:34:41 +00:00
member this.ÇevreleyenAlan = this.Yükseklik * this.Genişlik
2016-04-25 23:02:07 +00:00
// temel uygulaması yla bir sanal metot
2016-04-26 05:34:41 +00:00
abstract member Yazdı r : unit -> unit
default this.Yazdı r () = printfn "Ben bir şekil (önümden çekil!)"
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// Somut bir sı nı fı n soyut sı nı ftan kalı tı mı
2016-04-26 05:34:41 +00:00
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"
2016-04-25 05:57:21 +00:00
// test
2016-04-26 05:34:41 +00:00
let r = Dikdörtgen(2, 3)
printfn "Genişlik: %i" r.Genişlik
printfn "Çevreleyen Alan: %i" r.ÇevreleyenAlan
r.Yazdı r()
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ------- ekleme metotları -------
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// C#'ta olduğu gibi F# da var olan sı nı fları ekleme metotları ile genişletebilir.
2016-04-25 05:57:21 +00:00
type System.String with
member this.StartsWithA = this.StartsWith "A"
// test
2016-04-26 05:34:41 +00:00
let s = "Ahmet"
printfn "'%s' 'A' ile başlar = %A" s s.StartsWithA
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
// ------- olaylar -------
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
type Butonum() =
let tı klamaOlayı = new Event< _ > ()
2016-04-25 05:57:21 +00:00
[< CLIEvent > ]
2016-04-26 05:34:41 +00:00
member this.OnClick = tı klamaOlayı .Publish
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
member this.DenemeOlayı (arg) =
tı klamaOlayı .Trigger(this, arg)
2016-04-25 05:57:21 +00:00
// test
2016-04-26 05:34:41 +00:00
let butonum = new Butonum()
butonum.OnClick.Add(fun (sender, arg) ->
printfn "arg=%O ile beraber bir tı klama olayı " arg)
2016-04-25 05:57:21 +00:00
2016-04-26 05:34:41 +00:00
butonum.DenemeOlayı ("Merhaba Dünya!")
2016-04-25 05:57:21 +00:00
```
2016-04-25 23:02:07 +00:00
## Daha fazla bilgi
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
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.
2016-04-25 05:57:21 +00:00
2016-04-25 23:02:07 +00:00
F# hakkı nda daha fazla bilgi için: [fsharp.org ](http://fsharp.org/ ).