merge conflict error fixed

tr/02.3.md

@@ -13,31 +13,18 @@ Akış kontrolü programcılıkta en büyük icattır. Onun sayesinde, basit kon
 `if` şartları için Go da paranteze gerek yoktur.
 
 	if x > 10 {
-<<<<<<< HEAD
     	fmt.Println("x 10'dan büyüktür")
 	} else {
     	fmt.Println("x 10'dan küçük veya eşittir")
-=======
-    	fmt.Println("x is greater than 10")
-	} else {
-    	fmt.Println("x is less than or equal to 10")
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	} 
 	
 Go da çok işe yarar bir `if` kullanımı, şart ifadesinden önce değişken tanımlama yapmaktır. Bu değişkenin kapsamı sadece `if` blok alanı içerisinde geçerlidir.
 
 	// x'i tanımla, ve 10 dan büyük olup olmadığını kontrol et 
-<<<<<<< HEAD
 	if x := islenenDeger(); x > 10 {
     	fmt.Println("x 10'dan büyüktür")
 	} else {
     	fmt.Println("x 10'dan küçüktür")
-=======
-	if x := computedValue(); x > 10 {
-    	fmt.Println("x is greater than 10")
-	} else {
-    	fmt.Println("x is less than 10")
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 	// Bu satır derlenemez
@@ -45,21 +32,12 @@ Go da çok işe yarar bir `if` kullanımı, şart ifadesinden önce değişken t
 	
 Birden fazla şart için `if-else` kullanın.	
 
-<<<<<<< HEAD
 	if sayı == 3 {
     	fmt.Println("Sayı 3'e eşittir")
 	} else if integer < 3 {
     	fmt.Println("Sayı 3'ten küçüktür")
 	} else {
     	fmt.Println("Sayı 3'ten büyüktür")
-=======
-	if integer == 3 {
-    	fmt.Println("The integer is equal to 3")
-	} else if integer < 3 {
-    	fmt.Println("The integer is less than 3")
-	} else {
-    	fmt.Println("The integer is greater than 3")
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 	
 ### goto
@@ -68,17 +46,10 @@ Go da `goto` terimi mevcuttur fakat kullanırken dikkatli olun. `goto` programı
 
 	func myFunc() {
     	i := 0
-<<<<<<< HEAD
 	Buraya:   // label sonuna ":" koyulur
     	fmt.Println(i)
     	i++
     	goto Buraya   // "Buraya" labeline git
-=======
-	Here:   // label ends with ":"
-    	fmt.Println(i)
-    	i++
-    	goto Here   // jump to label "Here"
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 	
 Label'ın adı büyük-küçük harfe duyarlıdır.
@@ -87,19 +58,11 @@ Label'ın adı büyük-küçük harfe duyarlıdır.
 
 `for` Go da bulunan en güçlü kontrol lojiğidir. Datayı döngüsel olarak ve tekrarlı işlemlerle okuyabilir, `while` döngüsü gibi.
 
-<<<<<<< HEAD
 	for ifade1; ifade2; ifade3 {
     	//...
 	}
 
 `ifade1`, `ifade2` ve `ifade3` birer ifade olmak üzere, `ifade1` ve `ifade3` değişken tanımlama veya bir fonksiyondan dönen değer olabilirken, `ifade2` ise kontrol ifadesidir. `ifade1` ifadesi döngüye girmeden önce bir kere işlenecektir. `ifade3` ise her döngü sonunda işlenir.
-=======
-	for expression1; expression2; expression3 {
-    	//...
-	}
-
-`expression1`, `expression2` ve `expression3` birer ifade olmak üzere, `expression1` ve `expression3` değişken tanımlama veya bir fonksiyondan dönen return olabilirken, `expression2` ise kontrol ifadesidir. `expression1` ifadesi döngüye girmeden önce bir kere işlenecektir. `expression3` ise her döngü sonunda işlenir.
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 
 Örnekler düz yazıdan daha yararlı olacaktır.
 
@@ -107,7 +70,6 @@ Label'ın adı büyük-küçük harfe duyarlıdır.
 	import "fmt"
 
 	func main(){
-<<<<<<< HEAD
     	toplam := 0;
     	for index:=0; index < 10 ; index++ {
         	toplam += index
@@ -123,85 +85,43 @@ Bazen birden fazla atama yapmak gerekir fakat Go bunun için kullanılacak bir `
 	toplam := 1
 	for ; toplam < 1000;  {
     	toplam += toplam
-=======
-    	sum := 0;
-    	for index:=0; index < 10 ; index++ {
-        	sum += index
-    	}
-    	fmt.Println("sum is equal to ", sum)
-	}
-	// Print：sum is equal to 45
-
-Bazen birden fazla atama yapmak gerekir fakat Go bunun için kullanılacak bir `,` operatörü yoktur. Biz de `i, j = i + 1, j - 1` gibi paralel atamalar yaparız.
-
-İhtiyacımız yoksa `expression1` ve `expression1` ifadelerini çıkarabiliriz.
-
-	sum := 1
-	for ; sum < 1000;  {
-    	sum += sum
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Hatta `;` bile çıkarılabilir. Tanıdık geldi mi? Evet, tamamen `while` gibi oldu.
 
-<<<<<<< HEAD
 	toplam := 1
 	for toplam < 1000 {
     	toplam += toplam
-=======
-	sum := 1
-	for sum < 1000 {
-    	sum += sum
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Döngülerde `break` ve `continue` adında iki önemli işlem vardır. `break` döngüden çıkartır ve `continue` o anki tekrarı atlar ve sonraki tekrara geçer. Eğer birden fazla iç içe döngüleriniz varsa `break` ile labelları kullabilirsiniz.
 
 	for index := 10; index>0; index-- {
     	if index == 5{
-<<<<<<< HEAD
         	break // veya continue
     	}
     	fmt.Println(index)
 	}
 	// break varsa yazılanlar: 10、9、8、7、6
 	// continue varsa yazılanlar: 10、9、8、7、6、4、3、2、1
-=======
-        	break // or continue
-    	}
-    	fmt.Println(index)
-	}
-	// break prints 10、9、8、7、6
-	// continue prints 10、9、8、7、6、4、3、2、1
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 
 `for` döngüsü `range` kullanıldığında `slice` ve `map` de bulunan datayı okuyabilir.
 
 	for k,v:=range map {
-<<<<<<< HEAD
     	fmt.Println("map'in k anahtarı:", k)
     	fmt.Println("map'in k anahtarındaki değeri:", v)
-=======
-    	fmt.Println("map's key:",k)
-    	fmt.Println("map's val:",v)
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Go da birden fazla değer return yapılabildiği ve kullanılmayan bir değişken olduğunda derleyici hata verdiği için, kullanmak istemediğiniz değişkenler için `_` kullanabilirsiniz.
 
 	for _, v := range map{
-<<<<<<< HEAD
     	fmt.Println("map'in değeri:", v)
-=======
-    	fmt.Println("map's val:", v)
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 	
 ### switch
 
 Bazı durumlarda çok fazla `if-else` kullandığınızı farkedebilirsiniz. Bu programı okumayı zorlaştırır ve gelecekte bakım yapmayı zorlaştırabilir. Bu durumda problemi çözmek için `switch` kullanmak mükemmeldir. 
 
-<<<<<<< HEAD
 	switch anaIfade {
 	case ifade1:
     	// eşleşme olursa işlenecek kod
@@ -211,17 +131,6 @@ Bazı durumlarda çok fazla `if-else` kullandığınızı farkedebilirsiniz. Bu
     	// eşleşme olursa işlenecek kod
 	default:
     	// eşleşme olmazsa işlenecek kod
-=======
-	switch sExpr {
-	case expr1:
-    	some instructions
-	case expr2:
-    	some other instructions
-	case expr3:
-    	some other instructions
-	default:
-    	other code
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 `sExpr`, `expr1`, `expr2`, ve `expr3` ifadelerinin türleri aynı olmalıdır. `switch` çok esnektir. Şartlar sabit olmak zorunda değildir ve şart sağlanana kadar yukarıdan aşağıya doğru çalışır. Eğer `switch` in ardından bir ifade gelmiyorsa `true` olarak görülür.
@@ -229,7 +138,6 @@ Bazı durumlarda çok fazla `if-else` kullandığınızı farkedebilirsiniz. Bu
 	i := 10
 	switch i {
 	case 1:
-<<<<<<< HEAD
     	fmt.Println("i 1'e eşittir")
 	case 2, 3, 4:
     	fmt.Println("i 2, 3 veya 4'e eşittir")
@@ -237,20 +145,10 @@ Bazı durumlarda çok fazla `if-else` kullandığınızı farkedebilirsiniz. Bu
     	fmt.Println("i 10'a eşittir")
 	default:
     	fmt.Println("Tek bildiğim i nin bir sayi olduğu")
-=======
-    	fmt.Println("i is equal to 1")
-	case 2, 3, 4:
-    	fmt.Println("i is equal to 2, 3 or 4")
-	case 10:
-    	fmt.Println("i is equal to 10")
-	default:
-    	fmt.Println("All I know is that i is an integer")
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Beşinci satırdaki gibi `case` içinde birden fazla değer olabilir. `case` sonlarına `break` eklemeye gerek yoktur, şart sağlanıp işlem yapıldıktan sonra çıkacaktır. Eğer çıkmasını istemiyorsanız `fallthrough` ifadesini kullanarak bir sonraki şarta devam edebilirsiniz.
 
-<<<<<<< HEAD
 	sayı := 6
 	switch sayı {
 	case 4:
@@ -287,59 +185,14 @@ Programın sonucu şu olacaktır.
     	// fonksiyon gövdesi
     	// birden fazla return
     	return dönüş1, dönüş2
-=======
-	integer := 6
-	switch integer {
-	case 4:
-		fmt.Println("integer <= 4")
-		fallthrough
-	case 5:
-		fmt.Println("integer <= 5")
-		fallthrough
-	case 6:
-		fmt.Println("integer <= 6")
-		fallthrough
-	case 7:
-		fmt.Println("integer <= 7")
-		fallthrough
-	case 8:
-		fmt.Println("integer <= 8")
-		fallthrough
-	default:
-		fmt.Println("default case")
-	}
-	
-This program prints the following information.
-
-	integer <= 6
-	integer <= 7
-	integer <= 8
-	default case
-
-## Functions
-
-`func` terimini kullanarak bir fonksiyon tanımlayın.
-
-	func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
-    	// function body
-    	// multi-value return
-    	return value1, value2
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Yukarıdaki örnekten tahmin edebileceğiniz üzere aşağıda açıklamaları bulunur.
 
-<<<<<<< HEAD
 - `fonksiyonAdı` adlı foonksiyonu tanımlamak için `func` terimini kullanın.
 - Fonksiyonlar sıfır veya daha fazla parametreye sahip olabilir. Parametrenin türü adından sonra gelir ve birden fazla parametre varsa `,` ile ayrılır.
 - Fonksiyonlar birden fazla değer döndürebilirler.
 - Bu örnekte `çıkış1` ve `çıkış2` adında iki değer döndürülmüş. Bunlara ad vermek zorunda değilsiniz, türünü yazmanız yeterli.
-=======
-- `funcName` adlı foonksiyonu tanımlamak için `func` terimini kullanın.
-- Fonksiyonlar sıfır veya daha fazla parametreye sahip olabilir. Parametrenin türü adından sonra gelir ve birden fazla parametre varsa `,` ile ayrılır.
-- Fonksiyonlar birden fazla değer döndürebilirler.
-- Bu örnekte `output1` ve `output2` adında iki değer döndürülmüş. Bunlara ad vermek zorunda değilsiniz, türünü yazmanız yeterli.
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 - Eğer sadece bir değer döndürecekseniz parantez olmadan yazmalısınız.
 - Eğer en az bir değer döndürüyorsanız, fonksiyonun içinde istediğiniz yerde `return` terimini kullanmalısınız.
 
@@ -348,11 +201,7 @@ Yukarıdaki örnekten tahmin edebileceğiniz üzere aşağıda açıklamaları b
 	package main
 	import "fmt"
 
-<<<<<<< HEAD
 	// a ile b arasından büyük olanı döndür
-=======
-	// return greater value between a and b
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	func max(a, b int) int {
     	if a > b {
         	return a
@@ -365,21 +214,12 @@ Yukarıdaki örnekten tahmin edebileceğiniz üzere aşağıda açıklamaları b
     	y := 4
     	z := 5
 
-<<<<<<< HEAD
     	max_xy := max(x, y) // max(x, y) fonskiyonunu çağır
     	max_xz := max(x, z) // max(x, z) fonksiyonunu çağır
 
     	fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
     	fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
     	fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // burada da fonksiyon çağırıldı
-=======
-    	max_xy := max(x, y) // call function max(x, y)
-    	max_xz := max(x, z) // call function max(x, z)
-
-    	fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
-    	fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
-    	fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // call function here
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Yukarıdaki örnek fonksiyon `max` da iki aynı tür parametre `int` olduğu için bir tane yazmak yeterli olur. Yani `a int, b int` yerine `a, b int` kullanılır. Birden fazla parametre için de aynı kural geçerlidir. Farkettiyseniz `max` fonksiyonu sadece bir değer döndürür ve zorunda olmadığımız için o değere bir isim vermedik, bu kısa halini kullandık. 
@@ -393,13 +233,8 @@ Alttaki örnekte bunu kullanalım.
 	package main
 	import "fmt"
 
-<<<<<<< HEAD
 	// A+B ve A*B nin sonuçlarını döndür
 	func toplaVeCarp(A, B int) (int, int) {
-=======
-	// return results of A + B and A * B
-	func SumAndProduct(A, B int) (int, int) {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
     return A+B, A*B
 	}
 
@@ -407,30 +242,17 @@ Alttaki örnekte bunu kullanalım.
     	x := 3
     	y := 4
 
-<<<<<<< HEAD
     	xARTIy, xCARPIy := SumAndProduct(x, y)
 
     	fmt.Printf("%d + %d = %d\n", x, y, xARTIy)
     	fmt.Printf("%d * %d = %d\n", x, y, xCARPIy)
-=======
-    	xPLUSy, xTIMESy := SumAndProduct(x, y)
-
-    	fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
-    	fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 	
 Üstteki fonksiyon isimsiz iki değer döndürür -isterseniz isim verebilirsiniz. Eğer isimlendirseydik, `return` yazıp isimlerini yazmamız yeterdi. Çünkü fonksiyonun içinde tanımlılar. Şuna dikkat etmelisiniz ki eğer fonksiyonu başka bir pakette kullanacaksanız (fonksiyonun ilk harfi büyük harfle başlamalıdır) `return` yapacaklarınızı tam bir ifade olarak yazmanız daha iyi olacaktır. Kodu daha okunur hale getirir. 
 
-<<<<<<< HEAD
 	func ToplaVeCarp(A, B int) (toplanan int, carpılan int) {
     	toplanan = A+B
     	carpılan = A*B
-=======
-	func SumAndProduct(A, B int) (add int, multiplied int) {
-    	add = A+B
-    	multiplied = A*B
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
     	return
 	}
 
@@ -443,11 +265,7 @@ Go birden fazla argüman alabilen fonksiyonları destekler. Bunlara variadic (be
 `arg …int` kısmı Go ya bu fonksiyonun değişen sayıda argüman aldığını söyler. Bu argümanların türü `int` dir. `arg` fonksiyonun gövdesinde `int` türünde bir `slice` olur.
 
 	for _, n := range arg {
-<<<<<<< HEAD
     	fmt.Printf("Sayı: %d\n", n)
-=======
-    	fmt.Printf("And the number is: %d\n", n)
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 	
 ### Değer ile devretmek ve pointerlar
@@ -459,23 +277,15 @@ Bunun kanıtı olarak bir örnek görelim.
 	package main
 	import "fmt"
 
-<<<<<<< HEAD
 	// a ya 1 eklemek için basit bir fonksiyon
 	func birEkle(a int) int {
     	a = a+1 // a'nın değeri değişti
     	return a // a'nın yeni değeri döndürülüyor
-=======
-	// simple function to add 1 to a
-	func add1(a int) int {
-    	a = a+1 // we change value of a 
-    	return a // return new value of a
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 	func main() {
     	x := 3
 
-<<<<<<< HEAD
     	fmt.Println("x = ", x)  // sonuç "x = 3" olmalı
 
     	x1 := birEkle(x)  // birEkle(x) fonksiyonu çağırıldı
@@ -491,58 +301,25 @@ Sebebi basit: `birEkle` i çağırdığımızda ona `x` in bir kopyasını gönd
 Şimdi sorabilirsiniz `x` in kendisini nasıl fonksiyona verebilirim diye.
 
 Burada pointer kullanmamız gerekiyor. Biliyoruz ki değişkenler bellekte tutulur ve bir adresleri vardır. Eğer değişkenin aslını değiştirmek istiyorsak onun bellek adresini kullanmalıyız. Böylelikle `birEkle` fonksiyonu `x` in adresini kullanarak onun değerini değiştirebilir. Parametre türünü `*int` olarak değiştiriyoruz ve değişkenin adresini `&x` ile fonksiyona veriyoruz. Fonksiyona değerin bir kopyasını değil de bir pointer verdiğimize dikkat edin.
-=======
-    	fmt.Println("x = ", x)  // should print "x = 3"
-
-    	x1 := add1(x)  // call add1(x)
-
-    	fmt.Println("x+1 = ", x1) // should print "x+1 = 4"
-    	fmt.Println("x = ", x)    // should print "x = 3"
-	}
-
-Gördünüz mü? `add1` fonksiyonuna `x` i gönderdiğimiz halde asıl değeri değişmedi.
-
-Sebebi basit: `add1` i çağırdığımızda ona `x` in bir kopyasını gönderdik `x` in kendisini değil.
-
-Şimdi sorabilirsiniz `x` in kendisini nasıl fonksiyona verebilirim diye.
-
-Burada pointer kullanmamız gerekiyor. Biliyoruz ki değişkenler bellekte tutulur ve bir adresleri vardır. Eğer değişkenin aslını değiştirmek istiyorsak onun bellek adresini kullanmalıyız. Böylelikle `add1` fonksiyonu `x` in adresini kullanarak onun değerini değiştirebilir. Parametre türünü `*int` olarak değiştiriyoruz ve değişkenin adresini `&x` ile fonksiyona veriyoruz. Fonksiyona değerin bir kopyasını değil de bir pointer verdiğimize dikkat edin.
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 
 	package main
 	import "fmt"
 
-<<<<<<< HEAD
 	// a ya 1 eklemek için basit bir fonksiyon
 	func birEkle(a *int) int {
     	*a = *a+1 // a'nın değeri değişti
     	return *a // a'nın yeni değeri döndürülüyor
-=======
-	// simple function to add 1 to a
-	func add1(a *int) int {
-    	*a = *a+1 // we changed value of a
-    	return *a // return new value of a
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 	func main() {
     	x := 3
 
-<<<<<<< HEAD
     	fmt.Println("x = ", x)  // sonuç "x = 3" olmalı
 
     	x1 := add1(&x)  // birEkle(x) fonksiyonu çağırıldı ve x'in adresi verildi
 
     	fmt.Println("x+1 = ", x1) // sonuç "x+1 = 4" olmalı
     	fmt.Println("x = ", x)    // sonuç "x = 4" olmalı
-=======
-    	fmt.Println("x = ", x)  // should print "x = 3"
-
-    	x1 := add1(&x)  // call add1(&x) pass memory address of x
-
-    	fmt.Println("x+1 = ", x1) // should print "x+1 = 4"
-    	fmt.Println("x = ", x)    // should print "x = 4"
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 Şimdi `x` in asıl değerini değiştirebiliriz. Neden pointer kullanıyoruz? Avantajı nedir?
@@ -555,26 +332,15 @@ Burada pointer kullanmamız gerekiyor. Biliyoruz ki değişkenler bellekte tutul
 
 Go da iyi tasarlanmış `defer` (ertelemek) adlı bir terim vardır. Bir fonksiyonda birden fazla `defer` ifadesi bulunabilir, program çalıştığında sondan başa sırayla çalışacaklardır. Programın dosya açtığı durumlarda bu dosyaların hata vermeden önce kapatılması gerekir. Örneklere bakalım.
 
-<<<<<<< HEAD
 	func OkuYaz() bool {
     	file.Open("dosya")
 	// Kod
     	if hataX {
-=======
-	func ReadWrite() bool {
-    	file.Open("file")
-	// Do some work
-    	if failureX {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
         	file.Close()
         	return false
     	}
 
-<<<<<<< HEAD
     	if hataY {
-=======
-    	if failureY {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
         	file.Close()
         	return false
         }
@@ -585,7 +351,6 @@ Go da iyi tasarlanmış `defer` (ertelemek) adlı bir terim vardır. Bir fonksiy
 
 Bazı kodların tekrar ettiğini görüyoruz. `defer` bu problemi çok iyi çözer. Daha temiz kod yazmanıza yardım etmekle kalmaz kodunuzu daha okunur yapar.
 
-<<<<<<< HEAD
 	func OkuYaz() bool {
     	file.Open("dosya")
     	defer file.Close()
@@ -593,15 +358,6 @@ Bazı kodların tekrar ettiğini görüyoruz. `defer` bu problemi çok iyi çöz
         	return false
     	}
     	if hataY {
-=======
-	func ReadWrite() bool {
-    	file.Open("file")
-    	defer file.Close()
-    	if failureX {
-        	return false
-    	}
-    	if failureY {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
         	return false
     	}
     	return true
@@ -617,46 +373,29 @@ Eğer birden fazla `defer` varsa ters sırayla çalışırlar. Sıradaki örnek
 
 Go'da fonksiyonlar aynı zamanda değişken olabilirler. `type` onları kullanarak tanımlayabiliriz. Aynı imzaya sahip fonksiyonlar ayno tür olarak görülebilir.
 
-<<<<<<< HEAD
 	type türAdı func(parametre1 tür1, parametre2 tür2 [, ...]) (çıkış1 tür1 [, ...])
-=======
-	type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 
 Bunun avantajı nedir? Cevap, fonksiyonları değer olarak verebilmemizi sağlamasıdır.
 
 	package main
 	import "fmt"
 
-<<<<<<< HEAD
 	type testInt func(int) bool // değişken olarak fonksiyon tanımlandı
 
 	func tekMi(sayı int) bool {
     	if sayı%2 == 0 {
-=======
-	type testInt func(int) bool // define a function type of variable
-
-	func isOdd(integer int) bool {
-    	if integer%2 == 0 {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
         	return false
     	}
     	return true
 	}
 
-<<<<<<< HEAD
 	func çiftMi(sayı int) bool {
     	if sayı%2 == 0 {
-=======
-	func isEven(integer int) bool {
-    	if integer%2 == 0 {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
         	return true
     	}
     	return false
 	}
 
-<<<<<<< HEAD
 	// 'f' fonksiyonunu bir fonksiyona parametre olarak ata
 
 	func filtre(slice []int, f testInt) []int {
@@ -667,24 +406,11 @@ Bunun avantajı nedir? Cevap, fonksiyonları değer olarak verebilmemizi sağlam
         	}
     	}
     	return sonuc
-=======
-	// pass the function `f` as an argument to another function
-
-	func filter(slice []int, f testInt) []int {
-    	var result []int
-    	for _, value := range slice {
-        	if f(value) {
-            	result = append(result, value)
-        	}
-    	}
-    	return result
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 	}
 
 	func main(){
     	slice := []int {1, 2, 3, 4, 5, 7}
     	fmt.Println("slice = ", slice)
-<<<<<<< HEAD
     	tek := filtre(slice, tekMi)    // fonksiyonu değer olarak kullan
     	fmt.Println("Slice'daki tek sayılar: ", tek)
     	çift := filtre(slice, çiftMi) 
@@ -692,15 +418,6 @@ Bunun avantajı nedir? Cevap, fonksiyonları değer olarak verebilmemizi sağlam
 	}
 
 Interface kullanılan durumlarda çok yararlıdır. Gördüğünüz gibi `testInt` fonksiyon türünde bir değişkendir ve `filtre`'nin döndürdüğü argümanlar ve değerler `testInt` ile aynıdır. Böylelikle programlarımızda karmaşık mantık yürütebilir ve esneklik kazanabiliriz.
-=======
-    	odd := filter(slice, isOdd)    // use function as values
-    	fmt.Println("Odd elements of slice are: ", odd)
-    	even := filter(slice, isEven) 
-    	fmt.Println("Even elements of slice are: ", even)
-	}
-
-Interface kullanılan durumlarda çok yararlıdır. Gördüğünüz gibi `testInt` fonksiyon türünde bir değişkendir ve `filter` ın döndürdüğü argümanlar ve değerler `testInt` ile aynıdır. Böylelikle programlarımızda karmaşık mantık yürütebilir ve esneklik kazanabiliriz.
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 
 ### Panic ve Recover
 
@@ -712,39 +429,23 @@ Go da Java gibi `try-catch` yapısı yoktur. Go exception fırlatmak yerine `pan
 
 Aşağıdaki örnekte `panic` nasıl kullanılır gösterilmiştir.
 
-<<<<<<< HEAD
 	var kullanıcı = os.Getenv("KULLANICI")
 
 	func init() {
     	if kullanıcı == "" {
         	panic("$KULLANICI için bir değer bulunamadı")
-=======
-	var user = os.Getenv("USER")
-
-	func init() {
-    	if user == "" {
-        	panic("no value for $USER")
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
     	}
 	}
 
 Bu örnek de `panic` kontrolü yapılmasını gösterir.	
 
-<<<<<<< HEAD
 	func panicYapar(f func()) (b bool) {
-=======
-	func throwsPanic(f func()) (b bool) {
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
     	defer func() {
         	if x := recover(); x != nil {
             	b = true
         	}
     	}()
-<<<<<<< HEAD
     	f() // eğer f() panic yaparsa recover yapılır
-=======
-    	f() // if f causes panic, it will recover
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
     	return
 	}
 	
@@ -758,11 +459,7 @@ Programlar işleme `main` paketinden başlar. Eğer `main` başka paketler dahil
 
 ![](images/2.3.init.png?raw=true)
 
-<<<<<<< HEAD
 Şekil 2.6 Go da programların parafe edilmesinin akışı
-=======
-Figure 2.6 Go da programların parafe edilmesinin akışı
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 
 ### import
 
@@ -813,15 +510,8 @@ Paketler dahil edilirken kullanılan özel operatörler vardır ve bunlar geneld
 	
 	Bu operatör dahil edilen paketin sadece `init` fonksiyonun çağrılıp çalıştırılması için kullanılır. Paketteki diğer fonksiyonları kullanacağınıza emin değilseniz kullanabilirsiniz.
 	
-<<<<<<< HEAD
 ## Linkler
 
 - [Rehber](preface.md)
 - Önceki bölüm: [Go temelleri](02.2.md)
-=======
-## Links
-
-- [Directory](preface.md)
-- Önceki bölüm: [Go foundation](02.2.md)
->>>>>>> eead24cf064976b648de5826eab51880c803b0fa
 - Sonraki bölüm: [struct](02.4.md)