summaryrefslogtreecommitdiffhomepage
path: root/tr-tr
diff options
context:
space:
mode:
Diffstat (limited to 'tr-tr')
-rw-r--r--tr-tr/bf-tr.html.markdown (renamed from tr-tr/brainfuck-tr.html.markdown)4
-rw-r--r--tr-tr/c-tr.html.markdown36
-rw-r--r--tr-tr/csharp-tr.html.markdown5
-rw-r--r--tr-tr/dynamic-programming-tr.html.markdown49
-rw-r--r--tr-tr/fsharp-tr.html.markdown631
-rw-r--r--tr-tr/kotlin-tr.html.markdown474
-rw-r--r--tr-tr/markdown-tr.html.markdown251
-rw-r--r--tr-tr/objective-c-tr.html.markdown2
-rw-r--r--tr-tr/python3-tr.html.markdown640
-rw-r--r--tr-tr/swift-tr.html.markdown589
-rw-r--r--tr-tr/typescript-tr.html.markdown180
11 files changed, 2838 insertions, 23 deletions
diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/bf-tr.html.markdown
index baca4217..e7015cd0 100644
--- a/tr-tr/brainfuck-tr.html.markdown
+++ b/tr-tr/bf-tr.html.markdown
@@ -1,5 +1,5 @@
---
-language: brainfuck
+language: bf
filename: brainfuck-tr
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io"]
@@ -19,7 +19,7 @@ gözardı edilir.
Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir
dizidir. İşaretçi ilk hücreyi işaret eder.
-Sekik komut vardır:
+Sekiz komut vardır:
+ : Geçerli hücrenin değerini bir artırır.
- : Geçerli hücrenin değerini bir azaltır.
> : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 128901de..6042a609 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -91,9 +91,9 @@ int main() {
// Örneğin,
printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words)
- // If the argument of the `sizeof` operator an expression, then its argument
- // is not evaluated (except VLAs (see below)).
- // The value it yields in this case is a compile-time constant.
+ // Eger arguman düzenli ifae olan sizeof operatoru ise degerlendirilmez.
+ // VLAs hariç asagiya bakiniz).
+ // Bu durumda verimliligin degeri derleme-zamani sabitidir.
int a = 1;
// size_t bir objeyi temsil etmek için kullanılan 2 byte uzunluğundaki bir
@@ -101,7 +101,7 @@ int main() {
size_t size = sizeof(a++); // a++ is not evaluated
printf("sizeof(a++) = %zu where a = %d\n", size, a);
- // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture)
+ // yazdirilan "sizeof(a++) = 4 where a = 1" (32-bit mimaride)
// Diziler somut bir boyut ile oluşturulmalıdır.
char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
@@ -119,19 +119,19 @@ int main() {
my_array[1] = 2;
printf("%d\n", my_array[1]); // => 2
- // In C99 (and as an optional feature in C11), variable-length arrays (VLAs)
- // can be declared as well. The size of such an array need not be a compile
- // time constant:
- printf("Enter the array size: "); // ask the user for an array size
+ // C99'da (ve C11 istege bagli bir ozellik olarak), değidken-uzunluklu diziler (VLAs) bildirilebilirler.
+ // Böyle bir dizinin boyuunu derlenmesi gerekmez
+ // zaman sabiti:
+ printf("Enter the array size: "); // dizi boyutu kullaniciya soruluyor
char buf[0x100];
fgets(buf, sizeof buf, stdin);
- // strtoul parses a string to an unsigned integer
+ // strtoul isaretsiz integerlar icin string ayiricisidir.
size_t size = strtoul(buf, NULL, 10);
int var_length_array[size]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array);
- // A possible outcome of this program may be:
+ // Bu programın olası bir sonucu olabilir:
// > Enter the array size: 10
// > sizeof array = 40
@@ -151,8 +151,8 @@ int main() {
printf("%d\n", a_string[16]); // => 0
// i.e., byte #17 is 0 (as are 18, 19, and 20)
- // If we have characters between single quotes, that's a character literal.
- // It's of type `int`, and *not* `char` (for historical reasons).
+ // Tek tirnak arasinda karakterlere sahipsek, bu karakterler degismezdir.
+ // Tip `int` ise, `char` *degildir* (tarihsel sebeplerle).
int cha = 'a'; // fine
char chb = 'a'; // fine too (implicit conversion from int to char)
@@ -201,10 +201,10 @@ int main() {
0x01 << 1; // => 0x02 (bitwise left shift (by 1))
0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
- // Be careful when shifting signed integers - the following are undefined:
- // - shifting into the sign bit of a signed integer (int a = 1 << 32)
- // - left-shifting a negative number (int a = -1 << 2)
- // - shifting by an offset which is >= the width of the type of the LHS:
+ // Isaretli sayilari kaydirirken dikkatli olun - tanimsizlar sunlardir:
+ // - isaretli sayinin isaret bitinde yap?ilan kaydirma (int a = 1 << 32)
+ // - negatif sayilarda sol kaydirma (int a = -1 << 2)
+ // - LHS tipinde >= ile olan ofset genisletmelerde yapilan kaydirma:
// int a = 1 << 32; // UB if int is 32 bits wide
///////////////////////////////////////
@@ -481,8 +481,8 @@ Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.or
It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the
-[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
Diğer taraftan google sizin için bir arkadaş olabilir.
-[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member \ No newline at end of file
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 7755ed44..91c7c269 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -8,7 +8,7 @@ contributors:
translators:
- ["Melih Mucuk", "http://melihmucuk.com"]
lang: tr-tr
-filename: LearnCSharp.cs
+filename: LearnCSharp-tr.cs
---
@@ -234,7 +234,8 @@ on a new line! ""Wow!"", the masses cried";
// Üçlü operatörler
// Basit bir if/else ifadesi şöyle yazılabilir
// <koşul> ? <true> : <false>
- string isTrue = (true) ? "True" : "False";
+ int toCompare = 17;
+ string isTrue = toCompare == 17 ? "True" : "False";
// While döngüsü
int fooWhile = 0;
diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
new file mode 100644
index 00000000..606ecf04
--- /dev/null
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -0,0 +1,49 @@
+---
+language: Dynamic Programming
+filename: dynamic-tr.txt
+contributors:
+ - ["Akashdeep Goel", "https://github.com/akashdeepgoel"]
+translators:
+ - ["Mehmet Cem Yaraş", "https://www.linkedin.com/in/yarascem/"]
+lang: tr-tr
+---
+
+Dinamik Programlama
+Giriş
+Dinamik Programlama, göreceğimiz gibi belirli bir problem sınıfını çözmek için kullanılan güçlü bir tekniktir. Fikir çok basittir, verilen girdiyle ilgili bir sorunu çözdüyseniz, aynı sorunun tekrar çözülmesini önlemek için sonucunu gelecekte referans olarak kaydedilmesine dayanır.
+
+Her zaman hatırla! "Geçmiş hatırlayamayanlar, aynı şeyleri tekrar yaşamaya mahkumlardır!"
+
+Bu tür sorunların çözüm yolları
+
+1-Yukarıdan aşağıya:
+Verilen problemi çözerek çözmeye başlayın. Sorunun zaten çözüldüğünü görürseniz, kaydedilen cevabı döndürmeniz yeterlidir. Çözülmemişse, çözünüz ve cevabı saklayınız. Bu genellikle düşünmek kolaydır ve çok sezgiseldir. Buna Ezberleştirme denir.
+
+2-Aşağıdan yukarıya:
+Sorunu analiz edin ve alt problemlerin çözülme sırasını görün ve önemsiz alt sorundan verilen soruna doğru başlayın. Bu süreçte, problemi çözmeden önce alt problemlerin çözülmesi gerekmektedir. Buna Dinamik Programlama denir.
+
+Örnek
+En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. S = {a1, a2, a3, a4, ............., an-1} dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, j için <I, aj <ai alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için j <i ve aj <ai gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma O (n2) zaman alır.
+
+En uzun artan alt dizinin uzunluğunu bulmak için sözde kod: Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır.
+
+Yönlendirilmiş asiklik grafiğinde en uzun yolu bulmak için benzer bir kavram uygulanabilir.
+
+```python
+for i=0 to n-1
+ LS[i]=1
+ for j=0 to i-1
+ if (a[i] > a[j] and LS[i]<LS[j])
+ LS[i] = LS[j]+1
+for i=0 to n-1
+ if (largest < LS[i])
+
+```
+
+Bazı Ünlü Dinamik Programlama Problemleri
+-Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs—floyd-warshall-algorithm-with-c-program-source-code
+-Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—the-integer-knapsack-problem
+-Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—longest-common-subsequence
+
+Online Kaynaklar
+https://www.codechef.com/wiki/tutorial-dynamic-programming
diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
new file mode 100644
index 00000000..8c47397c
--- /dev/null
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -0,0 +1,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/).
diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
new file mode 100644
index 00000000..4d2dd291
--- /dev/null
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -0,0 +1,474 @@
+---
+language: kotlin
+filename: kotlin-tr.kt
+contributors:
+ - ["Baha Can Aydın", "https://github.com/bahacan19"]
+lang: tr-tr
+---
+Kotlin, JVM, Android ve tarayıcı için statik olarak yazılmış bir programlama dilidir.
+Java %100 birlikte çalışabilir.
+[Daha:](https://kotlinlang.org/)
+
+```kotlin
+
+// Tek satır yoruma almak için : //
+/*
+ Birkaç satırı yoruma almak için
+*/
+
+// "package" anahtar kelimesi tıpkı Java'da olduğu gibidir.
+package com.learnxinyminutes.kotlin
+
+/*
+Bir Kotlin programının başlama noktası (Java'da olduğu gibi) "com.learnxinyminutes.kotlin.main" metodudur.
+Bu metoda komut satırından bir 'Array' gönderilebilir.
+*/
+fun main(args: Array<String>) {
+ /*
+ Bir değer tanımlamak için "var" ya da "val" anahtar kelimeleri kullanılıyor.
+ "val" tanımlananlar tekrar atanamazken "var" tanımlananlar atanabilir.
+ */
+ val fooVal = 10 // fooVal değerini daha sonra tekrar atayamıyoruz
+ var fooVar = 10
+ fooVar = 20 // fooVar tekrar atanabilir.
+
+ /*
+ Çoğu zaman, Kotlin bir değişkenin tipini anlayabilir,
+ bu yüzden her zaman belirtmeye gerek yoktur.
+ Bir değişkenin tipini şöyle belirtebiliriz:
+ */
+ val foo: Int = 7
+
+ /*
+ String değerler Java'da olduğu gibi tanımlanır.
+ */
+ val fooString = "İşte String bu!"
+ val barString = "Yeni satıra geçiyorum...?\nGeçtim!"
+ val bazString = "Tab mı istedin?\tAl bakalım!"
+ println(fooString)
+ println(barString)
+ println(bazString)
+
+ /*
+ Raw string, üçlü çift-tırnak sınırlandırılan String bloklarıdır.
+ Tıpkı bir text editör gibi String tanımlamaya izin verir.
+ */
+ val fooRawString = """
+fun helloWorld(val name : String) {
+ println("Merhaba, dünya!")
+}
+"""
+ println(fooRawString)
+
+ /*
+ String değerler, ($) işareti ile birtakım deyimler ve değerler içererbilir
+ */
+ val fooTemplateString = "$fooString değerinin ${fooString.length} adet karakteri vardır."
+ println(fooTemplateString)
+
+ /*
+ Null atanabilen bir değişken nullable olarak tanımlanmalıdır.
+ Bu, deişken tipinin sonuna ? eklenerek yapılabilir.
+ Erişim ise '?.' operatörü ile yapılır.
+ Bir değişken null ise, yerine kullaılacak alternatif bir değer belirtmek için
+ '?:' operatörünü kullanırız.
+ */
+ var fooNullable: String? = "abc"
+ println(fooNullable?.length) // => 3
+ println(fooNullable?.length ?: -1) // => 3
+ fooNullable = null
+ println(fooNullable?.length) // => null
+ println(fooNullable?.length ?: -1) // => -1
+
+ /*
+ Metodlar "fun" anahtar kelimesi ile tanımlanır.
+ Metod argümanları, Metod adından sonra parantez içinde belirtilir.
+ Metod argümanlarının opsiyonel olarak default (varsayılan) değerleri olabilir.
+ Metodun dönüş tipi, gerekirse, metod parentezinden sonra ':' operatörü ile belirtilir.
+ */
+ fun hello(name: String = "dünya"): String {
+ return "Merhaba, $name!"
+ }
+ println(hello("foo")) // => Merhaba, foo!
+ println(hello(name = "bar")) // => Merhaba, bar!
+ println(hello()) // => Merhaba, dünya!
+
+ /*
+ Bir metoda çokca argüman göndermek için 'vararg' anahtar kelimesi
+ kullanılır.
+ */
+ fun varargExample(vararg names: Int) {
+ println("${names.size} adet arguman paslanmıştır")
+ }
+ varargExample() // => 0 adet arguman paslanmıştır
+ varargExample(1) // => 1 adet arguman paslanmıştır
+ varargExample(1, 2, 3) // => 3 adet arguman paslanmıştır
+
+ /*
+ Bir metod tek bir ifadeden oluşuyorsa
+ süslü parantezler yerine '=' kullanılabilir.
+ */
+ fun odd(x: Int): Boolean = x % 2 == 1
+ println(odd(6)) // => false
+ println(odd(7)) // => true
+
+ // Eğer dönüş tipi anlaşılabiliyorsa ayrıca belirtmemize gerek yoktur.
+ fun even(x: Int) = x % 2 == 0
+ println(even(6)) // => true
+ println(even(7)) // => false
+
+ // Metodlar, metodları arguman ve dönüş tipi olarak alabilir
+ fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+ return {n -> !f.invoke(n)} // bu satırdaki !f.invoke(n) metodu !f(n) şeklinde sadeleştirilebilir.
+ }
+
+
+ // Bir metodu sadece '::' ön eki ile de arguman olarak çağırabiliriz
+ println(not(::odd)(4)) // ==> true
+
+ // Metodlar değişken gibi atanabilir.
+ val notOdd = not(::odd)
+ val notEven = not(::even)
+
+ // Lambda ifadeleri arguman olarak paslanabilir.
+ val notZero = not {n -> n == 0}
+ /*
+ Eğer bir lambda fonksiyonu sadece bir arguman alıyorsa,
+ '->' ifadesi atlanabilir, 'it' ifadesi ile belirtilebilir.
+ */
+ val notPositive = not { it > 0} // not(n -> n > 0) ifadesi ile aynı
+
+ for (i in 0..4) {
+ println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+ }
+
+ /*
+ * Diğer for döngüleri
+ * */
+ val myInt = 3
+ for (i in 1..100) { } // kapalı aralık. 100 dahil.
+ for (i in 1 until 100) { } // 100 dahil değil
+ for (x in 2..10 step 2) { } // ikişer adımlı
+ for (x in 10 downTo 1) { } // Ondan geriye doğru. 1 dahil.
+ if (myInt in 1..10) { }
+
+
+
+ /*
+ Bir sınıf tanımlamak için 'class' anahtar kelimesi kullanılır.
+ Kotlin'de bütün sınıflar varsayılan olarak 'final' tanımlanırlar.
+ * */
+ class ExampleClass(val x: Int) {
+
+ fun memberFunction(y: Int): Int {
+ return x + y
+ }
+
+ infix fun yTimes(y: Int): Int {
+ return x * y
+ }
+ }
+ /*
+ * Bir sınıfı türetilebilir yapmak için 'open' anahtar kelimesi kullanılır.
+ * */
+ open class A
+
+ class B : A()
+
+
+ /*
+ Yeni bir instance oluşturmak için doğrudan constructor çağırılır.
+ Kotlinde 'new' anahtar kelimesi yoktur.
+ */
+ val fooExampleClass = ExampleClass(7)
+ // Bir sınıfa üye metodları . (nokta) ile çağırabiliriz.
+ println(fooExampleClass.memberFunction(4)) // => 11
+ /*
+ 'infix' ön eki ile tanımlanan metodlar
+ alışılan metod çağrısını daha kolay bir söz dizimine dönüştürür.
+ */
+ println(fooExampleClass yTimes 4) // => 28
+
+ /*
+ Data class lar sadece veri tutan sınıflar için uygun bir çözümdür.
+ Bu şekilde tanımlanan sınıfların "hashCode"/"equals" ve "toString" metodları
+ otomatik olarak oluşur.
+ */
+ data class DataClassExample (val x: Int, val y: Int, val z: Int)
+ val fooData = DataClassExample(1, 2, 4)
+ println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+ // Data class ların copy metodları olur.
+ val fooCopy = fooData.copy(y = 100)
+ println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+ // Destructuring Declarations, bir objeyi çoklu değişkenler ile ifade etme yöntemidir.
+ val (a, b, c) = fooCopy
+ println("$a $b $c") // => 1 100 4
+
+ // bir 'for' döngüsü içinde 'Destructuring' :
+ for ((a, b, c) in listOf(fooData)) {
+ println("$a $b $c") // => 1 100 4
+ }
+
+ val mapData = mapOf("a" to 1, "b" to 2)
+ // Map.Entry de destructurable gösterilebilir.
+ for ((key, value) in mapData) {
+ println("$key -> $value")
+ }
+
+ // 'with' metodu ile bir objeye bir lamda metodu uygulayabiliriz.
+ data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+ val fooMutableData = MutableDataClassExample(7, 4, 9)
+ with (fooMutableData) {
+ x -= 2
+ y += 2
+ z--
+ }
+
+ println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+ /*
+ 'listOf' metodu ile bir liste oluşturulabilir.
+ Oluşan liste immutable olacaktır, yani elaman eklenemez ve çıkarılamaz.
+ */
+ val fooList = listOf("a", "b", "c")
+ println(fooList.size) // => 3
+ println(fooList.first()) // => a
+ println(fooList.last()) // => c
+ // Elemanlara indexleri ile erişilebilir.
+ println(fooList[1]) // => b
+
+ // Mutable bir liste ise 'mutableListOf' metodu ile oluşturabilir.
+ val fooMutableList = mutableListOf("a", "b", "c")
+ fooMutableList.add("d")
+ println(fooMutableList.last()) // => d
+ println(fooMutableList.size) // => 4
+
+ // Bir 'set' oluşturmak için 'setOf' metodunu kullanabiliriz.
+ val fooSet = setOf("a", "b", "c")
+ println(fooSet.contains("a")) // => true
+ println(fooSet.contains("z")) // => false
+
+ // 'mapOf' metodu ile 'map' oluşturabiliriz.
+ val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // Map değerlerine ulaşmak için :
+ println(fooMap["a"]) // => 8
+
+ /*
+ Sequence, Kotlin dilinde lazy-hesaplanan collection ları temsil eder.
+ Bunun için 'generateSequence' metodunu kullanabiliriz. Bu metod bir önceki değerden
+ bir sonraki değeri hesaplamak için gerekli bir lamda metodunu arguman olarak alır.
+ */
+ val fooSequence = generateSequence(1, { it + 1 })
+
+ val x = fooSequence.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Örneğin fibonacci serisi oluşturabilen bir 'Sequence' oluşturmak için:
+ fun fibonacciSequence(): Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun next(): Long {
+ val result = a + b
+ a = b
+ b = result
+ return a
+ }
+
+ return generateSequence(::next)
+ }
+ val y = fibonacciSequence().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+
+ // Kotlin Collection lar ile çalışmak için higher-order metodlar sağlar.
+ val z = (1..9)
+ .map {it * 3} // her bir elamanı 3 ile çarp
+ .filter {it < 20} // 20 den küçük değerleri ele
+ .groupBy {it % 2 == 0} // ikiye tam bölünen ve bölünmeyen şeklinde grupla (Map)
+ .mapKeys {if (it.key) "even" else "odd"} // oluşan map in boolen 'key' lerini String bir değere dönüştür.
+ println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+ // Bir 'for' döngüsü 'itearator' sağlayan her objeye uygulanabilir.
+ for (c in "merhaba") {
+ println(c)
+ }
+
+ // 'while' döngüsü diğer dillere benzer şekilde çalışır.
+ var ctr = 0
+ while (ctr < 5) {
+ println(ctr)
+ ctr++
+ }
+ do {
+ println(ctr)
+ ctr++
+ } while (ctr < 10)
+
+ /*
+ 'if' bir dönüş değeri olan deyim gibi de kullanılabilir.
+ Bu sebepten Kotlin, Java'da bulunan '?:' ifadesi içermez.
+ */
+ val num = 5
+ val message = if (num % 2 == 0) "even" else "odd"
+ println("$num is $message") // => 5 is odd
+
+ // 'if-else if' yapıları için 'when' kullanılabilir.
+ val i = 10
+ when {
+ i < 7 -> println("first block")
+ fooString.startsWith("hello") -> println("second block")
+ else -> println("else block")
+ }
+
+ // 'when' bir parametre ile de kullanılabilir.
+ when (i) {
+ 0, 21 -> println("0 or 21")
+ in 1..20 -> println("in the range 1 to 20")
+ else -> println("none of the above")
+ }
+
+ // 'when' dönüş değeri olan bir metod gibi de davranabilir.
+ var result = when (i) {
+ 0, 21 -> "0 or 21"
+ in 1..20 -> "in the range 1 to 20"
+ else -> "none of the above"
+ }
+ println(result)
+
+
+ /*
+ Bir objenin tipini 'is' operatörü ile tayin edebiliriz.
+ Eğer obje tip kontrolünü geçerse, cast etmeden doğrudan
+ o tipteymiş gibi kullanılabilir.
+ */
+ fun smartCastExample(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x otomatik olarak Boolean'a cast edilir.
+ return x
+ } else if (x is Int) {
+ // x otomatik olarak Int tipine cast edilir.
+ return x > 0
+ } else if (x is String) {
+ // x otomatik olarak String tipine cast edilir.
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(smartCastExample("Merhaba, dünya!")) // => true
+ println(smartCastExample("")) // => false
+ println(smartCastExample(5)) // => true
+ println(smartCastExample(0)) // => false
+ println(smartCastExample(true)) // => true
+
+ // Smartcast 'when' bloğu ile de çalışır.
+ fun smartCastWhenExample(x: Any) = when (x) {
+ is Boolean -> x
+ is Int -> x > 0
+ is String -> x.isNotEmpty()
+ else -> false
+ }
+
+ /*
+ Extension lar, bir sınıfa fonksinolalite eklemenin bir yoludur.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("Merhaba, dünya!".remove('a')) // => Merhb, düny!
+
+
+
+ //Biraz detaylı Kotlin
+
+
+ /*
+ * Delegated Properties, bir değişken tanımlarken kullanılan birkaç standart yöntemler içerir.
+ * https://kotlinlang.org/docs/reference/delegated-properties.html
+ * En bilinen delegate property metodları: lazy(), observable()
+ * */
+
+ /*
+ * Lazy, bir değişkeni ilk erişimde çalıştırılacak olan bir lambda ile tanımlama metodudur.
+ * Sonraki erişimlerde değişkene atanan değer hatırlanır.
+ * Lazy, synchronized bir delegation yöntemidir; değer sadece bir thread içinde hesaplanır,
+ * tüm thread ler aynı değere erişir. Eğer senkronizasyon gerekli değilse, lazy metodu içine
+ * LazyThreadSafetyMode.PUBLICATION paslanabilir.
+ * */
+
+ val lazyValue: String by lazy( {
+ println("bi sn... hesaplıyorum....")
+ "Selam!"
+ })
+
+ println(lazyValue)// bi sn... hesaplıyorum.... Selam!
+ println(lazyValue) // Selam!
+ /*
+ * Observable, bir değişkende olabilecek yeniden atama değişikliklerini dinleme yöntemidir.
+ * İki arguman alır; değişkenin ilk değeri, değiştiğinde çağrılan bir handler metodu. Handler
+ * metodu değişken her değiştiğinde çağırılır.
+ * */
+ var myObservableName: String by Delegates.observable("<isim yok>") {
+ prop, old, new ->
+ println("$old -> $new")
+ }
+ myObservableName = "Baha" //<isim yok> -> Baha
+ myObservableName = "Can" //Baha -> Can
+
+
+ /*
+ * Eğer değişkenin yeniden atanmasını denetlemek isterek vetoable()
+ * metodunu kullanabiliriz.
+ * */
+
+ var myVetoableName : String by Delegates.vetoable("<isim yok>"){
+ property, oldValue, newValue ->
+ if (newValue.length < 2) {
+ println("Tek harfli isim kabul etmiyoruz!")
+ false
+ } else {
+ println("$oldValue -> $newValue")
+ true
+ }
+ }
+
+ myVetoableName = "Baha" //<isim yok> -> Baha
+ myVetoableName = "C" //Tek harfli isim kabul etmiyoruz!
+ println(myVetoableName) //Baha
+
+
+ //singleton değişkene ulaşmak:
+ println(ObjectExample.hello()) // => Merhaba
+}
+
+// Enum class lar Java'daki enum lara benzerdir.
+enum class EnumExample {
+ A, B, C
+}
+
+/*
+'object' anahtar kelimesi ile singleton nesneler oluşturulabilir.
+Bu şekilde tanımlanan sınıflardan yeni nesneler oluşturulamaz, sadece adı ile refere edilebilir.
+*/
+object ObjectExample {
+ fun hello(): String {
+ return "Merhaba"
+ }
+}
+
+fun useObject() {
+ ObjectExample.hello()
+ val someRef: Any = ObjectExample
+}
+
+```
+
+### İlerisi için:
+
+* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser](http://try.kotlinlang.org/)
+* [A list of Kotlin resources](http://kotlin.link/)
+* [Kotlin Koans in your IDE](https://kotlinlang.org/docs/tutorials/koans.html/)
diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
new file mode 100644
index 00000000..b8f11e39
--- /dev/null
+++ b/tr-tr/markdown-tr.html.markdown
@@ -0,0 +1,251 @@
+---
+language: markdown
+contributors:
+ - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+ - ["Eray AYDIN", "http://erayaydin.me/"]
+lang: tr-tr
+filename: markdown-tr.md
+---
+
+Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır.
+
+
+```markdown
+<!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir
+ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve
+markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız,
+bu elementin içeriğinde markdown söz dizimlerini kullanamazsınız. -->
+
+<!-- Markdown ayrıca işleyiciden işleyiciye farklılık gösterebilir. Bu rehberde
+evrensel özelliklere uygun anlatımlar olacaktır. Bir çok işleyici bu rehberdeki
+anlatımları destekler -->
+
+<!-- Başlıklar -->
+<!-- Kolayca <h1>'den <h6>'ya HTML etiketleri oluşturabilirsiniz.
+Kare (#) sayısı bu elementin numarasını belirleyecek ve devamında getirdiğiniz
+yazı bu elementin içeriği olacaktır
+-->
+# Bu bir <h1>
+## Bu bir <h2>
+### Bu bir <h3>
+#### Bu bir <h4>
+##### Bu bir <h5>
+###### Bu bir <h6>
+
+<!-- Markdown ayrıca h1 ve h2 için 2 alternatif yol daha taşır -->
+Bu bir h1
+=========
+
+Bu bir h2
+---------
+
+<!-- Basit yazı stilleri -->
+<!-- Markdown ile yazılar kolayca italik ve kalın belirtilebilir -->
+*Bu yazı italik.*
+_Bu yazı da italik._
+
+**Bu yazı kalın.**
+__Bu yazı da kalın.__
+
+***Bu yazı hem kalın hem italik.***
+**_Bu da öyle!_**
+*__Hatta bu bile!__*
+
+<!-- GitHub Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
+~~Bu yazı üstü çizili olarak gözükecek.~~
+
+<!-- Paragraflar bir veya daha fazla boş satırla ayrılır. -->
+
+Bu bir paragraf. Paragrafın içeriğine devam ediyorum, eğlenceli değil mi?
+
+Şimdi 2. paragrafıma geçtim.
+Hala 2. paragraftayım, çünkü boş bir satır bırakmadım.
+
+Bu da 3. paragrafım!
+
+<!-- HTML'de her satır için <br /> etiketi kullanmak ister misiniz, Bir
+paragrafı bitirdikten sonra 2 veya daha fazla boşluk bırakın ve yeni paragrafa
+başlayın, bu bir <br /> etiketi sayılacaktır -->
+
+Bu yazının sonunda 2 boşluk var (bu satırı seçerek kontrol edebilirsiniz).
+
+Bir üst satırda <br /> etiketi var!
+
+<!-- Blok yazılarının yapımı oldukça kolay, (>) karakteri ile yapabilirsiniz -->
+
+> Bu bir blok etiketi. Satırlara ayırmak için
+> her satırın başında `>` karakter yerleştirmeli veya tek satırda bütün içeriği yazabilirsiniz.
+> Satır `>` karakteri ile başladığı sürece sorun yok.
+
+> Ayrıca alt alta da blok elementi açabilirsiniz
+>> iç içe yani
+> düzgün değil mi ?
+
+<!-- Listeler -->
+<!-- Numarasız listeler için yıldız, artı, veya tire kullanabilirsiniz -->
+
+* Nesne
+* Nesne
+* Bir başka nesne
+
+veya
+
++ Nesne
++ Nesne
++ Bir başka nesne
+
+veya
+
+- Nesne
+- Nesne
+- Son bir nesne
+
+<!-- Numaralı liste için başına sıralı bir şekilde sayı eklemeniz yeterli -->
+
+1. İlk nesne
+2. İkinci nesne
+3. Üçüncü nesne
+
+<!-- İsterseniz sıralı bir şekilde yazmak zorunda değilsiniz, markdown
+biçimlendirirken sizin için sıralayacaktır, fakat bunu önermiyorum. Markdown dosyasının
+düzgün gözükmesi için önerilen metodu uygulamanızı tavsiye ederim -->
+
+1. İlk nesne
+1. İkinci nesne
+1. Üçüncü nesne
+
+<!-- (Bunun çıktısı ile, sıralı olarak yazdığımız örneğin çıktısı aynı olacaktır) -->
+
+<!-- Ayrıca alt alta liste oluşturabilirsiniz -->
+
+1. İlk nesne
+2. İkinci nesne
+3. Üçüncü nesne
+ * Alt nesne
+ * Alt nesne
+4. Dördüncü nesne
+
+<!-- Ayrıca görev listeleri de bulunmakta. HTML seçim kutusu(checkbox) oluşturacaktır. -->
+Kutunun içerisinde `x` yoksa eğer seçim kutusu boş olacaktır.
+- [ ] Yapılacak ilk görev.
+- [ ] Yapılması gereken bir başka görev
+Aşağıdaki seçim kutusu ise içi dolu olacaktır.
+- [x] Bu görev başarıyla yapıldı
+
+<!-- Kod blokları -->
+<!-- Kod bloklarını(<code> elementi) belirtmek için 4 adet boşluk veya bir
+tab karakterini kullanabilirsiniz -->
+
+ Bu bir kod
+ öyle mi?
+
+<!-- Ayrıca kod içerisinde girinti kullanmak istiyorsanız tekrar `tab` veya `4 boşluk`
+kullanabilirsiniz -->
+
+ my_array.each do |item|
+ puts item
+ end
+
+<!-- Yazı içerisinde kod belirtmek için sorgu tırnağı (`) kullanabilirsiniz -->
+
+Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
+
+<!-- GitHub Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
+
+\`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
+def foobar
+ puts "Hello world!"
+end
+\`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
+
+<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, GitHub da
+``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli
+syntax aydınlatmaları uygulanacaktır -->
+
+<!-- Düz çizgi (<hr />) -->
+<!-- Düz çizgiler 3 veya daha fazla yıldız/çizgi ile yapılabilir. Boşluklar önemsiz. -->
+
+***
+---
+- - -
+****************
+
+<!-- Linkler -->
+<!-- Markdown'daki en güzel şeylerden biri kolayca link oluşturmaktır.
+Linkte göstermek istediğiniz yazıyı [] içerisine yerleştirin ve sonuna parantezler içerisinde ()
+gideceği adresi belirtin -->
+
+[Bana tıkla!](http://test.com)
+
+<!-- Ayrıca linke `title` özelliği eklemek için tırnakları kullanabilirsiniz -->
+
+[Bana tıkla!](http://test.com "Test.com'a gider")
+
+<!-- Bağıl yollar da çalışıyor. -->
+[Müzik dinle](/muzik/).
+
+<!-- Markdown ayrıca referans linklerini de destekler -->
+
+[Bu linke tıklayarak][link1] daha detaylı bilgi alabilirsiniz!
+[Ayrıca bu linki de inceleyin][foobar] tabi istiyorsanız.
+
+[link1]: http://test.com/ "harika!"
+[foobar]: http://foobar.biz/ "okey!"
+
+<!--Başlık ayrıca tek tırnak veya parantez içinde olabilir, veya direk yazılabilir.
+Referans döküman içerisindeki herhangi bir yer olabilir ve referans IDsi
+benzersiz olduğu sürece sorunsuz çalışacaktır. -->
+
+<!-- Ayrıca "dolaylı adlandırma" bulunmaktadır, "dolaylı adlandırma", linkin yazısının
+aynı zamanda onun idsi olmasıdır -->
+
+[Bu][] bir link.
+[bu]: http://bubirlink.com
+
+<!-- Fakat bu çok tercih edilen bir yöntem değil. -->
+
+<!-- Resimler -->
+<!-- Resimler aslında linklere çok benziyor fakat başında ünlem bulunuyor! -->
+![Bu alt etiketine gelecek içerik](http://imgur.com/resmim.jpg "Bu da isteğe bağlı olan bir başlık")
+
+<!-- Referanslar resimler için de geçerli -->
+![Bu alt etiketi.][resmim]
+
+[resmim]: bagil/linkler/de/calisiyor.jpg "Başlık isterseniz buraya girebilirsiniz"
+
+<!-- Çeşitli -->
+<!-- Oto-linkler -->
+
+<http://testwebsite.com/> ile
+[http://testwebsite.com/](http://testwebsite.com) aynı şeyler
+
+<!-- Oto-linkler epostaları da destekler -->
+
+<foo@bar.com>
+
+<!-- Kaçış karakterleri -->
+
+Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmamasını istiyorum,
+bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*.
+
+<!-- Tablolar -->
+<!-- Tablolar sadece GitHub Flavored Markdown'da destekleniyor ve açıkçası
+performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: -->
+
+| Sütun1 | Sütun 2 | Sütün 3 |
+| :----------- | :------: | ------------: |
+| Sola dayalı | Ortalı | Sağa dayalı |
+| test | test | test |
+
+<!-- ayrıca, bunun aynısı -->
+
+Sütun 1 | Sütun 2 | Sütun 3
+:-- | :-: | --:
+Çok çirkin göözüküyor | değil | mi?
+
+<!-- Bitiş! -->
+
+```
+
+Daha detaylı bilgi için, John Gruber'in resmi söz dizimi yazısını [buradan](http://daringfireball.net/projects/markdown/syntax) veya Adam Pritchard'ın mükemmel hatırlatma kağıdını [buradan](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) inceleyebilirsiniz.
diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown
index f27cbf08..727f973e 100644
--- a/tr-tr/objective-c-tr.html.markdown
+++ b/tr-tr/objective-c-tr.html.markdown
@@ -14,7 +14,7 @@ kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama di
Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C
programlama diline Smalltalk stilinde mesajlaşma ekler.
-```objective_c
+```objective-c
// Tek satır yorum // işaretleri ile başlar
/*
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
new file mode 100644
index 00000000..e53d5568
--- /dev/null
+++ b/tr-tr/python3-tr.html.markdown
@@ -0,0 +1,640 @@
+---
+language: python3
+contributors:
+ - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+ - ["Steven Basart", "http://github.com/xksteven"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+ - ["Eray AYDIN", "http://erayaydin.me/"]
+lang: tr-tr
+filename: learnpython3-tr.py
+---
+
+Python,90ların başlarında Guido Van Rossum tarafından oluşturulmuştur. En popüler olan dillerden biridir. Beni Python'a aşık eden sebep onun syntax beraklığı. Çok basit bir çalıştırılabilir söz koddur.
+
+Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [burayı](http://learnxinyminutes.com/docs/python/) kontrol edebilirsiniz.
+
+```python
+
+# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
+
+""" Çok satırlı olmasını istediğiniz yorumlar
+ üç adet tırnak(") işareti ile
+ yapılmaktadır
+"""
+
+####################################################
+## 1. Temel Veri Türleri ve Operatörler
+####################################################
+
+# Sayılar
+3 # => 3
+
+# Tahmin edebileceğiniz gibi matematik
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+
+# Bölme işlemi varsayılan olarak onluk döndürür
+35 / 5 # => 7.0
+
+# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Onluk kullanırsanız, sonuç da onluk olur
+3 * 2.0 # => 6.0
+
+# Kalan operatörü
+7 % 3 # => 1
+
+# Üs (2 üzeri 4)
+2**4 # => 16
+
+# Parantez ile önceliği değiştirebilirsiniz
+(1 + 3) * 2 # => 8
+
+# Boolean(Doğru-Yanlış) değerleri standart
+True
+False
+
+# 'değil' ile terse çevirme
+not True # => False
+not False # => True
+
+# Boolean Operatörleri
+# "and" ve "or" büyük küçük harf duyarlıdır
+True and False #=> False
+False or True #=> True
+
+# Bool operatörleri ile sayı kullanımı
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# Eşitlik kontrolü ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Eşitsizlik Kontrolü !=
+1 != 1 # => False
+2 != 1 # => True
+
+# Diğer karşılaştırmalar
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
+"Bu bir yazı."
+'Bu da bir yazı.'
+
+# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
+"Merhaba " + "dünya!" # => "Merhaba dünya!"
+
+# Bir yazı(string) karakter listesi gibi işlenebilir
+"Bu bir yazı"[0] # => 'B'
+
+# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
+"{} da ayrıca {}".format("yazılar", "işlenebilir")
+
+# Biçimlendirme işleminde aynı argümanı da birden fazla kullanabilirsiniz.
+"{0} çeviktir, {0} hızlıdır, {0} , {1} üzerinden atlayabilir".format("Ahmet", "şeker çubuğu")
+#=> "Ahmet çeviktir, Ahmet hızlıdır, Ahmet , şeker çubuğu üzerinden atlayabilir"
+
+# Argümanın sırasını saymak istemiyorsanız, anahtar kelime kullanabilirsiniz.
+"{isim} yemek olarak {yemek} istiyor".format(isim="Ahmet", yemek="patates") #=> "Ahmet yemek olarak patates istiyor"
+
+# Eğer Python 3 kodunuz ayrıca Python 2.5 ve üstünde çalışmasını istiyorsanız,
+# eski stil formatlamayı kullanabilirsiniz:
+"%s bu %s yolla da %s" % ("yazılar", "eski", "biçimlendirilebilir")
+
+
+# Hiçbir şey(none) da bir objedir
+None # => None
+
+# Bir değerin none ile eşitlik kontrolü için "==" sembolünü kullanmayın
+# Bunun yerine "is" kullanın. Obje türünün eşitliğini kontrol edecektir.
+"vb" is None # => False
+None is None # => True
+
+# None, 0, ve boş yazılar/listeler/sözlükler hepsi False değeri döndürü.
+# Diğer veriler ise True değeri döndürür
+bool(0) # => False
+bool("") # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Değişkenler ve Koleksiyonlar
+####################################################
+
+# Python bir yazdırma fonksiyonuna sahip
+print("Ben Python. Tanıştığıma memnun oldum!")
+
+# Değişkenlere veri atamak için önce değişkeni oluşturmanıza gerek yok.
+# Düzenli bir değişken için hepsi_kucuk_ve_alt_cizgi_ile_ayirin
+bir_degisken = 5
+bir_degisken # => 5
+
+# Önceden tanımlanmamış değişkene erişmek hata oluşturacaktır.
+# Kontrol akışları başlığından hata kontrolünü öğrenebilirsiniz.
+bir_bilinmeyen_degisken # NameError hatası oluşturur
+
+# Listeler ile sıralamaları tutabilirsiniz
+li = []
+# Önceden doldurulmuş listeler ile başlayabilirsiniz
+diger_li = [4, 5, 6]
+
+# 'append' ile listenin sonuna ekleme yapabilirsiniz
+li.append(1) # li artık [1] oldu
+li.append(2) # li artık [1, 2] oldu
+li.append(4) # li artık [1, 2, 4] oldu
+li.append(3) # li artık [1, 2, 4, 3] oldu
+# 'pop' ile listenin son elementini kaldırabilirsiniz
+li.pop() # => 3 ve li artık [1, 2, 4]
+# Çıkarttığımız tekrardan ekleyelim
+li.append(3) # li yeniden [1, 2, 4, 3] oldu.
+
+# Dizi gibi listeye erişim sağlayın
+li[0] # => 1
+# Son elemente bakın
+li[-1] # => 3
+
+# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
+li[4] # IndexError hatası oluşturur
+
+# Bir kısmını almak isterseniz.
+li[1:3] # => [2, 4]
+# Başlangıç belirtmezseniz
+li[2:] # => [4, 3]
+# Sonu belirtmesseniz
+li[:3] # => [1, 2, 4]
+# Her ikişer objeyi seçme
+li[::2] # =>[1, 4]
+# Listeyi tersten almak
+li[::-1] # => [3, 4, 2, 1]
+# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
+# li[baslangic:son:adim]
+
+# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
+del li[2] # li artık [1, 2, 3] oldu
+
+# Listelerde de ekleme yapabilirsiniz
+# Not: değerler üzerinde değişiklik yapılmaz.
+li + diger_li # => [1, 2, 3, 4, 5, 6]
+
+# Listeleri birbirine bağlamak için "extend()" kullanılabilir
+li.extend(diger_li) # li artık [1, 2, 3, 4, 5, 6] oldu
+
+# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
+1 in li # => True
+
+# Uzunluğu öğrenmek için "len()" kullanılabilir
+len(li) # => 6
+
+
+# Tüpler listeler gibidir fakat değiştirilemez.
+tup = (1, 2, 3)
+tup[0] # => 1
+tup[0] = 3 # TypeError hatası oluşturur
+
+# Diğer liste işlemlerini tüplerde de uygulayabilirsiniz
+len(tup) # => 3
+tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
+tup[:2] # => (1, 2)
+2 in tup # => True
+
+# Tüpleri(veya listeleri) değişkenlere açabilirsiniz
+a, b, c = (1, 2, 3) # 'a' artık 1, 'b' artık 2 ve 'c' artık 3
+# Eğer parantez kullanmazsanız varsayılan oalrak tüpler oluşturulur
+d, e, f = 4, 5, 6
+# 2 değeri birbirine değiştirmek bu kadar kolay
+e, d = d, e # 'd' artık 5 ve 'e' artık 4
+
+
+# Sözlükler anahtar kodlarla verileri tutar
+bos_sozl = {}
+# Önceden doldurulmuş sözlük oluşturma
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
+
+# Değere bakmak için [] kullanalım
+dolu_sozl["bir"] # => 1
+
+# Bütün anahtarları almak için "keys()" kullanılabilir.
+# Listelemek için list() kullanacağınız çünkü dönen değerin işlenmesi gerekiyor. Bu konuya daha sonra değineceğiz.
+# Not - Sözlük anahtarlarının sıralaması kesin değildir.
+# Beklediğiniz çıktı sizinkiyle tam uyuşmuyor olabilir.
+list(dolu_sozl.keys()) # => ["uc", "iki", "bir"]
+
+
+# Tüm değerleri almak için "values()" kullanacağız. Dönen değeri biçimlendirmek için de list() kullanmamız gerekiyor
+# Not - Sıralama değişebilir.
+list(dolu_sozl.values()) # => [3, 2, 1]
+
+
+# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
+"bir" in dolu_sozl # => True
+1 in dolu_sozl # => False
+
+# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
+dolu_sozl["dort"] # KeyError hatası oluşturur
+
+# "get()" metodu ile değeri almaya çalışırsanız KeyError sorunundan kurtulursunuz
+dolu_sozl.get("bir") # => 1
+dolu_sozl.get("dort") # => None
+# "get" metoduna parametre belirterek değerin olmaması durumunda varsayılan bir değer döndürebilirsiniz.
+dolu_sozl.get("bir", 4) # => 1
+dolu_sozl.get("dort", 4) # => 4
+
+# "setdefault()" metodu sözlükte, belirttiğiniz anahtarın [olmaması] durumunda varsayılan bir değer atayacaktır
+dolu_sozl.setdefault("bes", 5) # dolu_sozl["bes"] artık 5 değerine sahip
+dolu_sozl.setdefault("bes", 6) # dolu_sozl["bes"] değişmedi, hala 5 değerine sahip
+
+# Sözlüğe ekleme
+dolu_sozl.update({"dort":4}) #=> {"bir": 1, "iki": 2, "uc": 3, "dort": 4}
+#dolu_sozl["dort"] = 4 #sözlüğe eklemenin bir diğer yolu
+
+# Sözlükten anahtar silmek için 'del' kullanılabilir
+del dolu_sozl["bir"] # "bir" anahtarını dolu sözlükten silecektir
+
+
+# Setler ... set işte :D
+bos_set = set()
+# Seti bir veri listesi ile de oluşturabilirsiniz. Evet, biraz sözlük gibi duruyor. Üzgünüm.
+bir_set = {1, 1, 2, 2, 3, 4} # bir_set artık {1, 2, 3, 4}
+
+# Sete yeni setler ekleyebilirsiniz
+dolu_set = bir_set
+
+# Sete bir diğer öğe ekleme
+dolu_set.add(5) # dolu_set artık {1, 2, 3, 4, 5} oldu
+
+# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
+diger_set = {3, 4, 5, 6}
+dolu_set & diger_set # => {3, 4, 5}
+
+# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
+dolu_set | diger_set # => {1, 2, 3, 4, 5, 6}
+
+# Farklılıkları almak için "-" kullanabilirsiniz
+{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
+
+# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
+2 in dolu_set # => True
+10 in dolu_set # => False
+
+
+####################################################
+## 3. Kontrol Akışları ve Temel Soyutlandırma
+####################################################
+
+# Bir değişken oluşturalım
+bir_degisken = 5
+
+# Burada bir "if" ifadesi var. Girinti(boşluk,tab) python için önemlidir!
+# çıktı olarak "bir_degisken 10 dan küçük" yazar
+if bir_degisken > 10:
+ print("bir_degisken 10 dan büyük")
+elif bir_degisken < 10: # Bu 'elif' ifadesi zorunlu değildir.
+ print("bir_degisken 10 dan küçük")
+else: # Bu ifade de zorunlu değil.
+ print("bir_degisken değeri 10")
+
+
+"""
+Döngülerle lsiteleri döngüye alabilirsiniz
+çıktı:
+ köpek bir memeli hayvandır
+ kedi bir memeli hayvandır
+ fare bir memeli hayvandır
+"""
+for hayvan in ["köpek", "kedi, "fare"]:
+ # format ile kolayca yazıyı biçimlendirelim
+ print("{} bir memeli hayvandır".format(hayvan))
+
+"""
+"range(sayi)" bir sayı listesi döndür
+0'dan belirttiğiniz sayıyıa kadar
+çıktı:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+
+"""
+'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
+çıktı:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # Uzun hali x = x + 1
+
+# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
+try:
+ # Bir hata oluşturmak için "raise" kullanabilirsiniz
+ raise IndexError("Bu bir index hatası")
+except IndexError as e:
+ pass # Önemsiz, devam et.
+except (TypeError, NameError):
+ pass # Çoklu bir şekilde hataları kontrol edebilirsiniz, tabi gerekirse.
+else: # İsteğe bağlı bir kısım. Eğer hiçbir hata kontrol mekanizması desteklemiyorsa bu blok çalışacaktır
+ print("Her şey iyi!") # IndexError, TypeError ve NameError harici bir hatada bu blok çalıştı
+
+# Temel Soyutlandırma, bir objenin işlenmiş halidir.
+# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
+
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
+temel_soyut = dolu_sozl.keys()
+print(temel_soyut) #=> range(1,10). Bu obje temel soyutlandırma arayüzü ile oluşturuldu
+
+# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
+for i in temel_soyut:
+ print(i) # Çıktısı: bir, iki, uc
+
+# Fakat, elementin anahtarına değerine.
+temel_soyut[1] # TypeError hatası!
+
+# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
+iterator = iter(temel_soyut)
+
+# 'iterator' o obje üzerinde yaptığımız değişiklikleri hatırlayacaktır
+# Bir sonraki objeyi almak için __next__ fonksiyonunu kullanabilirsiniz.
+iterator.__next__() #=> "bir"
+
+# Bir önceki __next__ fonksiyonumuzu hatırlayıp bir sonraki kullanımda bu sefer ondan bir sonraki objeyi döndürecektir
+iterator.__next__() #=> "iki"
+iterator.__next__() #=> "uc"
+
+# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
+iterator.__next__() # StopIteration hatası
+
+# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
+list(dolu_sozl.keys()) #=> Returns ["bir", "iki", "uc"]
+
+
+####################################################
+## 4. Fonksiyonlar
+####################################################
+
+# "def" ile yeni fonksiyonlar oluşturabilirsiniz
+def topla(x, y):
+ print("x = {} ve y = {}".format(x, y))
+ return x + y # Değer döndürmek için 'return' kullanmalısınız
+
+# Fonksiyonu parametleri ile çağırıyoruz
+topla(5, 6) # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
+
+# Bir diğer fonksiyon çağırma yöntemi de anahtar değerleri ile belirtmek
+topla(y=6, x=5) # Anahtar değeri belirttiğiniz için parametre sıralaması önemsiz.
+
+# Sınırsız sayıda argüman da alabilirsiniz
+def argumanlar(*argumanlar):
+ return argumanlar
+
+argumanlar(1, 2, 3) # => (1, 2, 3)
+
+# Parametrelerin anahtar değerlerini almak isterseniz
+def anahtar_par(**anahtarlar):
+ return anahtar
+
+# Çalıştırdığımızda
+anahtar_par(anah1="deg1", anah2="deg2") # => {"anah1": "deg1", "anah2": "deg2"}
+
+
+# İsterseniz, bu ikisini birden kullanabilirsiniz
+def tum_argumanlar(*argumanlar, **anahtarla):
+ print(argumanlar)
+ print(anahtarla)
+"""
+tum_argumanlar(1, 2, a=3, b=4) çıktı:
+ (1, 2)
+ {"a": 3, "b": 4}
+"""
+
+# Fonksiyonu çağırırken de aynısını kullanabilirsiniz
+argumanlar = (1, 2, 3, 4)
+anahtarla = {"a": 3, "b": 4}
+tum_argumanlar(*argumanlar) # = foo(1, 2, 3, 4)
+tum_argumanlar(**anahtarla) # = foo(a=3, b=4)
+tum_argumanlar(*argumanlar, **anahtarla) # = foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Fonksiyonlarda kullanacağımız bir değişken oluşturalım
+x = 5
+
+def belirleX(sayi):
+ # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
+ x = sayi # => 43
+ print (x) # => 43
+
+def globalBelirleX(sayi):
+ global x
+ print (x) # => 5
+ x = sayi # global olan x değişkeni artık 6
+ print (x) # => 6
+
+belirleX(43)
+globalBelirleX(6)
+
+
+# Sınıf fonksiyonları oluşturma
+def toplama_olustur(x):
+ def topla(y):
+ return x + y
+ return topla
+
+ekle_10 = toplama_olustur(10)
+ekle_10(3) # => 13
+
+# Bilinmeyen fonksiyon
+(lambda x: x > 2)(3) # => True
+
+# TODO - Fix for iterables
+# Belirli sayıdan yükseğini alma fonksiyonu
+map(ekle_10, [1, 2, 3]) # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Filtreleme işlemi için liste comprehensions da kullanabiliriz
+[ekle_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
+
+####################################################
+## 5. Sınıflar
+####################################################
+
+
+# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
+class Insan(obje):
+
+ # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
+ tur = "H. sapiens"
+
+ # Basit başlatıcı, Sınıf çağrıldığında tetiklenecektir.
+ # Dikkat edin, iki adet alt çizgi(_) bulunmakta. Bunlar
+ # python tarafından tanımlanan isimlerdir.
+ # Kendinize ait bir fonksiyon oluştururken __fonksiyon__ kullanmayınız!
+ def __init__(self, isim):
+ # Parametreyi sınıfın değerine atayalım
+ self.isim = isim
+
+ # Bir metot. Bütün metotlar ilk parametre olarak "self "alır.
+ def soyle(self, mesaj):
+ return "{isim}: {mesaj}".format(isim=self.name, mesaj=mesaj)
+
+ # Bir sınıf metotu bütün nesnelere paylaştırılır
+ # İlk parametre olarak sınıf alırlar
+ @classmethod
+ def getir_tur(snf):
+ return snf.tur
+
+ # Bir statik metot, sınıf ve nesnesiz çağrılır
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+
+# Sınıfı çağıralım
+i = Insan(isim="Ahmet")
+print(i.soyle("merhaba")) # çıktı "Ahmet: merhaba"
+
+j = Insan("Ali")
+print(j.soyle("selam")) # çıktı "Ali: selam"
+
+# Sınıf metodumuzu çağıraim
+i.getir_tur() # => "H. sapiens"
+
+# Paylaşılan değeri değiştirelim
+Insan.tur = "H. neanderthalensis"
+i.getir_tur() # => "H. neanderthalensis"
+j.getir_tur() # => "H. neanderthalensis"
+
+# Statik metodumuzu çağıralım
+Insan.grunt() # => "*grunt*"
+
+
+####################################################
+## 6. Moduller
+####################################################
+
+# Modülleri içe aktarabilirsiniz
+import math
+print(math.sqrt(16)) # => 4.0
+
+# Modülden belirli bir fonksiyonları alabilirsiniz
+from math import ceil, floor
+print(ceil(3.7)) # => 4.0
+print(floor(3.7)) # => 3.0
+
+# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
+# Dikkat: bunu yapmanızı önermem.
+from math import *
+
+# Modül isimlerini değiştirebilirsiniz.
+# Not: Modül ismini kısaltmanız çok daha iyi olacaktır
+import math as m
+math.sqrt(16) == m.sqrt(16) # => True
+
+# Python modulleri aslında birer python dosyalarıdır.
+# İsterseniz siz de yazabilir ve içe aktarabilirsiniz Modulün
+# ismi ile dosyanın ismi aynı olacaktır.
+
+# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
+import math
+dir(math)
+
+
+####################################################
+## 7. Gelişmiş
+####################################################
+
+# Oluşturucular uzun uzun kod yazmamanızı sağlayacak ve yardımcı olacaktır
+def kare_sayilar(nesne):
+ for i in nesne:
+ yield i + i
+
+# Bir oluşturucu(generator) değerleri anında oluşturur.
+# Bir seferde tüm değerleri oluşturup göndermek yerine teker teker her oluşumdan
+# sonra geri döndürür. Bu demektir ki, kare_sayilar fonksiyonumuzda 15'ten büyük
+# değerler işlenmeyecektir.
+# Not: range() da bir oluşturucu(generator)dur. 1-900000000 arası bir liste yapmaya çalıştığınızda
+# çok fazla vakit alacaktır.
+# Python tarafından belirlenen anahtar kelimelerden kaçınmak için basitçe alt çizgi(_) kullanılabilir.
+range_ = range(1, 900000000)
+# kare_sayilar'dan dönen değer 30'a ulaştığında durduralım
+for i in kare_sayilar(range_):
+ print(i)
+ if i >= 30:
+ break
+
+
+# Dekoratörler
+# Bu örnekte,
+# Eğer lutfen_soyle True ise dönen değer değişecektir.
+from functools import wraps
+
+
+def yalvar(hedef_fonksiyon):
+ @wraps(hedef_fonksiyon)
+ def metot(*args, **kwargs):
+ msj, lutfen_soyle = hedef_fonksiyon(*args, **kwargs)
+ if lutfen_soyle:
+ return "{} {}".format(msj, "Lütfen! Artık dayanamıyorum :(")
+ return msj
+
+ return metot
+
+
+@yalvar
+def soyle(lutfen_soyle=False):
+ msj = "Bana soda alır mısın?"
+ return msj, lutfen_soyle
+
+
+print(soyle()) # Bana soda alır mısın?
+print(soyle(lutfen_soyle=True)) # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :(
+```
+
+## Daha Fazlasına Hazır Mısınız?
+
+### Ücretsiz Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
+
+### Kitaplar
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..4c2cf59b
--- /dev/null
+++ b/tr-tr/swift-tr.html.markdown
@@ -0,0 +1,589 @@
+---
+language: swift
+contributors:
+ - ["Özgür Şahin", "https://github.com/ozgurshn/"]
+filename: learnswift-tr.swift
+lang: tr-tr
+---
+
+Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir. Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
+
+
+Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
+
+Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
+
+
+
+```swift
+// modülü import etme
+import UIKit
+
+//
+// MARK: Temeller
+//
+
+
+//XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot
+//listesinde gruplama yapmanıza olanak sağlıyor
+// MARK: Bölüm işareti
+// TODO: Daha sonra yapılacak
+// FIXME: Bu kodu düzelt
+
+
+//Swift 2 de, println ve print metotları print komutunda birleştirildi.
+//Print otomatik olarak yeni satır ekliyor.
+print("Merhaba dünya") // println print olarak kullanılıyor.
+print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar.
+
+// variables (var) değer atandıktan sonra değiştirilebilir.
+// constants (let) değer atndıktan sonra değiştirilemez.
+
+var degiskenim = 42
+let øπΩ = "deger" // unicode degişken adları
+let π = 3.1415926
+let convenience = "keyword" // bağlamsal değişken adı
+let isim = "ahmet"; let soyad = "un" // farklı ifadeler noktalı virgül
+kullanılarak ayrılabilir.
+let `class` = "keyword" // rezerve edilmiş keywordler tek tırnak içerisine
+alınarak değişken adı olarak kullanılabilir
+let doubleOlduguBelli: Double = 70
+let intDegisken = 0007 // 7
+let largeIntDegisken = 77_000 // 77000
+let etiket = "birseyler " + String(degiskenim) // Cast etme
+let piYazi = "Pi = \(π), Pi 2 = \(π * 2)" // String içerisine değiken yazdırma
+
+
+// Builde özel değişkenler
+// -D build ayarını kullanır.
+#if false
+ print("yazılmadı")
+ let buildDegiskeni= 3
+#else
+ let buildDegiskeni = 7
+#endif
+print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7
+
+/*
+ Optionals Swift dilinde bazı değerleri veya yokluğu (None) bir değişkende
+ tutmanıza olanak sağlar.
+
+ Swift'te her bir degişkeninin bir değeri olması gerektiğinden, nil değeri
+ bile Optional değer olarak saklanır.
+
+ Optional<T> bir enum'dır.
+*/
+var baziOptionalString: String? = "optional" // nil olabilir.
+// yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay
+//okunabilir)
+var someOptionalString2: Optional<String> = "optional"
+
+
+if baziOptionalString != nil {
+ // ben nil değilim
+ if baziOptionalString!.hasPrefix("opt") {
+ print("ön eki var")
+ }
+
+ let bos = baziOptionalString?.isEmpty
+}
+baziOptionalString = nil
+
+// belirgin olarak acilan(unwrap) opsiyonel (optional) değer
+var acilanString: String! = "Değer bekleniliyor"
+//yukarıdakiyle aynı ama ! bir postfix operatördür (kolay okunabilir)
+var acilanString2: ImplicitlyUnwrappedOptional<String> = "Değer bekleniliyor."
+
+if let baziOpsiyonelSabitString = baziOptionalString {
+ // eğer bir değeri varsa, nil değilse
+ if ! baziOpsiyonelSabitString("tamam") {
+ // ön eke sahip değil
+ }
+}
+
+// Swift değişkenlerde herhangi bir tip saklanabilir.
+// AnyObject == id
+// Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle
+//çalışabilir
+(Class, Int, struct, etc)
+var herhangiBirObject: AnyObject = 7
+herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün"
+
+/*
+ Yorumlar buraya
+
+ /*
+ İç içe yorum yazılması da mümkün
+ */
+*/
+
+//
+// MARK: Koleksiyonlar
+//
+
+/*
+ Array ve Dictionary tipleri aslında structdırlar. Bu yüzden `let` ve `var`
+ ayrıca bu tipleri tanımlarken değişebilir(var) veya değişemez(let)
+ olduğunu belirtir.
+
+*/
+
+// Diziler
+var liste = ["balik", "su", "limon"]
+liste[1] = "şişe su"
+let bosDizi = [String]() // let == değiştirilemez
+let bosDizi2 = Array<String>() // yukarıdakiyle aynı
+var bosDegistirilebilirDizi = [String]() // var == değişebilir
+
+
+// Dictionary
+var meslekler = [
+ "Kamil": "Kaptan",
+ "Ayse": "Analist"
+]
+meslekler["Cansu"] = "Halkla İlişkiler"
+let bosDictionary = [String: Float]() // let == değiştirilemez
+let bosDictionary2 = Dictionary<String, Float>() // yukarıdakiyle aynı
+var bosDegistirilebirDictionary = [String: Float]() // var == değiştirilebilir
+
+
+//
+// MARK: Kontroller
+//
+
+// for döngüsü (dizi)
+let dizi = [1, 1, 2, 3, 5]
+for deger in dizi {
+ if deger == 1 {
+ print("Bir!")
+ } else {
+ print("Bir degil!")
+ }
+}
+
+// for döngüsü (dictionary)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+ print("\(key): \(value)")
+}
+
+// for döngüsü (aralık)
+for i in -1...liste.count {
+ print(i)
+}
+liste[1...2] = ["et", "yogurt"]
+// ..< kullanarak son elemanı çıkartabilirsiniz
+
+// while döngüsü
+var i = 1
+while i < 1000 {
+ i *= 2
+}
+
+// do-while döngüsü
+do {
+ print("merhaba")
+} while 1 == 2
+
+// Switch
+// Çok güçlü, `if` ifadesenin daha kolay okunabilir hali olarak düşünün
+// String, object örnekleri, ve primitif tipleri (Int, Double, vs) destekler.
+let sebze = "kırmızı biber"
+switch sebze {
+case "sogan":
+ let sebzeYorumu = "Biraz da domates ekle"
+case "domates", "salata":
+ let sebzeYorumu = "İyi bir sandviç olur"
+case let lokalScopeDegeri where lokalScopeDegeri.hasSuffix("biber"):
+ let sebzeYorumu = "Acı bir \(lokalScopeDegeri)?"
+default: // zorunludur (tüm olasılıkları yakalamak icin)
+ let sebzeYorumu = "Corbadaki herseyin tadı güzel"
+}
+
+
+//
+// MARK: Fonksiyonlar
+//
+
+// Fonksiyonlar first-class tiplerdir, yani başka fonksiyon içine konabilir
+// ve parametre olarak geçirilebilirler.
+
+// Swift dökümanlarıylaa birlikte Fonksiyonlar (format as reStructedText)
+
+/**
+ selamlama işlemi
+
+ :param: isim e isim
+ :param: gun e A gun
+ :returns: isim ve gunu iceren bir String
+*/
+func selam(isim: String, gun: String) -> String {
+ return "Merhaba \(isim), bugün \(gun)."
+}
+selam("Can", "Salı")
+
+// fonksiyon parametre davranışı hariç yukarıdakine benzer
+func selam2(#gerekliIsim: String, disParametreIsmi lokalParamtreIsmi: String) -> String {
+ return "Merhaba \(gerekliIsim), bugün \(lokalParamtreIsmi)"
+}
+selam2(gerekliIsim:"Can", disParametreIsmi: "Salı")
+
+// Bir tuple ile birden fazla deger dönen fonksiyon
+func fiyatlariGetir() -> (Double, Double, Double) {
+ return (3.59, 3.69, 3.79)
+}
+let fiyatTuple = fiyatlariGetir()
+let fiyat = fiyatTuple.2 // 3.79
+// _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden
+//gelir
+let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69
+print(fiyat1 == fiyatTuple.1) // true
+print("Benzin fiyatı: \(fiyat)")
+
+// Çeşitli Argümanlar
+func ayarla(sayilar: Int...) {
+ // bu bir dizidir
+ let sayi = sayilar[0]
+ let argumanSAyisi = sayilar.count
+}
+
+// fonksiyonu parametre olarak geçirme veya döndürme
+func arttirmaIslemi() -> (Int -> Int) {
+ func birEkle(sayi: Int) -> Int {
+ return 1 + sayi
+ }
+ return birEkle
+}
+var arttir = arttirmaIslemi()
+arttir(7)
+
+// referans geçirme
+func yerDegistir(inout a: Int, inout b: Int) {
+ let tempA = a
+ a = b
+ b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+yerDegistir(&someIntA, &someIntB)
+print(someIntB) // 7
+
+
+//
+// MARK: Closurelar
+//
+var sayilar = [1, 2, 6]
+
+// Fonksiyonlar özelleştirilmiş closurelardır. ({})
+
+// Closure örneği.
+// `->` parametrelerle dönüş tipini birbirinden ayırır
+// `in` closure başlığını closure bodysinden ayırır.
+sayilar.map({
+ (sayi: Int) -> Int in
+ let sonuc = 3 * sayi
+ return sonuc
+})
+
+// eger tip biliniyorsa, yukarıdaki gibi, şöyle yapabiliriz
+sayilar = sayilar.map({ sayi in 3 * sayi })
+// Hatta bunu
+//sayilar = sayilar.map({ $0 * 3 })
+
+print(sayilar) // [3, 6, 18]
+
+// Trailing closure
+sayilar = sorted(sayilar) { $0 > $1 }
+
+print(sayilar) // [18, 6, 3]
+
+// Super kısa hali ise, < operatörü tipleri çıkartabildiği için
+
+sayilar = sorted(sayilar, < )
+
+print(sayilar) // [3, 6, 18]
+
+//
+// MARK: Yapılar
+//
+
+// Structurelar ve sınıflar birçok aynı özelliğe sahiptir.
+struct IsimTablosu {
+ let isimler = [String]()
+
+ // Özelleştirilmiş dizi erişimi
+ subscript(index: Int) -> String {
+ return isimler[index]
+ }
+}
+
+// Structurelar otomatik oluşturulmuş kurucu metoda sahiptir.
+let isimTablosu = IsimTablosu(isimler: ["Ben", "Onlar"])
+let isim = isimTablosu[1]
+print("İsim \(name)") // İsim Onlar
+
+//
+// MARK: Sınıflar
+//
+
+// Sınıflar, structurelar ve üyeleri 3 seviye erişime sahiptir.
+// Bunlar: internal (default), public, private
+
+public class Sekil {
+ public func alaniGetir() -> Int {
+ return 0;
+ }
+}
+
+// Sınıfın tüm değişkenleri ve metotları publictir.
+// Eğer sadece veriyi yapılandırılmış bir objede
+// saklamak istiyorsanız, `struct` kullanmalısınız.
+
+internal class Rect: Sekil {
+ var yanUzunluk: Int = 1
+
+ // Özelleştirilmiş getter ve setter propertyleri
+ private var cevre: Int {
+ get {
+ return 4 * yanUzunluk
+ }
+ set {
+ // `newValue ` setterlarda yeni değere erişimi sağlar
+ yanUzunluk = newValue / 4
+ }
+ }
+
+ // Bir değişkene geç atama(lazy load) yapmak
+ // altSekil getter cağrılana dek nil (oluşturulmamış) olarak kalır
+ lazy var altSekil = Rect(yanUzunluk: 4)
+
+ // Eğer özelleştirilmiş getter ve setter a ihtiyacınız yoksa,
+ // ama bir değişkene get veya set yapıldıktan sonra bir işlem yapmak
+ // istiyorsanız, `willSet` ve `didSet` metotlarını kullanabilirsiniz
+ var identifier: String = "defaultID" {
+ // `willSet` argümanı yeni değer için değişkenin adı olacaktır.
+ willSet(someIdentifier) {
+ print(someIdentifier)
+ }
+ }
+
+ init(yanUzunluk: Int) {
+ self. yanUzunluk = yanUzunluk
+ // super.init i her zaman özelleştirilmiş değerleri oluşturduktan sonra
+ çağırın
+ super.init()
+ }
+
+ func kisalt() {
+ if yanUzunluk > 0 {
+ --yanUzunluk
+ }
+ }
+
+ override func alaniGetir() -> Int {
+ return yanUzunluk * yanUzunluk
+ }
+}
+
+// Basit `Kare` sınıfI `Rect` sınıfını extend ediyor.
+class Kare: Rect {
+ convenience init() {
+ self.init(yanUzunluk: 5)
+ }
+}
+
+var benimKarem = Kare()
+print(m benimKarem.alaniGetir()) // 25
+benimKarem.kisalt()
+print(benimKarem.yanUzunluk) // 4
+
+// sınıf örneğini cast etme
+let birSekil = benimKarem as Sekil
+
+// örnekleri karşılaştır, objeleri karşılaştıran == (equal to) ile aynı değil
+if benimKarem === benimKarem {
+ print("Evet, bu benimKarem")
+}
+
+// Opsiyonel init
+class Daire: Sekil {
+ var yaricap: Int
+ override func alaniGetir() -> Int {
+ return 3 * yaricap * yaricap
+ }
+
+ // Eğer init opsiyonelse (nil dönebilir) `init` den sonra soru işareti
+ // son eki ekle.
+ init?(yaricap: Int) {
+ self.yaricap = yaricap
+ super.init()
+
+ if yaricap <= 0 {
+ return nil
+ }
+ }
+}
+
+var benimDairem = Daire(radius: 1)
+print(benimDairem?.alaniGetir()) // Optional(3)
+print(benimDairem!. alaniGetir()) // 3
+var benimBosDairem = Daire(yaricap: -1)
+print(benimBosDairem?. alaniGetir()) // "nil"
+if let daire = benimBosDairem {
+ // benimBosDairem nil olduğu için çalışmayacak
+ print("circle is not nil")
+}
+
+
+//
+// MARK: Enumlar
+//
+
+// Enumlar opsiyonel olarak özel bir tip veya kendi tiplerinde olabilirler.
+// Sınıflar gibi metotlar içerebilirler.
+
+enum Kart {
+ case kupa, maca, sinek, karo
+ func getIcon() -> String {
+ switch self {
+ case .maca: return "♤"
+ case .kupa: return "♡"
+ case .karo: return "♢"
+ case .sinek: return "♧"
+ }
+ }
+}
+
+// Enum değerleri kısayol syntaxa izin verir. Eğer değişken tipi açık olarak belirtildiyse enum tipini yazmaya gerek kalmaz.
+var kartTipi: Kart = .kupa
+
+// Integer olmayan enumlar direk değer (rawValue) atama gerektirir.
+enum KitapAdi: String {
+ case john = "John"
+ case luke = "Luke"
+}
+print("Name: \(KitapAdi.john.rawValue)")
+
+// Değerlerle ilişkilendirilmiş Enum
+enum Mobilya {
+ // Int ile ilişkilendirilmiş
+ case masa(yukseklik: Int)
+ // String ve Int ile ilişkilendirilmiş
+ case sandalye(String, Int)
+
+ func aciklama() -> String {
+ switch self {
+ case .masa(let yukseklik):
+ return "Masa boyu \(yukseklik) cm"
+ case .sandalye(let marka, let yukseklik):
+ return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
+ }
+ }
+}
+
+var masa: Mobilya = .masa(yukseklik: 80)
+print(masa.aciklama()) // "Masa boyu 80 cm"
+var sandalye = Mobilya.sandalye("Foo", 40)
+print(sandalye.aciklama()) // "Foo marka sandalyenin boyu 40 cm"
+
+
+//
+// MARK: Protokoller
+//
+
+// `protocol` onu kullanan tiplerin bazı özel değişkenleri, metotları,
+// tip metotlarını,opertörleri ve alt indisleri (subscripts) içermesini
+// zorunlu hale getirebilir.
+
+protocol SekilUretici {
+ var aktif: Bool { get set }
+ func sekilOlustur() -> Sekil
+}
+
+// @objc ile tanımlanan protokoller, uygunluğu kontrol edebilmenizi sağlayacak
+// şekilde opsiyonel fonksiyonlara izin verir
+@objc protocol SekliDondur {
+ optional func sekillendirilmis()
+ optional func sekillendirilebilir() -> Bool
+}
+
+class BenimSeklim: Rect {
+ var delegate: SekliDondur?
+
+ func buyut() {
+ yanUzlunluk += 2
+
+ // Bir çalışma zamanı hatası("optional chaining") fırlatmak yerine nil
+ //değeri görmezden gelerek nil dönmek için opsiyonel değişken, metot veya
+ // altindisten sonra soru işareti koyabilirsiniz.
+ if let izinVeriyormu = self.delegate?.sekillendirilebilir?() {
+ // önce delegate i sonra metodu test edin
+ self.delegate?.sekillendirilmis?()
+ }
+ }
+}
+
+
+//
+// MARK: Diğerleri
+//
+
+// `extension`lar: Var olan tiplere ekstra özellikler ekleyin
+
+// Kare artık `Printable` protokolüne uyuyor.
+extension Kare: Printable {
+ var description: String {
+ return "Alan: \(alaniGetir()) - ID: \(self.identifier)"
+ }
+}
+
+print("Kare: \(benimKarem)")
+
+// Dahili tipleri de yeni özellikler ekleyebilirsiniz
+extension Int {
+ var customProperty: String {
+ return "Bu sayı \(self)"
+ }
+
+ func carp(num: Int) -> Int {
+ return num * self
+ }
+}
+
+print(7.customProperty) // "Bu sayı 7"
+print(14.carp(3)) // 42
+
+// Genericler: Java ve C#'a benzer şekilde. `where` anahtar kelimesini
+// kullanarak genericlerin özelliklerini belirleyin
+
+func indexiBul<T: Equatable>(dizi: [T], bulunacakDeger: T) -> Int? {
+ for (index, deger) in enumerate(dizi) {
+ if deger == bulunacakDeger {
+ return index
+ }
+ }
+ return nil
+}
+let bulunanIndex = indexiBul([1, 2, 3, 4], 3)
+print(bulunanIndex == 2) // true
+
+// Operatorler:
+// Özel operatorler şu karakterlerle başlayabilir:
+// / = - + * % < > ! & | ^ . ~
+// veya
+// Unicode math, symbol, arrow, dingbat, ve line/box karakterleri.
+prefix operator !!! {}
+
+// Yan uzunluğu 3 katına çıkartan prefix operatörü
+prefix func !!! (inout sekil: Kare) -> Kare {
+ sekil.YanUzunluk *= 3
+ return sekil
+}
+
+// güncel deger
+print(benimKarem.YanUzunluk) // 4
+
+// yan uzunluğu !!! operatorü kullanarak 3 katına çıkar
+!!!benimKarem
+print(benimKarem.YanUzunluk) // 12
+```
diff --git a/tr-tr/typescript-tr.html.markdown b/tr-tr/typescript-tr.html.markdown
new file mode 100644
index 00000000..1bf674c6
--- /dev/null
+++ b/tr-tr/typescript-tr.html.markdown
@@ -0,0 +1,180 @@
+---
+language: TypeScript
+contributors:
+ - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+ - ["Mustafa Zengin", "http://zengin.github.com"]
+filename: learntypescript-tr.ts
+lang: tr-tr
+---
+
+TypeScript, JavaScript'le yazılmış büyük ölçekli uygulamaların geliştirilmesini kolaylaştırmayı hedefleyen bir dildir.
+TypeScript, JavaScript'e sınıflar, modüller, arayüzler, jenerik tipler ve (isteğe bağlı) static tipleme gibi genel konseptler ekler.
+JavaScript, TypeScript'in bir alt kümesidir: Bütün JavaScript kodları geçerli birer TypeScript kodudur ve sorunsuz herhangi bir projeye eklenebilirler. TypeScript derleyici JavaScript kodu üretir.
+
+Bu makale sadece TypeScript'e ait ekstra söz dizimini konu alır, JavaScript için bkz: [JavaScript] (../javascript/).
+
+TypeScript derleyiciyi test etmek için [Playground] (http://www.typescriptlang.org/Playground)'a gidin. Orada otomatik tamamlama ile kod yazabilecek ve üretilen JavaScript'i görebileceksiniz.
+
+```js
+// TypeScript'te üç ana tip vardır.
+var bittiMi: boolean = false;
+var satırlar: number = 42;
+var isim: string = "Anders";
+
+// Tipin bilinmediği zamanlar için "Any" tipi
+var bilinmiyor: any = 4;
+bilinmiyor = "belki de bir string'dir";
+bilinmiyor = false; // tamam, boolean olsun
+
+// Kolleksiyon olarak, tipli ve jenerik diziler
+var liste: number[] = [1, 2, 3];
+// Alternatif olarak jenerik Array tipi
+var liste: Array<number> = [1, 2, 3];
+
+// 'enum' tipleri:
+enum Renk {Kırmızı, Yeşil, Mavi};
+var r: Renk = Renk.Yeşil;
+
+// Son olarak, "void" hiç bir şey döndürmeyen fonksiyonlarda kullanılan tiptir.
+function çokFeciBirUyarı(): void {
+ alert("Ben biraz sinir bozucuyum!");
+}
+
+// Fonksiyonlar birinci sınıf vatandaşlardır ve "kalın ok" lambda söz dizimi "=>"
+// ve tip çıkarımı kullanırlar.
+// Aşağıda listelenenler birbirinin aynısı ve derleyici aynı fonksiyon yapısını
+// çıkaracak ve aynı JavaScript kodunu üretecektir
+var f1 = function(i: number): number { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+var f4 = (i: number) => { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+// Tek satırlık yazımda "return" anahtar kelimesine ihtiyaç yok.
+var f5 = (i: number) => i * i;
+
+// Arayüzler yapısaldır, listelenen özelliklere sahip her şey arayüzle uyumludur.
+interface Kişi {
+ isim: string;
+ // İsteğe bağlı özellikler "?" ile işaretlenir
+ yaş?: number;
+ // Ve fonksiyonlar...
+ hareketEt(): void;
+}
+
+// "Kişi" arayüzünü kullanan bir nesne
+// isim ve hareketEt özelliklerine sahip olduğu için Kişi olarak kullanılabilir.
+var p: Kişi = { isim: "Anders", hareketEt: () => {} };
+// İsteğe bağlı özelliğe sahip bir Kişi
+var geçerliKişi: Kişi = { isim: "Anders", yaş: 42, hareketEt: () => {} };
+// Geçersiz bir kişi, çünkü yaş bir sayı (number) tipi değil
+var geçersizKişi: Kişi = { isim: "Anders", yaş: true };
+
+// Arayüzler bir fonksiyon tipi de ifade edebilirler
+interface aramaFonksiyonu {
+ (kaynak: string, altString: string): boolean;
+}
+
+// Parametrelerin sadece tipleri önemli, isimleri önemli değil
+var benimAramam: aramaFonksiyonu;
+benimAramam = function(kynk: string, alt: string) {
+ return kynk.search(alt) != -1;
+}
+
+// Sınıflar - üyeler (members) varsayılan olarak public'tir.
+class Nokta {
+ // Özellikler
+ x: number;
+
+ // Yapıcı (constructor) - bu bağlamdaki public/private anahtar kelimeleri
+ // özellikler için gerekli demirbaş kodu oluşturur ve ilk değerlerin
+ // atanmasını sağlar.
+ // Bu örnekte, "y" de "x" gibi tanımlanacak is, but with less code
+ // Default values are also supported
+
+ constructor(x: number, public y: number = 0) {
+ this.x = x;
+ }
+
+ // Fonksiyonlar
+ mesafe() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+ // Statik üyeler
+ static orijin = new Nokta(0, 0);
+}
+
+var p1 = new Nokta(10 ,20);
+var p2 = new Nokta(25); //y = 0
+
+// Kalıtım
+class Nokta3Boyutlu extends Nokta {
+ constructor(x: number, y: number, public z: number = 0) {
+ super(x, y); // süper sınıfın yapıcısını çağırmak zorunlu
+ }
+
+ // yeniden tanımlama
+ mesafe() {
+ var d = super.mesafe();
+ return Math.sqrt(d * d + this.z * this.z);
+ }
+}
+
+// Modüller, "." alt modülleri ayırmak için kullanılabilir
+module Geometri {
+ export class Kare {
+ constructor(public kenarUzunluğu: number = 0) {
+ }
+ alan() {
+ return Math.pow(this.kenarUzunluğu, 2);
+ }
+ }
+}
+
+var s1 = new Geometri.Kare(5);
+
+// Modüle atıfta bulunmak için yerel takma ad
+import G = Geometri;
+
+var s2 = new G.Kare(10);
+
+// Jenerik Tipler
+// Sınıflar
+class Tuple<T1, T2> {
+ constructor(public item1: T1, public item2: T2) {
+ }
+}
+
+// Arayüzler
+interface Çift<T> {
+ item1: T;
+ item2: T;
+}
+
+// Ve fonksiyonlar
+var çifttenTupleÜret = function<T>(p: Çift<T>) {
+ return new Tuple(p.item1, p.item2);
+};
+
+var tuple = çifttenTupleÜret({ item1:"merhaba", item2:"dünya"});
+
+// Tanım dosyasına atıfta bulunma:
+/// <reference path="jquery.d.ts" />
+
+// Şablon Stringleri (ters apostrof kullanan stringler)
+// Şablon Stringlerinin kullanımı
+var isim = 'Anders';
+var selamlama = `Merhaba ${isim}, nasılsın?`
+// Şablon Stringleri ile çok satırlı stringler
+var çokSatırlıString = `Bu çok satırlı
+bir string örneği`;
+
+```
+
+## Daha fazlası
+ * [TypeScript Resmi Sitesi] (http://www.typescriptlang.org/)
+ * [TypeScript dil spesifikasyonu (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Channel 9'da TypeScript'e Giriş] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [GitHub'ta Açık Kaynak Kodu] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - tip tanımları için kaynak] (http://definitelytyped.org/)