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-26 05:51:05 +00:00
|
|
|
|
lang: tr-tr
|
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/).
|