6 files changed, 611 insertions, 21 deletions

diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
index baca4217..bd842b17 100644
--- a/tr-tr/brainfuck-tr.html.markdown
+++ b/tr-tr/brainfuck-tr.html.markdown
@@ -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..2d4240ed 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
 
     ///////////////////////////////////////
@@ -485,4 +485,4 @@ Readable code is better than clever code and fast code. For a good, sane coding
 
 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 a68026a5..91c7c269 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -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/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
index 2477c5da..c7de2922 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -538,7 +538,7 @@ Insan.grunt()   # => "*grunt*"
 
 # Modülleri içe aktarabilirsiniz
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # Modülden belirli bir fonksiyonları alabilirsiniz
 from math import ceil, floor
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..15056bb8
--- /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.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
+```