From c5c8004450567a4be4c814e3c18725688c1601b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 19:50:46 +0200
Subject: Primitive Datatypes and Operators

---
 tr-tr/python3-tr.html.markdown | 645 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 645 insertions(+)
 create mode 100644 tr-tr/python3-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
new file mode 100644
index 00000000..d815e4f9
--- /dev/null
+++ b/tr-tr/python3-tr.html.markdown
@@ -0,0 +1,645 @@
+---
+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
+
+# Single line comments start with a number symbol.
+
+""" Multiline strings can be written
+    using three "s, and are often used
+    as comments
+"""
+
+####################################################
+## 1. Primitive Datatypes and Operators
+####################################################
+
+# You have numbers
+3  # => 3
+
+# Math is what you would expect
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+
+# Except division which returns floats by default
+35 / 5  # => 7.0
+
+# Result of integer division truncated down both for positive and negative. 
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # works on floats too
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# When you use a float, results are floats
+3 * 2.0 # => 6.0
+
+# Modulo operation
+7 % 3 # => 1
+
+# Exponentiation (x to the yth power)
+2**4 # => 16
+
+# Enforce precedence with parentheses
+(1 + 3) * 2  # => 8
+
+# Boolean values are primitives
+True
+False
+
+# negate with not
+not True  # => False
+not False  # => True
+
+# Boolean Operators
+# Note "and" and "or" are case-sensitive
+True and False #=> False
+False or True #=> True
+
+# Note using Bool operators with ints
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True 
+2 == True #=> False 
+1 == True #=> True
+
+# Equality is ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Inequality is !=
+1 != 1  # => False
+2 != 1  # => True
+
+# More comparisons
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Comparisons can be chained!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# Strings are created with " or '
+"This is a string."
+'This is also a string.'
+
+# Strings can be added too! But try not to do this.
+"Hello " + "world!"  # => "Hello world!"
+
+# A string can be treated like a list of characters
+"This is a string"[0]  # => 'T'
+
+# .format can be used to format strings, like this:
+"{} can be {}".format("strings", "interpolated")
+
+# You can repeat the formatting arguments to save some typing.
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# You can use keywords if you don't want to count.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+
+# If your Python 3 code also needs to run on Python 2.5 and below, you can also
+# still use the old style of formatting:
+"%s can be %s the %s way" % ("strings", "interpolated", "old")
+
+
+# None is an object
+None  # => None
+
+# Don't use the equality "==" symbol to compare objects to None
+# Use "is" instead. This checks for equality of object identity.
+"etc" is None  # => False
+None is None  # => True
+
+# None, 0, and empty strings/lists/dicts all evaluate to False.
+# All other values are True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variables and Collections
+####################################################
+
+# Python has a print function
+print("I'm Python. Nice to meet you!")
+
+# No need to declare variables before assigning to them. 
+# Convention is to use lower_case_with_underscores
+some_var = 5
+some_var  # => 5
+
+# Accessing a previously unassigned variable is an exception.
+# See Control Flow to learn more about exception handling.
+some_unknown_var  # Raises a NameError
+
+# Lists store sequences
+li = []
+# You can start with a prefilled list
+other_li = [4, 5, 6]
+
+# Add stuff to the end of a list with append
+li.append(1)    # li is now [1]
+li.append(2)    # li is now [1, 2]
+li.append(4)    # li is now [1, 2, 4]
+li.append(3)    # li is now [1, 2, 4, 3]
+# Remove from the end with pop
+li.pop()        # => 3 and li is now [1, 2, 4]
+# Let's put it back
+li.append(3)    # li is now [1, 2, 4, 3] again.
+
+# Access a list like you would any array
+li[0]  # => 1
+# Look at the last element
+li[-1]  # => 3
+
+# Looking out of bounds is an IndexError
+li[4]  # Raises an IndexError
+
+# You can look at ranges with slice syntax.
+# (It's a closed/open range for you mathy types.)
+li[1:3]  # => [2, 4]
+# Omit the beginning
+li[2:]  # => [4, 3]
+# Omit the end
+li[:3]  # => [1, 2, 4]
+# Select every second entry
+li[::2]   # =>[1, 4]
+# Revert the list
+li[::-1]   # => [3, 4, 2, 1]
+# Use any combination of these to make advanced slices
+# li[start:end:step]
+
+# Remove arbitrary elements from a list with "del"
+del li[2]   # li is now [1, 2, 3]
+
+# You can add lists
+# Note: values for li and for other_li are not modified.
+li + other_li   # => [1, 2, 3, 4, 5, 6] 
+
+# Concatenate lists with "extend()"
+li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+
+# Check for existence in a list with "in"
+1 in li   # => True
+
+# Examine the length with "len()"
+len(li)   # => 6
+
+
+# Tuples are like lists but are immutable.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # Raises a TypeError
+
+# You can do all those list thingies on tuples too
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# You can unpack tuples (or lists) into variables
+a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
+# Tuples are created by default if you leave out the parentheses
+d, e, f = 4, 5, 6
+# Now look how easy it is to swap two values
+e, d = d, e     # d is now 5 and e is now 4
+
+
+# Dictionaries store mappings
+empty_dict = {}
+# Here is a prefilled dictionary
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Look up values with []
+filled_dict["one"]   # => 1
+
+# Get all keys as a list with "keys()". 
+# We need to wrap the call in list() because we are getting back an iterable. We'll talk about those later.
+# Note - Dictionary key ordering is not guaranteed.
+# Your results might not match this exactly.
+list(filled_dict.keys())   # => ["three", "two", "one"]
+
+
+# Get all values as a list with "values()". Once again we need to wrap it in list() to get it out of the iterable.
+# Note - Same as above regarding key ordering.
+list(filled_dict.values())   # => [3, 2, 1]
+
+
+# Check for existence of keys in a dictionary with "in"
+"one" in filled_dict   # => True
+1 in filled_dict   # => False
+
+# Looking up a non-existing key is a KeyError
+filled_dict["four"]   # KeyError
+
+# Use "get()" method to avoid the KeyError
+filled_dict.get("one")   # => 1
+filled_dict.get("four")   # => None
+# The get method supports a default argument when the value is missing
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)   # => 4
+
+# "setdefault()" inserts into a dictionary only if the given key isn't present
+filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+
+# Adding to a dictionary
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  #another way to add to dict
+
+# Remove keys from a dictionary with del
+del filled_dict["one"]  # Removes the key "one" from filled dict
+
+
+# Sets store ... well sets
+empty_set = set()
+# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
+some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+
+# Can set new variables to a set
+filled_set = some_set
+
+# Add one more item to the set 
+filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+
+# Do set intersection with &
+other_set = {3, 4, 5, 6}
+filled_set & other_set   # => {3, 4, 5}
+
+# Do set union with |
+filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+
+# Do set difference with -
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# Check for existence in a set with in
+2 in filled_set   # => True
+10 in filled_set   # => False
+
+
+####################################################
+## 3. Control Flow and Iterables
+####################################################
+
+# Let's just make a variable
+some_var = 5
+
+# Here is an if statement. Indentation is significant in python!
+# prints "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # This elif clause is optional.
+    print("some_var is smaller than 10.")
+else:                  # This is optional too.
+    print("some_var is indeed 10.")
+
+
+"""
+For loops iterate over lists
+prints:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # You can use format() to interpolate formatted strings
+    print("{} is a mammal".format(animal))
+
+"""
+"range(number)" returns a list of numbers
+from zero to the given number
+prints:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+While loops go until a condition is no longer met.
+prints:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Shorthand for x = x + 1
+
+# Handle exceptions with a try/except block
+try:
+    # Use "raise" to raise an error
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass    # Pass is just a no-op. Usually you would do recovery here.
+except (TypeError, NameError):
+    pass    # Multiple exceptions can be handled together, if required.
+else:   # Optional clause to the try/except block. Must follow all except blocks
+    print("All good!")   # Runs only if the code in try raises no exceptions
+
+# Python offers a fundamental abstraction called the Iterable.
+# An iterable is an object that can be treated as a sequence.
+# The object returned the range function, is an iterable.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). This is an object that implements our Iterable interface
+
+# We can loop over it.
+for i in our_iterable:
+    print(i)    # Prints one, two, three
+
+# However we cannot address elements by index.
+our_iterable[1]  # Raises a TypeError
+
+# An iterable is an object that knows how to create an iterator.
+our_iterator = iter(our_iterable)
+
+# Our iterator is an object that can remember the state as we traverse through it.
+# We get the next object by calling the __next__ function.
+our_iterator.__next__()  #=> "one"
+
+# It maintains state as we call __next__.
+our_iterator.__next__()  #=> "two"
+our_iterator.__next__()  #=> "three"
+
+# After the iterator has returned all of its data, it gives you a StopIterator Exception
+our_iterator.__next__() # Raises StopIteration
+
+# You can grab all the elements of an iterator by calling list() on it.
+list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. Functions
+####################################################
+
+# Use "def" to create new functions
+def add(x, y):
+    print("x is {} and y is {}".format(x, y))
+    return x + y    # Return values with a return statement
+
+# Calling functions with parameters
+add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+
+# Another way to call functions is with keyword arguments
+add(y=6, x=5)   # Keyword arguments can arrive in any order.
+
+# You can define functions that take a variable number of
+# positional arguments
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)   # => (1, 2, 3)
+
+# You can define functions that take a variable number of
+# keyword arguments, as well
+def keyword_args(**kwargs):
+    return kwargs
+
+# Let's call it to see what happens
+keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+
+
+# You can do both at once, if you like
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# When calling functions, you can do the opposite of args/kwargs!
+# Use * to expand tuples and use ** to expand kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
+all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
+all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Function Scope                                                                
+x = 5
+
+def setX(num):
+    # Local var x not the same as global variable x
+    x = num # => 43
+    print (x) # => 43
+    
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # global var x is now set to 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python has first class functions
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# There are also anonymous functions
+(lambda x: x > 2)(3)   # => True
+
+# TODO - Fix for iterables
+# There are built-in higher order functions
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# We can use list comprehensions for nice maps and filters
+# List comprehension stores the output as a list which can itself be a nested list
+[add_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. Classes
+####################################################
+
+
+# We subclass from object to get a class.
+class Human(object):
+
+    # A class attribute. It is shared by all instances of this class
+    species = "H. sapiens"
+
+    # Basic initializer, this is called when this class is instantiated.
+    # Note that the double leading and trailing underscores denote objects
+    # or attributes that are used by python but that live in user-controlled
+    # namespaces. Methods(or objects or attributes) like: __init__, __str__, 
+    # __repr__ etc. are called magic methods (or sometimes called dunder methods)  
+    # You should not invent such names on your own.
+    def __init__(self, name):
+        # Assign the argument to the instance's name attribute
+        self.name = name
+
+    # An instance method. All methods take "self" as the first argument
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # A class method is shared among all instances
+    # They are called with the calling class as the first argument
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # A static method is called without a class or instance reference
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instantiate a class
+i = Human(name="Ian")
+print(i.say("hi"))     # prints out "Ian: hi"
+
+j = Human("Joel")
+print(j.say("hello"))  # prints out "Joel: hello"
+
+# Call our class method
+i.get_species()   # => "H. sapiens"
+
+# Change the shared attribute
+Human.species = "H. neanderthalensis"
+i.get_species()   # => "H. neanderthalensis"
+j.get_species()   # => "H. neanderthalensis"
+
+# Call the static method
+Human.grunt()   # => "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# You can import modules
+import math
+print(math.sqrt(16))  # => 4
+
+# You can get specific functions from a module
+from math import ceil, floor
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
+
+# You can import all functions from a module.
+# Warning: this is not recommended
+from math import *
+
+# You can shorten module names
+import math as m
+math.sqrt(16) == m.sqrt(16)   # => True
+
+# Python modules are just ordinary python files. You
+# can write your own, and import them. The name of the
+# module is the same as the name of the file.
+
+# You can find out which functions and attributes
+# defines a module.
+import math
+dir(math)
+
+
+####################################################
+## 7. Advanced
+####################################################
+
+# Generators help you make lazy code
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# A generator creates values on the fly.
+# Instead of generating and returning all values at once it creates one in each
+# iteration.  This means values bigger than 15 wont be processed in
+# double_numbers.
+# Note range is a generator too. Creating a list 1-900000000 would take lot of
+# time to be made
+# We use a trailing underscore in variable names when we want to use a name that 
+# would normally collide with a python keyword
+range_ = range(1, 900000000)
+# will double all numbers until a result >=30 found
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decorators
+# in this example beg wraps say
+# Beg will call say. If say_please is True then it will change the returned
+# message
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())  # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+```
+
+## Ready For More?
+
+### Free Online
+
+* [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)
+
+### Dead Tree
+
+* [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)
+
-- 
cgit v1.2.3


From 46273c1ffe60c581968c9b43d1fb603a881823e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 20:34:27 +0200
Subject: Variables and Collections

---
 tr-tr/python3-tr.html.markdown | 297 ++++++++++++++++++++---------------------
 1 file changed, 148 insertions(+), 149 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index d815e4f9..4939f219 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -17,119 +17,119 @@ Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [bur
 
 ```python
 
-# Single line comments start with a number symbol.
+# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
 
-""" Multiline strings can be written
-    using three "s, and are often used
-    as comments
+""" Çok satırlı olmasını istediğiniz yorumlar
+    üç adet tırnak(") işareti ile
+    yapılmaktadır
 """
 
 ####################################################
-## 1. Primitive Datatypes and Operators
+## 1. Temel Veri Türleri ve Operatörler
 ####################################################
 
-# You have numbers
+# Sayılar
 3  # => 3
 
-# Math is what you would expect
+# Tahmin edebileceÄŸiniz gibi matematik
 1 + 1  # => 2
 8 - 1  # => 7
 10 * 2  # => 20
 
-# Except division which returns floats by default
+# Bölme işlemi varsayılan olarak onluk döndürür
 35 / 5  # => 7.0
 
-# Result of integer division truncated down both for positive and negative. 
+# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
 5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # works on floats too
+5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
-# When you use a float, results are floats
+# Onluk kullanırsanız, sonuç da onluk olur
 3 * 2.0 # => 6.0
 
-# Modulo operation
+# Kalan operatörü
 7 % 3 # => 1
 
-# Exponentiation (x to the yth power)
+# Üs (2 üzeri 4)
 2**4 # => 16
 
-# Enforce precedence with parentheses
+# Parantez ile önceliği değiştirebilirsiniz
 (1 + 3) * 2  # => 8
 
-# Boolean values are primitives
+# Boolean(Doğru-Yanlış) değerleri standart
 True
 False
 
-# negate with not
+# 'değil' ile terse çevirme
 not True  # => False
 not False  # => True
 
-# Boolean Operators
-# Note "and" and "or" are case-sensitive
+# Boolean Operatörleri
+# "and" ve "or" büyük küçük harf duyarlıdır
 True and False #=> False
 False or True #=> True
 
-# Note using Bool operators with ints
+# Bool operatörleri ile sayı kullanımı
 0 and 2 #=> 0
 -5 or 0 #=> -5
 0 == False #=> True 
 2 == True #=> False 
 1 == True #=> True
 
-# Equality is ==
+# Eşitlik kontrolü ==
 1 == 1  # => True
 2 == 1  # => False
 
-# Inequality is !=
+# Eşitsizlik Kontrolü !=
 1 != 1  # => False
 2 != 1  # => True
 
-# More comparisons
+# Diğer karşılaştırmalar
 1 < 10  # => True
 1 > 10  # => False
 2 <= 2  # => True
 2 >= 2  # => True
 
-# Comparisons can be chained!
+# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
-# Strings are created with " or '
-"This is a string."
-'This is also a string.'
+# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
+"Bu bir yazı."
+'Bu da bir yazı.'
 
-# Strings can be added too! But try not to do this.
-"Hello " + "world!"  # => "Hello world!"
+# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
+"Merhaba " + "dünya!"  # => "Merhaba dünya!"
 
-# A string can be treated like a list of characters
-"This is a string"[0]  # => 'T'
+# Bir yazı(string) karakter listesi gibi işlenebilir
+"Bu bir yazı"[0]  # => 'B'
 
-# .format can be used to format strings, like this:
-"{} can be {}".format("strings", "interpolated")
+# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
+"{} da ayrıca {}".format("yazılar", "işlenebilir")
 
-# You can repeat the formatting arguments to save some typing.
-"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
-#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+# 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"
 
-# You can use keywords if you don't want to count.
-"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+# 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"
 
-# If your Python 3 code also needs to run on Python 2.5 and below, you can also
-# still use the old style of formatting:
-"%s can be %s the %s way" % ("strings", "interpolated", "old")
+# 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")
 
 
-# None is an object
+# Hiçbir şey(none) da bir objedir
 None  # => None
 
-# Don't use the equality "==" symbol to compare objects to None
-# Use "is" instead. This checks for equality of object identity.
-"etc" is None  # => False
+# 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, and empty strings/lists/dicts all evaluate to False.
-# All other values are 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
@@ -137,164 +137,163 @@ bool({}) #=> False
 
 
 ####################################################
-## 2. Variables and Collections
+## 2. DeÄŸiÅŸkenler ve Koleksiyonlar
 ####################################################
 
-# Python has a print function
-print("I'm Python. Nice to meet you!")
+# Python bir yazdırma fonksiyonuna sahip
+print("Ben Python. Tanıştığıma memnun oldum!")
 
-# No need to declare variables before assigning to them. 
-# Convention is to use lower_case_with_underscores
-some_var = 5
-some_var  # => 5
+# 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
 
-# Accessing a previously unassigned variable is an exception.
-# See Control Flow to learn more about exception handling.
-some_unknown_var  # Raises a NameError
+# Ö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
 
-# Lists store sequences
+# Listeler ile sıralamaları tutabilirsiniz
 li = []
-# You can start with a prefilled list
-other_li = [4, 5, 6]
-
-# Add stuff to the end of a list with append
-li.append(1)    # li is now [1]
-li.append(2)    # li is now [1, 2]
-li.append(4)    # li is now [1, 2, 4]
-li.append(3)    # li is now [1, 2, 4, 3]
-# Remove from the end with pop
-li.pop()        # => 3 and li is now [1, 2, 4]
-# Let's put it back
-li.append(3)    # li is now [1, 2, 4, 3] again.
-
-# Access a list like you would any array
+# Ö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
-# Look at the last element
+# Son elemente bakın
 li[-1]  # => 3
 
-# Looking out of bounds is an IndexError
-li[4]  # Raises an IndexError
+# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
+li[4]  # IndexError hatası oluşturur
 
-# You can look at ranges with slice syntax.
-# (It's a closed/open range for you mathy types.)
+# Bir kısmını almak isterseniz.
 li[1:3]  # => [2, 4]
-# Omit the beginning
+# Başlangıç belirtmezseniz
 li[2:]  # => [4, 3]
-# Omit the end
+# Sonu belirtmesseniz
 li[:3]  # => [1, 2, 4]
-# Select every second entry
+# Her ikişer objeyi seçme
 li[::2]   # =>[1, 4]
-# Revert the list
+# Listeyi tersten almak
 li[::-1]   # => [3, 4, 2, 1]
-# Use any combination of these to make advanced slices
-# li[start:end:step]
+# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
+# li[baslangic:son:adim]
 
-# Remove arbitrary elements from a list with "del"
-del li[2]   # li is now [1, 2, 3]
+# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
+del li[2]   # li artık [1, 2, 3] oldu
 
-# You can add lists
-# Note: values for li and for other_li are not modified.
-li + other_li   # => [1, 2, 3, 4, 5, 6] 
+# Listelerde de ekleme yapabilirsiniz
+# Not: değerler üzerinde değişiklik yapılmaz.
+li + diger_li   # => [1, 2, 3, 4, 5, 6] 
 
-# Concatenate lists with "extend()"
-li.extend(other_li)   # Now li is [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
 
-# Check for existence in a list with "in"
+# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
 1 in li   # => True
 
-# Examine the length with "len()"
+# Uzunluğu öğrenmek için "len()" kullanılabilir
 len(li)   # => 6
 
 
-# Tuples are like lists but are immutable.
+# Tüpler listeler gibidir fakat değiştirilemez.
 tup = (1, 2, 3)
 tup[0]   # => 1
-tup[0] = 3  # Raises a TypeError
+tup[0] = 3  # TypeError hatası oluşturur
 
-# You can do all those list thingies on tuples too
+# 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
 
-# You can unpack tuples (or lists) into variables
-a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
-# Tuples are created by default if you leave out the parentheses
+# 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
-# Now look how easy it is to swap two values
-e, d = d, e     # d is now 5 and e is now 4
+# 2 deÄŸeri birbirine deÄŸiÅŸtirmek bu kadar kolay
+e, d = d, e     # 'd' artık 5 ve 'e' artık 4
 
 
-# Dictionaries store mappings
-empty_dict = {}
-# Here is a prefilled dictionary
-filled_dict = {"one": 1, "two": 2, "three": 3}
+# Sözlükler anahtar kodlarla verileri tutar
+bos_sozl = {}
+# Önceden doldurulmuş sözlük oluşturma
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
 
-# Look up values with []
-filled_dict["one"]   # => 1
+# Değere bakmak için [] kullanalım
+dolu_sozl["bir"]   # => 1
 
-# Get all keys as a list with "keys()". 
-# We need to wrap the call in list() because we are getting back an iterable. We'll talk about those later.
-# Note - Dictionary key ordering is not guaranteed.
-# Your results might not match this exactly.
-list(filled_dict.keys())   # => ["three", "two", "one"]
+# 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"]
 
 
-# Get all values as a list with "values()". Once again we need to wrap it in list() to get it out of the iterable.
-# Note - Same as above regarding key ordering.
-list(filled_dict.values())   # => [3, 2, 1]
+# 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]
 
 
-# Check for existence of keys in a dictionary with "in"
-"one" in filled_dict   # => True
-1 in filled_dict   # => False
+# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
+"bir" in dolu_sozl   # => True
+1 in dolu_sozl   # => False
 
-# Looking up a non-existing key is a KeyError
-filled_dict["four"]   # KeyError
+# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
+dolu_sozl["dort"]   # KeyError hatası oluşturur
 
-# Use "get()" method to avoid the KeyError
-filled_dict.get("one")   # => 1
-filled_dict.get("four")   # => None
-# The get method supports a default argument when the value is missing
-filled_dict.get("one", 4)   # => 1
-filled_dict.get("four", 4)   # => 4
+# "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()" inserts into a dictionary only if the given key isn't present
-filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
-filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+# "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
 
-# Adding to a dictionary
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4  #another way to add to dict
+# 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
 
-# Remove keys from a dictionary with del
-del filled_dict["one"]  # Removes the key "one" from filled dict
+# Sözlükten anahtar silmek için 'del' kullanılabilir
+del dolu_sozl["bir"]  # "bir" anahtarını dolu sözlükten silecektir
 
 
-# Sets store ... well sets
-empty_set = set()
-# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
-some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+# 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}
 
-# Can set new variables to a set
-filled_set = some_set
+# Sete yeni setler ekleyebilirsiniz
+dolu_set = bir_set
 
-# Add one more item to the set 
-filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+# Sete bir diğer öğe ekleme 
+dolu_set.add(5)   # dolu_set artık {1, 2, 3, 4, 5} oldu
 
-# Do set intersection with &
-other_set = {3, 4, 5, 6}
-filled_set & other_set   # => {3, 4, 5}
+# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
+diger_set = {3, 4, 5, 6}
+dolu_set & diger_set   # => {3, 4, 5}
 
-# Do set union with |
-filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
+dolu_set | diger_set   # => {1, 2, 3, 4, 5, 6}
 
-# Do set difference with -
+# Farklılıkları almak için "-" kullanabilirsiniz
 {1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
 
-# Check for existence in a set with in
-2 in filled_set   # => True
-10 in filled_set   # => False
+# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
+2 in dolu_set   # => True
+10 in dolu_set   # => False
 
 
 ####################################################
-- 
cgit v1.2.3


From 1ab0a6eb5e73079393844719da067c37e84b8fef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 21:05:25 +0200
Subject: Control Flow and Iterables

---
 tr-tr/python3-tr.html.markdown | 109 ++++++++++++++++++++---------------------
 1 file changed, 54 insertions(+), 55 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index 4939f219..b1806e7b 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -297,37 +297,37 @@ dolu_set | diger_set   # => {1, 2, 3, 4, 5, 6}
 
 
 ####################################################
-## 3. Control Flow and Iterables
+## 3. Kontrol Akışları ve Temel Soyutlandırma
 ####################################################
 
-# Let's just make a variable
-some_var = 5
+# Bir değişken oluşturalım
+bir_degisken = 5
 
-# Here is an if statement. Indentation is significant in python!
-# prints "some_var is smaller than 10"
-if some_var > 10:
-    print("some_var is totally bigger than 10.")
-elif some_var < 10:    # This elif clause is optional.
-    print("some_var is smaller than 10.")
-else:                  # This is optional too.
-    print("some_var is indeed 10.")
+# 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")
 
 
 """
-For loops iterate over lists
-prints:
-    dog is a mammal
-    cat is a mammal
-    mouse is a mammal
+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 animal in ["dog", "cat", "mouse"]:
-    # You can use format() to interpolate formatted strings
-    print("{} is a mammal".format(animal))
+for hayvan in ["köpek", "kedi, "fare"]:
+    # format ile kolayca yazıyı biçimlendirelim
+    print("{} bir memeli hayvandır".format(hayvan))
 
 """
-"range(number)" returns a list of numbers
-from zero to the given number
-prints:
+"range(sayi)" bir sayı listesi döndür
+0'dan belirttiğiniz sayıyıa kadar
+çıktı:
     0
     1
     2
@@ -337,8 +337,8 @@ for i in range(4):
     print(i)
 
 """
-While loops go until a condition is no longer met.
-prints:
+'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
+çıktı:
     0
     1
     2
@@ -347,50 +347,49 @@ prints:
 x = 0
 while x < 4:
     print(x)
-    x += 1  # Shorthand for x = x + 1
+    x += 1  # Uzun hali x = x + 1
 
-# Handle exceptions with a try/except block
+# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
 try:
-    # Use "raise" to raise an error
-    raise IndexError("This is an index error")
+    # Bir hata oluşturmak için "raise" kullanabilirsiniz
+    raise IndexError("Bu bir index hatası")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    pass    # Önemsiz, devam et.
 except (TypeError, NameError):
-    pass    # Multiple exceptions can be handled together, if required.
-else:   # Optional clause to the try/except block. Must follow all except blocks
-    print("All good!")   # Runs only if the code in try raises no exceptions
+    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ı
 
-# Python offers a fundamental abstraction called the Iterable.
-# An iterable is an object that can be treated as a sequence.
-# The object returned the range function, is an iterable.
+# Temel Soyutlandırma, bir objenin işlenmiş halidir.
+# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
 
-filled_dict = {"one": 1, "two": 2, "three": 3}
-our_iterable = filled_dict.keys()
-print(our_iterable) #=> range(1,10). This is an object that implements our Iterable interface
+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
 
-# We can loop over it.
-for i in our_iterable:
-    print(i)    # Prints one, two, three
+# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
+for i in temel_soyut:
+    print(i)    # Çıktısı: bir, iki, uc
 
-# However we cannot address elements by index.
-our_iterable[1]  # Raises a TypeError
+# Fakat, elementin anahtarına değerine.
+temel_soyut[1]  # TypeError hatası!
 
-# An iterable is an object that knows how to create an iterator.
-our_iterator = iter(our_iterable)
+# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
+iterator = iter(temel_soyut)
 
-# Our iterator is an object that can remember the state as we traverse through it.
-# We get the next object by calling the __next__ function.
-our_iterator.__next__()  #=> "one"
+# '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"
 
-# It maintains state as we call __next__.
-our_iterator.__next__()  #=> "two"
-our_iterator.__next__()  #=> "three"
+# 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"
 
-# After the iterator has returned all of its data, it gives you a StopIterator Exception
-our_iterator.__next__() # Raises StopIteration
+# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
+iterator.__next__() # StopIteration hatası
 
-# You can grab all the elements of an iterator by calling list() on it.
-list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
+list(dolu_sozl.keys())  #=> Returns ["bir", "iki", "uc"]
 
 
 ####################################################
-- 
cgit v1.2.3


From 71d688379641a91f6247920962a005d9af635a70 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 21:26:00 +0200
Subject: Functions

---
 tr-tr/python3-tr.html.markdown | 100 ++++++++++++++++++++---------------------
 1 file changed, 48 insertions(+), 52 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index b1806e7b..6babb7d0 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -393,93 +393,89 @@ list(dolu_sozl.keys())  #=> Returns ["bir", "iki", "uc"]
 
 
 ####################################################
-## 4. Functions
+## 4. Fonksiyonlar
 ####################################################
 
-# Use "def" to create new functions
-def add(x, y):
-    print("x is {} and y is {}".format(x, y))
-    return x + y    # Return values with a return statement
+# "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
 
-# Calling functions with parameters
-add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+# Fonksiyonu parametleri ile çağırıyoruz
+topla(5, 6)   # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
 
-# Another way to call functions is with keyword arguments
-add(y=6, x=5)   # Keyword arguments can arrive in any order.
+# 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.
 
-# You can define functions that take a variable number of
-# positional arguments
-def varargs(*args):
-    return args
+# Sınırsız sayıda argüman da alabilirsiniz
+def argumanlar(*argumanlar):
+    return argumanlar
 
-varargs(1, 2, 3)   # => (1, 2, 3)
+argumanlar(1, 2, 3)   # => (1, 2, 3)
 
-# You can define functions that take a variable number of
-# keyword arguments, as well
-def keyword_args(**kwargs):
-    return kwargs
+# Parametrelerin anahtar deÄŸerlerini almak isterseniz
+def anahtar_par(**anahtarlar):
+    return anahtar
 
-# Let's call it to see what happens
-keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+# Çalıştırdığımızda
+anahtar_par(anah1="deg1", anah2="deg2")   # => {"anah1": "deg1", "anah2": "deg2"}
 
 
-# You can do both at once, if you like
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
+# Ä°sterseniz, bu ikisini birden kullanabilirsiniz
+def tum_argumanlar(*argumanlar, **anahtarla):
+    print(argumanlar)
+    print(anahtarla)
 """
-all_the_args(1, 2, a=3, b=4) prints:
+tum_argumanlar(1, 2, a=3, b=4) çıktı:
     (1, 2)
     {"a": 3, "b": 4}
 """
 
-# When calling functions, you can do the opposite of args/kwargs!
-# Use * to expand tuples and use ** to expand kwargs.
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
-all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
-all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, 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)
 
 
-# Function Scope                                                                
+# Fonksiyonlarda kullanacağımız bir değişken oluşturalım                                  
 x = 5
 
-def setX(num):
-    # Local var x not the same as global variable x
-    x = num # => 43
+def belirleX(sayi):
+    # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
+    x = sayi # => 43
     print (x) # => 43
     
-def setGlobalX(num):
+def globalBelirleX(sayi):
     global x
     print (x) # => 5
-    x = num # global var x is now set to 6
+    x = sayi # global olan x değişkeni artık 6
     print (x) # => 6
 
-setX(43)
-setGlobalX(6)
+belirleX(43)
+globalBelirleX(6)
 
 
-# Python has first class functions
-def create_adder(x):
-    def adder(y):
+# Sınıf fonksiyonları oluşturma
+def toplama_olustur(x):
+    def topla(y):
         return x + y
-    return adder
+    return topla
 
-add_10 = create_adder(10)
-add_10(3)   # => 13
+ekle_10 = toplama_olustur(10)
+ekle_10(3)   # => 13
 
-# There are also anonymous functions
+# Bilinmeyen fonksiyon
 (lambda x: x > 2)(3)   # => True
 
 # TODO - Fix for iterables
-# There are built-in higher order functions
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
+# 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]
 
-# We can use list comprehensions for nice maps and filters
-# List comprehension stores the output as a list which can itself be a nested list
-[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+# 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]
 
 ####################################################
-- 
cgit v1.2.3


From e34c67290a311c32a208793f44e5d0d51bf37bc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 21:36:52 +0200
Subject: Classes

---
 tr-tr/python3-tr.html.markdown | 68 ++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 35 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index 6babb7d0..ee858fb6 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -479,59 +479,57 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 [x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
 
 ####################################################
-## 5. Classes
+## 5. Sınıflar
 ####################################################
 
 
-# We subclass from object to get a class.
-class Human(object):
+# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
+class Insan(obje):
 
-    # A class attribute. It is shared by all instances of this class
-    species = "H. sapiens"
+    # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
+    tur = "H. sapiens"
 
-    # Basic initializer, this is called when this class is instantiated.
-    # Note that the double leading and trailing underscores denote objects
-    # or attributes that are used by python but that live in user-controlled
-    # namespaces. Methods(or objects or attributes) like: __init__, __str__, 
-    # __repr__ etc. are called magic methods (or sometimes called dunder methods)  
-    # You should not invent such names on your own.
-    def __init__(self, name):
-        # Assign the argument to the instance's name attribute
-        self.name = name
+    # 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
 
-    # An instance method. All methods take "self" as the first argument
-    def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
+    # 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)
 
-    # A class method is shared among all instances
-    # They are called with the calling class as the first argument
+    # Bir sınıf metotu bütün nesnelere paylaştırılır
+    # İlk parametre olarak sınıf alırlar
     @classmethod
-    def get_species(cls):
-        return cls.species
+    def getir_tur(snf):
+        return snf.tur
 
-    # A static method is called without a class or instance reference
+    # Bir statik metot, sınıf ve nesnesiz çağrılır
     @staticmethod
     def grunt():
         return "*grunt*"
 
 
-# Instantiate a class
-i = Human(name="Ian")
-print(i.say("hi"))     # prints out "Ian: hi"
+# Sınıfı çağıralım
+i = Insan(isim="Ahmet")
+print(i.soyle("merhaba"))     # çıktı "Ahmet: merhaba"
 
-j = Human("Joel")
-print(j.say("hello"))  # prints out "Joel: hello"
+j = Insan("Ali")
+print(j.soyle("selam"))  # çıktı "Ali: selam"
 
-# Call our class method
-i.get_species()   # => "H. sapiens"
+# Sınıf metodumuzu çağıraim
+i.getir_tur()   # => "H. sapiens"
 
-# Change the shared attribute
-Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
+# Paylaşılan değeri değiştirelim
+Insan.tur = "H. neanderthalensis"
+i.getir_tur()   # => "H. neanderthalensis"
+j.getir_tur()   # => "H. neanderthalensis"
 
-# Call the static method
-Human.grunt()   # => "*grunt*"
+# Statik metodumuzu çağıralım
+Insan.grunt()   # => "*grunt*"
 
 
 ####################################################
-- 
cgit v1.2.3


From 4d74369df3a33f22442ce5938768500d55e9fa94 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Thu, 26 Mar 2015 15:23:45 +0200
Subject: Modules

---
 tr-tr/python3-tr.html.markdown | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index ee858fb6..83ce892d 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -533,32 +533,32 @@ Insan.grunt()   # => "*grunt*"
 
 
 ####################################################
-## 6. Modules
+## 6. Moduller
 ####################################################
 
-# You can import modules
+# Modülleri içe aktarabilirsiniz
 import math
 print(math.sqrt(16))  # => 4
 
-# You can get specific functions from a module
+# Modülden belirli bir fonksiyonları alabilirsiniz
 from math import ceil, floor
 print(ceil(3.7))  # => 4.0
 print(floor(3.7))   # => 3.0
 
-# You can import all functions from a module.
-# Warning: this is not recommended
+# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
+# Dikkat: bunu yapmanızı önermem.
 from math import *
 
-# You can shorten module names
+# 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 modules are just ordinary python files. You
-# can write your own, and import them. The name of the
-# module is the same as the name of the file.
+# 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.
 
-# You can find out which functions and attributes
-# defines a module.
+# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
 import math
 dir(math)
 
-- 
cgit v1.2.3


From fde928afa6ef076087acf6c2dbfde0b53ba46e99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Thu, 26 Mar 2015 15:36:05 +0200
Subject: Advanced

---
 tr-tr/python3-tr.html.markdown | 62 ++++++++++++++++++++----------------------
 1 file changed, 30 insertions(+), 32 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index 83ce892d..fcd57229 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -564,56 +564,54 @@ dir(math)
 
 
 ####################################################
-## 7. Advanced
+## 7. GeliÅŸmiÅŸ
 ####################################################
 
-# Generators help you make lazy code
-def double_numbers(iterable):
-    for i in iterable:
+# 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
 
-# A generator creates values on the fly.
-# Instead of generating and returning all values at once it creates one in each
-# iteration.  This means values bigger than 15 wont be processed in
-# double_numbers.
-# Note range is a generator too. Creating a list 1-900000000 would take lot of
-# time to be made
-# We use a trailing underscore in variable names when we want to use a name that 
-# would normally collide with a python keyword
+# 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)
-# will double all numbers until a result >=30 found
-for i in double_numbers(range_):
+# 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
 
 
-# Decorators
-# in this example beg wraps say
-# Beg will call say. If say_please is True then it will change the returned
-# message
+# Dekoratörler
+# Bu örnekte,
+# Eğer lutfen_soyle True ise dönen değer değişecektir.
 from functools import wraps
 
 
-def beg(target_function):
-    @wraps(target_function)
-    def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Please! I am poor :(")
-        return msg
+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 wrapper
+    return metot
 
 
-@beg
-def say(say_please=False):
-    msg = "Can you buy me a beer?"
-    return msg, say_please
+@yalvar
+def soyle(lutfen_soyle=False):
+    msj = "Bana soda alır mısın?"
+    return msj, lutfen_soyle
 
 
-print(say())  # Can you buy me a beer?
-print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+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 :(
 ```
 
 ## Ready For More?
-- 
cgit v1.2.3


From c26eb3384b7c1201d903acfdee67b1709696c249 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Thu, 26 Mar 2015 15:36:45 +0200
Subject: Ready To More?

---
 tr-tr/python3-tr.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index fcd57229..2477c5da 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -614,9 +614,9 @@ 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 :(
 ```
 
-## Ready For More?
+## Daha Fazlasına Hazır Mısınız?
 
-### Free Online
+### Ãœcretsiz Online
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
@@ -627,7 +627,7 @@ print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayana
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 * [Python Course](http://www.python-course.eu/index.php)
 
-### Dead Tree
+### 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)
-- 
cgit v1.2.3


From 212ba8301419923cffb82fa4d4ef7c91832b6096 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Mon, 30 Mar 2015 21:26:26 +0000
Subject: Markdown tr-tr language

---
 tr-tr/markdown-tr.html.markdown | 251 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 251 insertions(+)
 create mode 100644 tr-tr/markdown-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
new file mode 100644
index 00000000..bac8f6fc
--- /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.
-- 
cgit v1.2.3


From 919f255a58d7af0a65d0fbf9b5232317ec20db28 Mon Sep 17 00:00:00 2001
From: Thiago van Dieten <nktakumi@gmail.com>
Date: Sun, 2 Aug 2015 12:58:23 +0300
Subject: Fix 'filename' collision between csharp{,-tr}.html.markdown

Both were set to LearnCSharp.cs, so the live site has been serving the Turkish version for English.
---
 tr-tr/csharp-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 7755ed44..a68026a5 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
 
 ---
 
-- 
cgit v1.2.3


From 036577916e76fe4df512da1b6c9253e1f51a5175 Mon Sep 17 00:00:00 2001
From: ozgur sahin <ozgursahin555@gmail.com>
Date: Sat, 22 Aug 2015 18:31:39 +0300
Subject: [Swift/tr] Turkish For Swift

---
 tr-tr/swift-tr.html.markdown | 590 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 590 insertions(+)
 create mode 100644 tr-tr/swift-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..41835e13
--- /dev/null
+++ b/tr-tr/swift-tr.html.markdown
@@ -0,0 +1,590 @@
+---
+language: swift
+contributors:
+  - ["Özgür Şahin", "https://github.com/ozgurshn/"]
+filename: learnswift.swift
+---
+
+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.
+
+The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.  
+
+Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
+
+See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.  
+
+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...) {
+    // its an array
+    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
+```
-- 
cgit v1.2.3


From f72588075d0cd200d53893ad51129844df17aea7 Mon Sep 17 00:00:00 2001
From: ozgur sahin <ozgursahin555@gmail.com>
Date: Sun, 4 Oct 2015 22:01:10 +0300
Subject: swift-tr.html.markdown

Translated some English sentences.
---
 tr-tr/swift-tr.html.markdown | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 41835e13..c13f5ecf 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -3,16 +3,14 @@ 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.
-
-The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.  
+ 
 
 Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
 
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.  
-
 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.
 
 
@@ -243,7 +241,7 @@ print("Benzin fiyatı: \(fiyat)")
 
 // Çeşitli Argümanlar
 func ayarla(sayilar: Int...) {
-    // its an array
+    // bu bir dizidir
     let sayi = sayilar[0]
     let argumanSAyisi = sayilar.count
 }
-- 
cgit v1.2.3


From b1984042c845a73333972715e88a3d7a2e8cfdd7 Mon Sep 17 00:00:00 2001
From: Guntbert Reiter <guntbert@gmx.at>
Date: Sun, 4 Oct 2015 16:44:24 +0200
Subject: Put demonstrative condition into ternary expression

It should be made clear that the part before the ternary operator is
indeed a condition, most often created as some comparison expression.
---
 tr-tr/csharp-tr.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'tr-tr')

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;
-- 
cgit v1.2.3


From 1e90e7da1d042dfc46a5be11117a4e45e460bcf8 Mon Sep 17 00:00:00 2001
From: Andy B <andyjtbrown@gmail.com>
Date: Fri, 9 Oct 2015 15:32:05 +0100
Subject: [objective-c/en-fr-ru-tr-vn] Enable syntax highlighting

---
 tr-tr/objective-c-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

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
 
 /*
-- 
cgit v1.2.3


From ee835c28a942c85c5c32d24dde35239a8d07e7e2 Mon Sep 17 00:00:00 2001
From: Aybuke Ozdemir <aybuke.147@gmail.com>
Date: Sat, 31 Oct 2015 00:49:23 +0200
Subject: the comments were translated into Turkish

---
 tr-tr/c-tr.html.markdown | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

(limited to 'tr-tr')

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
-- 
cgit v1.2.3


From b2b274df08f65a62f5f4c65701b043a69bd77964 Mon Sep 17 00:00:00 2001
From: bureken <berkgureken@gmail.com>
Date: Sat, 31 Oct 2015 04:00:03 +0300
Subject: Turkish typo fix

---
 tr-tr/brainfuck-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

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).
-- 
cgit v1.2.3


From 2cebd90205c7caedc001202b7a517971f8f1ec20 Mon Sep 17 00:00:00 2001
From: bureken <berkgureken@gmail.com>
Date: Sat, 31 Oct 2015 21:19:11 +0300
Subject: Comment lines fixed

---
 tr-tr/swift-tr.html.markdown | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index c13f5ecf..15056bb8 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -25,14 +25,14 @@ import UIKit
 
 
 //XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot
- listesinde gruplama yapmanıza olanak sağlıyor
+//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.  
+//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.
 
@@ -75,7 +75,7 @@ print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7
 */
 var baziOptionalString: String? = "optional" // nil olabilir.
 // yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay 
-okunabilir)
+//okunabilir)
 var someOptionalString2: Optional<String> = "optional"  
 
 
@@ -104,7 +104,8 @@ if let baziOpsiyonelSabitString = baziOptionalString {
 // 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)
+//ç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"
 
@@ -234,7 +235,7 @@ func fiyatlariGetir() -> (Double, Double, Double) {
 let fiyatTuple = fiyatlariGetir()
 let fiyat = fiyatTuple.2 // 3.79
 // _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden
-gelir
+//gelir
 let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69
 print(fiyat1 == fiyatTuple.1) // true
 print("Benzin fiyatı: \(fiyat)")
-- 
cgit v1.2.3


From 7933ea3ce029a3418bac04210e0dd7f0f27e275d Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 21 Nov 2015 19:08:39 +0100
Subject: Applies a1ed02d6fad2b39137f52c6a04264a59e237d747 to translations

---
 tr-tr/python3-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

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
-- 
cgit v1.2.3


From 5aa692f5f3bbfa7b79224748dcfd8ca5fba7a8bc Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 12 Feb 2016 11:42:25 -0800
Subject: brainfuck->bf

---
 tr-tr/bf-tr.html.markdown        | 87 ++++++++++++++++++++++++++++++++++++++++
 tr-tr/brainfuck-tr.html.markdown | 87 ----------------------------------------
 2 files changed, 87 insertions(+), 87 deletions(-)
 create mode 100644 tr-tr/bf-tr.html.markdown
 delete mode 100644 tr-tr/brainfuck-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/bf-tr.html.markdown b/tr-tr/bf-tr.html.markdown
new file mode 100644
index 00000000..e7015cd0
--- /dev/null
+++ b/tr-tr/bf-tr.html.markdown
@@ -0,0 +1,87 @@
+---
+language: bf
+filename: brainfuck-tr
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+
+Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.) 
+son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen 
+Turing'dir.
+
+```
+"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter
+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.
+
+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).
+< : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye).
+. : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A').
+, : Bir girdilik karakteri aktif hücre için okur.
+[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar.
+    Diğer durumlarda bir sonraki yönergeye geçer.
+] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer.
+    Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner.
+
+[ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar.
+
+Basit bir brainfuck programına göz atalım.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır.
+#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve
+#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye
+geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez
+azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar).
+
+Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri
+60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz.
+#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını
+yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır.
+
+
+, [ > + < - ] > .
+
+Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır,
+ve daha sonra aynı karakteri ekrana yazdırır.
+
+, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü
+başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1
+hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin
+değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü
+biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda
+#2 hücresinin ASCII değerini yazdırıyoruz.
+
+Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de
+yazabilirsiniz.
+
+,[>+<-]>.
+
+
+Bu uygulamanın ne yaptığına bakalım:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Bu program 2 sayı alır, ve birbiri ile çarpar.
+
+Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir
+döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü
+daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç
+döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4
+hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye
+kopyalıyoruz.
+```
+
+İşte brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı
+yazabilirsiniz, veya farklı bir dilde brainfuck yorumlayıcısı yazabilirsiniz.
+Yorumlayıcı oldukça basittir, ama mazoşist iseniz, brainfuck içerisinde bir
+brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
deleted file mode 100644
index bd842b17..00000000
--- a/tr-tr/brainfuck-tr.html.markdown
+++ /dev/null
@@ -1,87 +0,0 @@
----
-language: brainfuck
-filename: brainfuck-tr
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io"]
-translators:
-    - ["Haydar KULEKCI", "http://scanf.info/"]
-lang: tr-tr
----
-
-Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.) 
-son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen 
-Turing'dir.
-
-```
-"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter
-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.
-
-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).
-< : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye).
-. : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A').
-, : Bir girdilik karakteri aktif hücre için okur.
-[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar.
-    Diğer durumlarda bir sonraki yönergeye geçer.
-] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer.
-    Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner.
-
-[ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar.
-
-Basit bir brainfuck programına göz atalım.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır.
-#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve
-#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye
-geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez
-azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar).
-
-Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri
-60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz.
-#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını
-yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır.
-
-
-, [ > + < - ] > .
-
-Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır,
-ve daha sonra aynı karakteri ekrana yazdırır.
-
-, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü
-başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1
-hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin
-değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü
-biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda
-#2 hücresinin ASCII değerini yazdırıyoruz.
-
-Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de
-yazabilirsiniz.
-
-,[>+<-]>.
-
-
-Bu uygulamanın ne yaptığına bakalım:
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Bu program 2 sayı alır, ve birbiri ile çarpar.
-
-Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir
-döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü
-daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç
-döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4
-hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye
-kopyalıyoruz.
-```
-
-İşte brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı
-yazabilirsiniz, veya farklı bir dilde brainfuck yorumlayıcısı yazabilirsiniz.
-Yorumlayıcı oldukça basittir, ama mazoşist iseniz, brainfuck içerisinde bir
-brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
-- 
cgit v1.2.3


From 484300f1db4509b08ed48526c61fcfcb48a6152b Mon Sep 17 00:00:00 2001
From: Zach Latta <zach@zachlatta.com>
Date: Tue, 23 Feb 2016 16:12:44 -0800
Subject: Fix capitalization of GitHub

---
 tr-tr/markdown-tr.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
index bac8f6fc..b8f11e39 100644
--- a/tr-tr/markdown-tr.html.markdown
+++ b/tr-tr/markdown-tr.html.markdown
@@ -52,7 +52,7 @@ __Bu yazı da kalın.__
 **_Bu da öyle!_**
 *__Hatta bu bile!__*
 
-<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
+<!-- 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. -->
@@ -151,7 +151,7 @@ kullanabilirsiniz -->
 
 Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
 
-<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
+<!-- GitHub Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
 
 \`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
 def foobar
@@ -159,7 +159,7 @@ def foobar
 end
 \`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
 
-<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da 
+<!-- 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 -->
 
@@ -230,7 +230,7 @@ Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmama
 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ı
+<!-- 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       |
-- 
cgit v1.2.3


From ab4fa4ea02e29c8f680aa70a01da082c08cb11d8 Mon Sep 17 00:00:00 2001
From: Mustafa Zengin <mzengin88@gmail.com>
Date: Sun, 24 Apr 2016 22:57:21 -0700
Subject: fsharp translation to Turkish in progress

---
 tr-tr/fsharp-tr.html.markdown | 630 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 630 insertions(+)
 create mode 100644 tr-tr/fsharp-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
new file mode 100644
index 00000000..b844f552
--- /dev/null
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -0,0 +1,630 @@
+---
+language: F#
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
+translators:
+    - ["Mustafa Zengin", "http://zengin.github.com/"]
+filename: learnfsharp.fs
+---
+
+F# fonksiyonel ve nesne tabanlı, 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 kullanılır
+(* ç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 myInt = 5
+let myFloat = 3.14
+let myString = "hello"           // tip bilgisi olmamasına dikkat
+
+// ------ Listeler ------
+let twoToFive = [2; 3; 4; 5]        // Köşeli parantezler listeleri oluşturur,
+                                 // değerler ise noktalı virgülle ayrılır.
+let oneToFive = 1 :: twoToFive   // :: yeni birinci elemanı olan bir liste oluşturur.
+// Sonuç: [1; 2; 3; 4; 5]
+let zeroToFive = [0; 1] @ twoToFive   // @ 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 square x = x * x          // Parantez kullanılmadığına dikkat.
+square 3                      // Åžimdi fonksiyonu uygula. Yine parantez yok.
+
+let add x y = x + y           // add (x,y) kullanmayın! Bu tamamen başka bir anlama geliyor.
+add 2 3                       // Åžimdi fonksiyonu uygula.
+
+// çok satırlı bir fonksiyon tanımlamak için sadece girinti kullan. Noktalıı virgül gerekmez.
+let evens list =
+   let isEven x = x % 2 = 0     // "isEven"ı alt fonksiyon olarak tanımla
+   List.filter isEven list    // List.filter boolean bir fonksiyon ve
+                              // üzerinde çalışılacak bir liste parametrelerinden oluşan
+                              // bir kütüphane fonksiyonu
+                              
+evens oneToFive               // Åžimdi fonksiyonu uygula.
+
+// Parantezleri önceliği netleştirmek için kullanabilirsin. Bu örnekte
+// "map"i önce iki argümanla uygula, sonra sonuç üzerinde "sum" uygula.
+// Parantezler olmasaydı, "List.map" List.sum'ın ilk argümanı olurdu.
+let sumOfSquaresTo100 =
+   List.sum ( List.map square [1..100] )
+
+// Bir operasyonun sonucunu bir sonrakine "|>" kullanarak besleyebilirsin.
+// Veri beslemek F#'ta UNIX'te olduğu gibi yaygındır..
+
+// Burada sumOfSquares fonksiyonunun veri beslemeyle yazılmış hali var:
+let sumOfSquaresTo100piped =
+   [1..100] |> List.map square |> List.sum  // "square" önceden tanımlanmıştı
+
+// Lambda'ları (anonim fonksiyonları) "fun" anahtar kelimesiyle tanımlayabilirsin
+let sumOfSquaresTo100withFun =
+   [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 simplePatternMatch =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x is a"
+    | "b" -> printfn "x is b"
+    | _ -> printfn "x is something else"   // 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 validValue = Some(99)
+let invalidValue = 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 optionPatternMatch input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Printing ------
+// The printf/printfn functions are similar to the
+// Console.Write/WriteLine functions in C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
+
+// There are also sprintf/sprintfn functions for formatting data
+// into a string, similar to String.Format in C#.
+
+// ================================================
+// More on functions
+// ================================================
+
+// F# is a true functional language -- functions are first
+// class entities and can be combined easily to make powerful
+// constructs
+
+// Modules are used to group functions together
+// Indentation is needed for each nested module.
+module FunctionExamples =
+
+    // define a simple adding function
+    let add x y = x + y
+
+    // basic usage of a function
+    let a = add 1 2
+    printfn "1 + 2 = %i" a
+
+    // partial application to "bake in" parameters
+    let add42 = add 42
+    let b = add42 1
+    printfn "42 + 1 = %i" b
+
+    // composition to combine functions
+    let add1 = add 1
+    let add2 = add 2
+    let add3 = add1 >> add2
+    let c = add3 7
+    printfn "3 + 7 = %i" c
+
+    // higher order functions
+    [1..10] |> List.map add3 |> printfn "new list is %A"
+
+    // lists of functions, and more
+    let add6 = [add1; add2; add3] |> List.reduce (>>)
+    let d = add6 7
+    printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Lists and collection
+// ================================================
+
+// There are three types of ordered collection:
+// * Lists are most basic immutable collection.
+// * Arrays are mutable and more efficient when needed.
+// * Sequences are lazy and infinite (e.g. an enumerator).
+//
+// Other collections include immutable maps and sets
+// plus all the standard .NET collections
+
+module ListExamples =
+
+    // lists use square brackets
+    let list1 = ["a"; "b"]
+    let list2 = "c" :: list1    // :: is prepending
+    let list3 = list1 @ list2   // @ is concat
+
+    // list comprehensions (aka generators)
+    let squares = [for i in 1..10 do yield i * i]
+
+    // prime number generator
+    let rec sieve = function
+        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primes = sieve [2..50]
+    printfn "%A" primes
+
+    // pattern matching for lists
+    let listMatcher aList =
+        match aList with
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | _ -> printfn "the list has more than two elements"
+
+    listMatcher [1; 2; 3; 4]
+    listMatcher [1; 2]
+    listMatcher [1]
+    listMatcher []
+
+    // recursion using lists
+    let rec sum aList =
+        match aList with
+        | [] -> 0
+        | x::xs -> x + sum xs
+    sum [1..10]
+
+    // -----------------------------------------
+    // Standard library functions
+    // -----------------------------------------
+
+    // map
+    let add3 x = x + 3
+    [1..10] |> List.map add3
+
+    // filter
+    let even x = x % 2 = 0
+    [1..10] |> List.filter even
+
+    // many more -- see documentation
+
+module ArrayExamples =
+
+    // arrays use square brackets with bar
+    let array1 = [| "a"; "b" |]
+    let first = array1.[0]        // indexed access using dot
+
+    // pattern matching for arrays is same as for lists
+    let arrayMatcher aList =
+        match aList with
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
+
+    arrayMatcher [| 1; 2; 3; 4 |]
+
+    // Standard library functions just as for List
+
+    [| 1..10 |]
+    |> Array.map (fun i -> i + 3)
+    |> Array.filter (fun i -> i % 2 = 0)
+    |> Array.iter (printfn "value is %i. ")
+
+
+module SequenceExamples =
+
+    // sequences use curly braces
+    let seq1 = seq { yield "a"; yield "b" }
+
+    // sequences can use yield and
+    // can contain subsequences
+    let strange = seq {
+        // "yield" adds one element
+        yield 1; yield 2;
+
+        // "yield!" adds a whole subsequence
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i % 2 = 0 then yield i }}
+    // test
+    strange |> Seq.toList
+
+
+    // Sequences can be created using "unfold"
+    // Here's the fibonacci series
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // test
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "first 10 fibs are %A" fib10
+
+
+// ================================================
+// Data Types
+// ================================================
+
+module DataTypeExamples =
+
+    // All data is immutable by default
+
+    // Tuples are quick 'n easy anonymous types
+    // -- Use a comma to create a tuple
+    let twoTuple = 1, 2
+    let threeTuple = "a", 2, true
+
+    // Pattern match to unpack
+    let x, y = twoTuple  // sets x = 1, y = 2
+
+    // ------------------------------------
+    // Record types have named fields
+    // ------------------------------------
+
+    // Use "type" with curly braces to define a record type
+    type Person = {First:string; Last:string}
+
+    // Use "let" with curly braces to create a record
+    let person1 = {First="John"; Last="Doe"}
+
+    // Pattern match to unpack
+    let {First = first} = person1    // sets first="John"
+
+    // ------------------------------------
+    // Union types (aka variants) have a set of choices
+    // Only case can be valid at a time.
+    // ------------------------------------
+
+    // Use "type" with bar/pipe to define a union type
+    type Temp =
+        | DegreesC of float
+        | DegreesF of float
+
+    // Use one of the cases to create one
+    let temp1 = DegreesF 98.6
+    let temp2 = DegreesC 37.0
+
+    // Pattern match on all cases to unpack
+    let printTemp = function
+       | DegreesC t -> printfn "%f degC" t
+       | DegreesF t -> printfn "%f degF" t
+
+    printTemp temp1
+    printTemp temp2
+
+    // ------------------------------------
+    // Recursive types
+    // ------------------------------------
+
+    // Types can be combined recursively in complex ways
+    // without having to create subclasses
+    type Employee =
+      | Worker of Person
+      | Manager of Employee list
+
+    let jdoe = {First="John"; Last="Doe"}
+    let worker = Worker jdoe
+
+    // ------------------------------------
+    // Modeling with types
+    // ------------------------------------
+
+    // Union types are great for modeling state without using flags
+    type EmailAddress =
+        | ValidEmailAddress of string
+        | InvalidEmailAddress of string
+
+    let trySendEmail email =
+        match email with // use pattern matching
+        | ValidEmailAddress address -> ()   // send
+        | InvalidEmailAddress address -> () // don't send
+
+    // The combination of union types and record types together
+    // provide a great foundation for domain driven design.
+    // You can create hundreds of little types that accurately
+    // reflect the domain.
+
+    type CartItem = { ProductCode: string; Qty: int }
+    type Payment = Payment of float
+    type ActiveCartData = { UnpaidItems: CartItem list }
+    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+    type ShoppingCart =
+        | EmptyCart  // no data
+        | ActiveCart of ActiveCartData
+        | PaidCart of PaidCartData
+
+    // ------------------------------------
+    // Built in behavior for types
+    // ------------------------------------
+
+    // Core types have useful "out-of-the-box" behavior, no coding needed.
+    // * Immutability
+    // * Pretty printing when debugging
+    // * Equality and comparison
+    // * Serialization
+
+    // Pretty printing using %A
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+             twoTuple person1 temp1 worker
+
+    // Equality and comparison built in.
+    // Here's an example with cards.
+    type Suit = Club | Diamond | Spade | Heart
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
+
+    let hand = [ Club, Ace; Heart, Three; Heart, Ace;
+                 Spade, Jack; Diamond, Two; Diamond, Ace ]
+
+    // sorting
+    List.sort hand |> printfn "sorted hand is (low to high) %A"
+    List.max hand |> printfn "high card is %A"
+    List.min hand |> printfn "low card is %A"
+
+
+// ================================================
+// Active patterns
+// ================================================
+
+module ActivePatternExamples =
+
+    // F# has a special type of pattern matching called "active patterns"
+    // where the pattern can be parsed or detected dynamically.
+
+    // "banana clips" are the syntax for active patterns
+
+    // for example, define an "active" pattern to match character types...
+    let (|Digit|Letter|Whitespace|Other|) ch =
+       if System.Char.IsDigit(ch) then Digit
+       else if System.Char.IsLetter(ch) then Letter
+       else if System.Char.IsWhiteSpace(ch) then Whitespace
+       else Other
+
+    // ... and then use it to make parsing logic much clearer
+    let printChar ch =
+      match ch with
+      | Digit -> printfn "%c is a Digit" ch
+      | Letter -> printfn "%c is a Letter" ch
+      | Whitespace -> printfn "%c is a Whitespace" ch
+      | _ -> printfn "%c is something else" ch
+
+    // print a list
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
+
+    // -----------------------------------
+    // FizzBuzz using active patterns
+    // -----------------------------------
+
+    // You can create partial matching patterns as well
+    // Just use underscore in the definition, and return Some if matched.
+    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+    // the main function
+    let fizzBuzz i =
+      match i with
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // test
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Conciseness
+// ================================================
+
+module AlgorithmExamples =
+
+    // F# has a high signal/noise ratio, so code reads
+    // almost like the actual algorithm
+
+    // ------ Example: define sumOfSquares function ------
+    let sumOfSquares n =
+       [1..n]              // 1) take all the numbers from 1 to n
+       |> List.map square  // 2) square each one
+       |> List.sum         // 3) sum the results
+
+    // test
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Example: define a sort function ------
+    let rec sort list =
+       match list with
+       // If the list is empty
+       | [] ->
+            []                            // return an empty list
+       // If the list is not empty
+       | firstElem::otherElements ->      // take the first element
+            let smallerElements =         // extract the smaller elements
+                otherElements             // from the remaining ones
+                |> List.filter (fun e -> e < firstElem)
+                |> sort                   // and sort them
+            let largerElements =          // extract the larger ones
+                otherElements             // from the remaining ones
+                |> List.filter (fun e -> e >= firstElem)
+                |> sort                   // and sort them
+            // Combine the 3 parts into a new list and return it
+            List.concat [smallerElements; [firstElem]; largerElements]
+
+    // test
+    sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
+
+// ================================================
+// Asynchronous Code
+// ================================================
+
+module AsyncExample =
+
+    // F# has built-in features to help with async code
+    // without encountering the "pyramid of doom"
+    //
+    // The following example downloads a set of web pages in parallel.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Fetch the contents of a URL asynchronously
+    let fetchUrlAsync url =
+        async {   // "async" keyword and curly braces
+                  // creates an "async" object
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
+                // use! is async assignment
+            use stream = resp.GetResponseStream()
+                // "use" triggers automatic close()
+                // on resource at end of scope
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
+            }
+
+    // a list of sites to fetch
+    let sites = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // do it
+    sites
+    |> List.map fetchUrlAsync  // make a list of async tasks
+    |> Async.Parallel          // set up the tasks to run in parallel
+    |> Async.RunSynchronously  // start them off
+
+// ================================================
+// .NET compatibility
+// ================================================
+
+module NetCompatibilityExamples =
+
+    // F# can do almost everything C# can do, and it integrates
+    // seamlessly with .NET or Mono libraries.
+
+    // ------- work with existing library functions  -------
+
+    let (i1success, i1) = System.Int32.TryParse("123");
+    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+    // ------- Implement interfaces on the fly! -------
+
+    // create a new object that implements IDisposable
+    let makeResource name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s disposed" name }
+
+    let useAndDisposeResources =
+        use r1 = makeResource "first resource"
+        printfn "using first resource"
+        for i in [1..3] do
+            let resourceName = sprintf "\tinner resource %d" i
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
+        use r2 = makeResource "second resource"
+        printfn "using second resource"
+        printfn "done."
+
+    // ------- Object oriented code -------
+
+    // F# is also a fully fledged OO language.
+    // It supports classes, inheritance, virtual methods, etc.
+
+    // interface with generic type
+    type IEnumerator<'a> =
+        abstract member Current : 'a
+        abstract MoveNext : unit -> bool
+
+    // abstract base class with virtual methods
+    [<AbstractClass>]
+    type Shape() =
+        // readonly properties
+        abstract member Width : int with get
+        abstract member Height : int with get
+        // non-virtual method
+        member this.BoundingArea = this.Height * this.Width
+        // virtual method with base implementation
+        abstract member Print : unit -> unit
+        default this.Print () = printfn "I'm a shape"
+
+    // concrete class that inherits from base class and overrides
+    type Rectangle(x:int, y:int) =
+        inherit Shape()
+        override this.Width = x
+        override this.Height = y
+        override this.Print ()  = printfn "I'm a Rectangle"
+
+    // test
+    let r = Rectangle(2, 3)
+    printfn "The width is %i" r.Width
+    printfn "The area is %i" r.BoundingArea
+    r.Print()
+
+    // ------- extension methods  -------
+
+    // Just as in C#, F# can extend existing classes with extension methods.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // test
+    let s = "Alice"
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+    // ------- events  -------
+
+    type MyButton() =
+        let clickEvent = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = clickEvent.Publish
+
+        member this.TestEvent(arg) =
+            clickEvent.Trigger(this, arg)
+
+    // test
+    let myButton = new MyButton()
+    myButton.OnClick.Add(fun (sender, arg) ->
+            printfn "Click event with arg=%O" arg)
+
+    myButton.TestEvent("Hello World!")
+
+```
+
+## More Information
+
+For more demonstrations of F#, go to the [Try F#](http://www.tryfsharp.org/Learn) site, or my [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) series.
+
+Read more about F# at [fsharp.org](http://fsharp.org/).
-- 
cgit v1.2.3


From 9b400a620a189c21c41ea3aa36c81726c134af81 Mon Sep 17 00:00:00 2001
From: kahredici <kadir.can.cetin@gmail.com>
Date: Tue, 26 Apr 2016 00:59:57 +0300
Subject: small additions.

---
 tr-tr/python3-tr.html.markdown | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index c7de2922..e53d5568 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -618,14 +618,19 @@ print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayana
 
 ### Ãœ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
 
-- 
cgit v1.2.3


From 67a867ac0a96e6b5bdce8ab9cb700f3039741447 Mon Sep 17 00:00:00 2001
From: Mustafa Zengin <mzengin88@gmail.com>
Date: Mon, 25 Apr 2016 16:02:07 -0700
Subject: fsharp tutorial Turkish translation first pass complete

---
 tr-tr/fsharp-tr.html.markdown | 300 +++++++++++++++++++++---------------------
 1 file changed, 150 insertions(+), 150 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
index b844f552..828d7327 100644
--- a/tr-tr/fsharp-tr.html.markdown
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -7,7 +7,7 @@ translators:
 filename: learnfsharp.fs
 ---
 
-F# fonksiyonel ve nesne tabanlı, genel amaçlı bir programlama dilidir. Bedava ve açık kaynaklıdır ve Linux, Mac, Windows ve dahasında çalışır.
+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.
 
@@ -106,84 +106,84 @@ let optionPatternMatch input =
 optionPatternMatch validValue
 optionPatternMatch invalidValue
 
-// ------ Printing ------
-// The printf/printfn functions are similar to the
-// Console.Write/WriteLine functions in C#.
+// ------ Yazdırma ------
+// printf/printfn fonksiyonları C#'taki 
+// Console.Write/WriteLine fonksiyonlarına benzer.
 printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
 printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
 
-// There are also sprintf/sprintfn functions for formatting data
-// into a string, similar to String.Format in C#.
+// sprintf/sprintfn fonksiyonları ise veriyi string'e
+// çevirmek içindir, C#'taki String.Format gibi.
 
 // ================================================
-// More on functions
+// Fonksiyonlar hakkında dahası
 // ================================================
 
-// F# is a true functional language -- functions are first
-// class entities and can be combined easily to make powerful
-// constructs
+// 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.
 
-// Modules are used to group functions together
-// Indentation is needed for each nested module.
+// Modüller fonksiyonları gruplamak için kullanılır.
+// Her bir modül için girinti gerekir.
 module FunctionExamples =
 
-    // define a simple adding function
+    // Temel bir ekleme fonksiyonu tanımla
     let add x y = x + y
 
-    // basic usage of a function
+    // Bir fonksiyonun temel kullanımı
     let a = add 1 2
     printfn "1 + 2 = %i" a
 
-    // partial application to "bake in" parameters
+    // Parametreleri kaynaklamak için parçalı uygulama
     let add42 = add 42
     let b = add42 1
     printfn "42 + 1 = %i" b
 
-    // composition to combine functions
+    // Fonksiyonları birleştirmek için kompozisyon
     let add1 = add 1
     let add2 = add 2
     let add3 = add1 >> add2
     let c = add3 7
     printfn "3 + 7 = %i" c
 
-    // higher order functions
+    // Yüksek dereceli fonksiyonlar
     [1..10] |> List.map add3 |> printfn "new list is %A"
 
-    // lists of functions, and more
+    // Fonksiyonlar listesi ve dahası
     let add6 = [add1; add2; add3] |> List.reduce (>>)
     let d = add6 7
     printfn "1 + 2 + 3 + 7 = %i" d
 
 // ================================================
-// Lists and collection
+// Listeler ve kolleksiyonlar
 // ================================================
 
-// There are three types of ordered collection:
-// * Lists are most basic immutable collection.
-// * Arrays are mutable and more efficient when needed.
-// * Sequences are lazy and infinite (e.g. an enumerator).
-//
-// Other collections include immutable maps and sets
-// plus all the standard .NET collections
+// Üç ç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 ListExamples =
 
-    // lists use square brackets
+    // listeler köşeli parantez kullanır
     let list1 = ["a"; "b"]
-    let list2 = "c" :: list1    // :: is prepending
-    let list3 = list1 @ list2   // @ is concat
+    let list2 = "c" :: list1    // :: baÅŸa eleman ekler
+    let list3 = list1 @ list2   // @ listeleri birbirine ekler
 
-    // list comprehensions (aka generators)
+    // Liste comprehension'ları (jeneratörler olarak da bilinir)
     let squares = [for i in 1..10 do yield i * i]
 
-    // prime number generator
+    // asal sayı jeneratörü
     let rec sieve = function
         | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
         | []      -> []
     let primes = sieve [2..50]
     printfn "%A" primes
 
-    // pattern matching for lists
+    // Listelerle kalıp eşleştirme
     let listMatcher aList =
         match aList with
         | [] -> printfn "the list is empty"
@@ -196,7 +196,7 @@ module ListExamples =
     listMatcher [1]
     listMatcher []
 
-    // recursion using lists
+    // Listeleri kullanarak recursion
     let rec sum aList =
         match aList with
         | [] -> 0
@@ -204,7 +204,7 @@ module ListExamples =
     sum [1..10]
 
     // -----------------------------------------
-    // Standard library functions
+    // Standart kütüphane fonksiyonları
     // -----------------------------------------
 
     // map
@@ -215,15 +215,15 @@ module ListExamples =
     let even x = x % 2 = 0
     [1..10] |> List.filter even
 
-    // many more -- see documentation
+    // ve dahası -- dökümantasyonu bakınız
 
 module ArrayExamples =
 
-    // arrays use square brackets with bar
+    // Diziler köşeli parantezle birlikte çubuk karakterini kullanır
     let array1 = [| "a"; "b" |]
-    let first = array1.[0]        // indexed access using dot
+    let first = array1.[0]        // nokta kullanarak indeks eriÅŸimi
 
-    // pattern matching for arrays is same as for lists
+    // Diziler için kalıp eşleştirme listlerle aynıdır
     let arrayMatcher aList =
         match aList with
         | [| |] -> printfn "the array is empty"
@@ -233,7 +233,7 @@ module ArrayExamples =
 
     arrayMatcher [| 1; 2; 3; 4 |]
 
-    // Standard library functions just as for List
+    // Listede olduğu gibi kütüphane fonksiyonları
 
     [| 1..10 |]
     |> Array.map (fun i -> i + 3)
@@ -243,16 +243,16 @@ module ArrayExamples =
 
 module SequenceExamples =
 
-    // sequences use curly braces
+    // seriler kıvrık parantez kullanır
     let seq1 = seq { yield "a"; yield "b" }
 
-    // sequences can use yield and
-    // can contain subsequences
+    // seriler yield'ı kullanabilir
+    // ve alt seriler barındırabilir
     let strange = seq {
-        // "yield" adds one element
+        // "yield" bir eleman ekliyor
         yield 1; yield 2;
 
-        // "yield!" adds a whole subsequence
+        // "yield!" bütün bir alt seriyi ekliyor
         yield! [5..10]
         yield! seq {
             for i in 1..10 do
@@ -261,8 +261,8 @@ module SequenceExamples =
     strange |> Seq.toList
 
 
-    // Sequences can be created using "unfold"
-    // Here's the fibonacci series
+    // Seriler "unfold" kullanılarak oluşturulabilir
+    // Fibonacci serisi örneği
     let fib = Seq.unfold (fun (fst,snd) ->
         Some(fst + snd, (snd, fst + snd))) (0,1)
 
@@ -272,49 +272,49 @@ module SequenceExamples =
 
 
 // ================================================
-// Data Types
+// Veri Tipleri
 // ================================================
 
 module DataTypeExamples =
 
-    // All data is immutable by default
+    // Bütün veriler varsayılan olarak değiştirilemezdir.
 
-    // Tuples are quick 'n easy anonymous types
-    // -- Use a comma to create a tuple
+    // Tuple'lar çabuk ve kolay anonim tiplerdir.
+    // -- Tuple oluşturmak için virgül kullan
     let twoTuple = 1, 2
     let threeTuple = "a", 2, true
 
-    // Pattern match to unpack
-    let x, y = twoTuple  // sets x = 1, y = 2
+    // paketi açmak için kalıp eşleştirme kullan
+    let x, y = twoTuple  // x = 1, y = 2
 
     // ------------------------------------
-    // Record types have named fields
+    // Record tipi isimlendirilmiÅŸ alanlara sahiptir
     // ------------------------------------
 
-    // Use "type" with curly braces to define a record type
+    // "type" ile kıvrık parantezleri record tipi oluşturmak için kullan
     type Person = {First:string; Last:string}
 
-    // Use "let" with curly braces to create a record
+    // "let" ile kıvrık parantezi record tipi oluşturmak için kullan
     let person1 = {First="John"; Last="Doe"}
 
-    // Pattern match to unpack
-    let {First = first} = person1    // sets first="John"
+    // paketi açmak için kalıp eşleştirme kullan
+    let {First = first} = person1    // first="John"
 
     // ------------------------------------
-    // Union types (aka variants) have a set of choices
-    // Only case can be valid at a time.
+    // Union tipleri (deÄŸiÅŸkenler olarak da bilinir) birden fazla
+	// seçeneğe sahiptir. Belli bir zamanda sadece bir tanesi geçerlidir.
     // ------------------------------------
 
-    // Use "type" with bar/pipe to define a union type
+    // "type" ile çubuk karakterini union tipi tanımlamak için kullan
     type Temp =
         | DegreesC of float
         | DegreesF of float
 
-    // Use one of the cases to create one
+    // Seçeneklerden birini kullan
     let temp1 = DegreesF 98.6
     let temp2 = DegreesC 37.0
 
-    // Pattern match on all cases to unpack
+    // Paketi açmak için bütün seçenekler üzerinde kalıp eşleştirme kullan
     let printTemp = function
        | DegreesC t -> printfn "%f degC" t
        | DegreesF t -> printfn "%f degF" t
@@ -323,11 +323,11 @@ module DataTypeExamples =
     printTemp temp2
 
     // ------------------------------------
-    // Recursive types
+    // Yinelgen (Recursive) tipler
     // ------------------------------------
 
-    // Types can be combined recursively in complex ways
-    // without having to create subclasses
+	// Tipler alt sınıflar oluşturmadan karmaşık şekillerde
+	// yinelgen olarak birleÅŸtirilebilirler.
     type Employee =
       | Worker of Person
       | Manager of Employee list
@@ -336,23 +336,22 @@ module DataTypeExamples =
     let worker = Worker jdoe
 
     // ------------------------------------
-    // Modeling with types
+    // Tipleri Kullanarak Modelleme
     // ------------------------------------
 
-    // Union types are great for modeling state without using flags
+    // Union tipleri bayrak kullanmadan durum modelleme için harikadır.
     type EmailAddress =
         | ValidEmailAddress of string
         | InvalidEmailAddress of string
 
     let trySendEmail email =
-        match email with // use pattern matching
-        | ValidEmailAddress address -> ()   // send
-        | InvalidEmailAddress address -> () // don't send
+        match email with // kalıp eşleştirme kullan
+        | ValidEmailAddress address -> ()   // gönder
+        | InvalidEmailAddress address -> () // gönderme
 
-    // The combination of union types and record types together
-    // provide a great foundation for domain driven design.
-    // You can create hundreds of little types that accurately
-    // reflect the domain.
+	// 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 CartItem = { ProductCode: string; Qty: int }
     type Payment = Payment of float
@@ -360,26 +359,27 @@ module DataTypeExamples =
     type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
 
     type ShoppingCart =
-        | EmptyCart  // no data
+        | EmptyCart  // veri yok
         | ActiveCart of ActiveCartData
         | PaidCart of PaidCartData
 
     // ------------------------------------
-    // Built in behavior for types
+    // Tipler için içgüdüsel davranış
     // ------------------------------------
 
-    // Core types have useful "out-of-the-box" behavior, no coding needed.
-    // * Immutability
-    // * Pretty printing when debugging
-    // * Equality and comparison
+    // Çekirdek tipler kendinden çok kullanışlı özelliklere sahiptir
+	// Ek kodlama gerektirmez
+    // * DeÄŸiÅŸmezlik
+    // * Debug ederken yazdırma
+    // * Eşitlik ve kıyaslama
     // * Serialization
 
-    // Pretty printing using %A
+    // %A kullanarak yazdırma
     printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
              twoTuple person1 temp1 worker
 
-    // Equality and comparison built in.
-    // Here's an example with cards.
+    // Eşitlik ve kıyaslama içgüdüseldir.
+    // İskambil kartlarıyla bir örnek
     type Suit = Club | Diamond | Spade | Heart
     type Rank = Two | Three | Four | Five | Six | Seven | Eight
                 | Nine | Ten | Jack | Queen | King | Ace
@@ -387,31 +387,31 @@ module DataTypeExamples =
     let hand = [ Club, Ace; Heart, Three; Heart, Ace;
                  Spade, Jack; Diamond, Two; Diamond, Ace ]
 
-    // sorting
+    // Sıralama
     List.sort hand |> printfn "sorted hand is (low to high) %A"
     List.max hand |> printfn "high card is %A"
     List.min hand |> printfn "low card is %A"
 
 
 // ================================================
-// Active patterns
+// Aktif Kalıplar
 // ================================================
 
 module ActivePatternExamples =
 
-    // F# has a special type of pattern matching called "active patterns"
-    // where the pattern can be parsed or detected dynamically.
+    // F# "aktif kalıplar" denen bir kalıp eşleştirmeye sahiptir.
+    // Kalıplar dinamik bir şekilde tespit edilip eşleştirilebilir.
 
-    // "banana clips" are the syntax for active patterns
+    // Aktif kalıplar için söz dizimi (| ... |) şeklindedir
 
-    // for example, define an "active" pattern to match character types...
+    // Örneğin, karakter tiplerini eşleyen bir "aktif" kalıp tanımlayın...
     let (|Digit|Letter|Whitespace|Other|) ch =
        if System.Char.IsDigit(ch) then Digit
        else if System.Char.IsLetter(ch) then Letter
        else if System.Char.IsWhiteSpace(ch) then Whitespace
        else Other
 
-    // ... and then use it to make parsing logic much clearer
+    // ... daha sonra eşleme mantığı çok daha net yapmak için bunu kullanın
     let printChar ch =
       match ch with
       | Digit -> printfn "%c is a Digit" ch
@@ -419,19 +419,19 @@ module ActivePatternExamples =
       | Whitespace -> printfn "%c is a Whitespace" ch
       | _ -> printfn "%c is something else" ch
 
-    // print a list
+    // Bir liste yazdırma
     ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
 
     // -----------------------------------
-    // FizzBuzz using active patterns
+    // Aktif Kalıpları Kullanarak FizzBuzz
     // -----------------------------------
 
-    // You can create partial matching patterns as well
-    // Just use underscore in the definition, and return Some if matched.
+	// 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 (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
     let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
 
-    // the main function
+    // Ana fonksiyon
     let fizzBuzz i =
       match i with
       | MultOf3 & MultOf5 -> printf "FizzBuzz, "
@@ -443,106 +443,106 @@ module ActivePatternExamples =
     [1..20] |> List.iter fizzBuzz
 
 // ================================================
-// Conciseness
+// Sadelik
 // ================================================
 
 module AlgorithmExamples =
 
-    // F# has a high signal/noise ratio, so code reads
-    // almost like the actual algorithm
+    // F#'ın sinyal/gürültü oranı yüksektir, dolayısıyla
+    // kod algoritmayla hemen hemen aynı görünür.
 
-    // ------ Example: define sumOfSquares function ------
+    // ------ Örnek: sumOfSquares fonksiyonunu tanımla ------
     let sumOfSquares n =
-       [1..n]              // 1) take all the numbers from 1 to n
-       |> List.map square  // 2) square each one
-       |> List.sum         // 3) sum the results
+       [1..n]              // 1) 1'den n'e kadar bütün sayıları al
+       |> List.map square  // 2) hepsinin karesini al
+       |> List.sum         // 3) sonuçları topla
 
     // test
     sumOfSquares 100 |> printfn "Sum of squares = %A"
 
-    // ------ Example: define a sort function ------
+    // ------ Örnek: bir sıralama fonksiyonu tanımla ------
     let rec sort list =
        match list with
-       // If the list is empty
+       // Liste boÅŸsa
        | [] ->
-            []                            // return an empty list
-       // If the list is not empty
-       | firstElem::otherElements ->      // take the first element
-            let smallerElements =         // extract the smaller elements
-                otherElements             // from the remaining ones
+            []                            // boş listeyi döndür
+       // Liste boÅŸ deÄŸilse
+       | firstElem::otherElements ->      // İlk elemanı al
+            let smallerElements =         // Daha küçük elemanları 
+                otherElements             // diğerlerinden ayır
                 |> List.filter (fun e -> e < firstElem)
-                |> sort                   // and sort them
-            let largerElements =          // extract the larger ones
-                otherElements             // from the remaining ones
+                |> sort                   // ve sırala
+            let largerElements =          // Daha büyük elemanları
+                otherElements             // diğerlerinden ayır
                 |> List.filter (fun e -> e >= firstElem)
-                |> sort                   // and sort them
-            // Combine the 3 parts into a new list and return it
+                |> sort                   // ve sırala
+            // 3 parçayı birbirine ekle ve listeyi döndür
             List.concat [smallerElements; [firstElem]; largerElements]
 
     // test
     sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
 
 // ================================================
-// Asynchronous Code
+// Eşzamanlı olmayan kod
 // ================================================
 
 module AsyncExample =
 
-    // F# has built-in features to help with async code
-    // without encountering the "pyramid of doom"
+    // F# "pyramid of doom" durumuyla karşılaştırmayacak şekilde
+	// içgüdüsel eşzamanlı olmayan özelliklere sahiptir.
     //
-    // The following example downloads a set of web pages in parallel.
+    // Bir sonraki örnek bir web sayfasını paralel bir şekilde indirir.
 
     open System.Net
     open System
     open System.IO
     open Microsoft.FSharp.Control.CommonExtensions
 
-    // Fetch the contents of a URL asynchronously
+    // İçeriği eşzamanlı olmayan bir şekilde getir
     let fetchUrlAsync url =
-        async {   // "async" keyword and curly braces
-                  // creates an "async" object
+        async {   // "async" anahtar kelimesi ve kıvrık parantez
+                  // "async (eşzamanlı olmayan)" nesneyi oluşturur
             let req = WebRequest.Create(Uri(url))
             use! resp = req.AsyncGetResponse()
-                // use! is async assignment
+                // use! eşzamanlı olmayan atamadır
             use stream = resp.GetResponseStream()
-                // "use" triggers automatic close()
-                // on resource at end of scope
+                // "use" kullanılan bloğun dışına çıkınca
+                // close()'u otomatik olarak tetikler
             use reader = new IO.StreamReader(stream)
             let html = reader.ReadToEnd()
             printfn "finished downloading %s" url
             }
 
-    // a list of sites to fetch
+    // İndirmek için bir web sitesi listesi
     let sites = ["http://www.bing.com";
                  "http://www.google.com";
                  "http://www.microsoft.com";
                  "http://www.amazon.com";
                  "http://www.yahoo.com"]
 
-    // do it
+    // Ä°ndir
     sites
-    |> List.map fetchUrlAsync  // make a list of async tasks
-    |> Async.Parallel          // set up the tasks to run in parallel
-    |> Async.RunSynchronously  // start them off
+    |> List.map fetchUrlAsync  // async görevlerden oluşan bir liste yap
+    |> Async.Parallel          // bu görevleri paralel çalışacak şekilde ayarla
+    |> Async.RunSynchronously  // baÅŸlat
 
 // ================================================
-// .NET compatibility
+// .NET uyumluluÄŸu
 // ================================================
 
 module NetCompatibilityExamples =
 
-    // F# can do almost everything C# can do, and it integrates
-    // seamlessly with .NET or Mono libraries.
+    // F#, C#'ın yapabildiği hemen herşeyi yapabilir,
+    // ve .NET ve Mono kütüphaneleriyle tereyağından kıl çeker gibi çalışır.
 
-    // ------- work with existing library functions  -------
+    // ------- var olan kütüphane fonksiyonları ile çalışma -------
 
     let (i1success, i1) = System.Int32.TryParse("123");
     if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
 
-    // ------- Implement interfaces on the fly! -------
+    // ------- Arayüzleri yol üstünde tanımla! -------
 
-    // create a new object that implements IDisposable
+    // IDisposable'ı sağlayan yeni bir nesne oluştur
     let makeResource name =
        { new System.IDisposable
          with member this.Dispose() = printfn "%s disposed" name }
@@ -558,29 +558,29 @@ module NetCompatibilityExamples =
         printfn "using second resource"
         printfn "done."
 
-    // ------- Object oriented code -------
+    // ------- Nesne yönelimli kod -------
 
-    // F# is also a fully fledged OO language.
-    // It supports classes, inheritance, virtual methods, etc.
+    // F# aynı zamanda tam bir nesne yönelimli dildir.
+    // Sınıfları, kalıtımı ve sanal metotları destekler.
 
-    // interface with generic type
+    // Genel ipli bir arayüz
     type IEnumerator<'a> =
         abstract member Current : 'a
         abstract MoveNext : unit -> bool
 
-    // abstract base class with virtual methods
+    // Sanal metotları olan soyut temel sınıflar
     [<AbstractClass>]
     type Shape() =
-        // readonly properties
+        // sadece okunabilir özellikler
         abstract member Width : int with get
         abstract member Height : int with get
-        // non-virtual method
+        // sanal olmayan metot
         member this.BoundingArea = this.Height * this.Width
-        // virtual method with base implementation
+        // temel uygulamasıyla bir sanal metot
         abstract member Print : unit -> unit
         default this.Print () = printfn "I'm a shape"
 
-    // concrete class that inherits from base class and overrides
+    // Somut bir sınıfın soyut sınıftan kalıtımı
     type Rectangle(x:int, y:int) =
         inherit Shape()
         override this.Width = x
@@ -593,9 +593,9 @@ module NetCompatibilityExamples =
     printfn "The area is %i" r.BoundingArea
     r.Print()
 
-    // ------- extension methods  -------
+    // ------- ekleme metotları -------
 
-    // Just as in C#, F# can extend existing classes with extension methods.
+    // 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"
 
@@ -603,7 +603,7 @@ module NetCompatibilityExamples =
     let s = "Alice"
     printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
 
-    // ------- events  -------
+    // ------- olaylar -------
 
     type MyButton() =
         let clickEvent = new Event<_>()
@@ -623,8 +623,8 @@ module NetCompatibilityExamples =
 
 ```
 
-## More Information
+## Daha fazla bilgi
 
-For more demonstrations of F#, go to the [Try F#](http://www.tryfsharp.org/Learn) site, or my [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) series.
+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.
 
-Read more about F# at [fsharp.org](http://fsharp.org/).
+F# hakkında daha fazla bilgi için: [fsharp.org](http://fsharp.org/).
-- 
cgit v1.2.3


From 71cf39f9c20f09bfd9b7dd60f3ec577420b0709d Mon Sep 17 00:00:00 2001
From: Mustafa Zengin <mzengin88@gmail.com>
Date: Mon, 25 Apr 2016 19:22:56 -0700
Subject: translation within the code

---
 tr-tr/fsharp-tr.html.markdown | 400 +++++++++++++++++++++---------------------
 1 file changed, 200 insertions(+), 200 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
index 828d7327..c89b2e34 100644
--- a/tr-tr/fsharp-tr.html.markdown
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -33,84 +33,84 @@ Aşağıdaki kodu denemek istiyorsanız, [tryfsharp.org](http://www.tryfsharp.or
 // "let" anahtar kelimesi (değişmez) değer tanımlar
 let myInt = 5
 let myFloat = 3.14
-let myString = "hello"           // tip bilgisi olmamasına dikkat
+let myString = "merhaba"           	// tip bilgisi olmamasına dikkat
 
 // ------ Listeler ------
-let twoToFive = [2; 3; 4; 5]        // Köşeli parantezler listeleri oluşturur,
-                                 // değerler ise noktalı virgülle ayrılır.
-let oneToFive = 1 :: twoToFive   // :: yeni birinci elemanı olan bir liste oluşturur.
+let ikidenBese = [2; 3; 4; 5]      	// Köşeli parantezler listeleri oluşturur,
+									// değerler ise noktalı virgülle ayrılır.
+let birdenBese = 1 :: ikidenBese   	// :: yeni birinci elemanı olan bir liste oluşturur.
 // Sonuç: [1; 2; 3; 4; 5]
-let zeroToFive = [0; 1] @ twoToFive   // @ iki listeyi birbirine ekler.
+let sifirdanBese = [0; 1] @ ikidenBese	// @ 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 square x = x * x          // Parantez kullanılmadığına dikkat.
-square 3                      // Åžimdi fonksiyonu uygula. Yine parantez yok.
+let kare x = x * x          // Parantez kullanılmadığına dikkat.
+kare 3                      // Åžimdi fonksiyonu uygula. Yine parantez yok.
 
-let add x y = x + y           // add (x,y) kullanmayın! Bu tamamen başka bir anlama geliyor.
-add 2 3                       // Åžimdi fonksiyonu uygula.
+let topla x y = x + y       // topla (x,y) kullanmayın! Bu tamamen başka bir anlama geliyor.
+topla 2 3                   // Åžimdi fonksiyonu uygula.
 
 // çok satırlı bir fonksiyon tanımlamak için sadece girinti kullan. Noktalıı virgül gerekmez.
-let evens list =
-   let isEven x = x % 2 = 0     // "isEven"ı alt fonksiyon olarak tanımla
-   List.filter isEven list    // List.filter boolean bir fonksiyon ve
-                              // üzerinde çalışılacak bir liste parametrelerinden oluşan
-                              // bir kütüphane fonksiyonu
+let ciftler liste =
+   let ciftMi x = x % 2 = 0 	// "ciftMi"yi alt fonksiyon olarak tanımla
+   List.filter ciftMi liste    	// List.filter boolean bir fonksiyon ve
+								// üzerinde çalışılacak bir liste parametrelerinden oluşan
+								// bir kütüphane fonksiyonu
                               
-evens oneToFive               // Åžimdi fonksiyonu uygula.
+evens birdenBese               	// Åžimdi fonksiyonu uygula.
 
 // Parantezleri önceliği netleştirmek için kullanabilirsin. Bu örnekte
-// "map"i önce iki argümanla uygula, sonra sonuç üzerinde "sum" uygula.
-// Parantezler olmasaydı, "List.map" List.sum'ın ilk argümanı olurdu.
-let sumOfSquaresTo100 =
-   List.sum ( List.map square [1..100] )
+// "map"i önce iki argümanla uygula, sonra sonuç üzerinde "ekle" uygula.
+// Parantezler olmasaydı, "List.map" List.ekle'ın ilk argümanı olurdu.
+let yuzeKadarKarelerinToplami =
+   List.ekle ( 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 sumOfSquares fonksiyonunun veri beslemeyle yazılmış hali var:
-let sumOfSquaresTo100piped =
-   [1..100] |> List.map square |> List.sum  // "square" önceden tanımlanmıştı
+// Burada karelerToplami fonksiyonunun veri beslemeyle yazılmış hali var:
+let veriBeslemeyleYuzeKadarKarelerinToplami =
+   [1..100] |> List.map kare |> List.ekle  // "kare" önceden tanımlanmıştı
 
 // Lambda'ları (anonim fonksiyonları) "fun" anahtar kelimesiyle tanımlayabilirsin
-let sumOfSquaresTo100withFun =
-   [1..100] |> List.map (fun x -> x * x) |> List.sum
+let funlaYuzeKadarKarelerinToplami =
+   [1..100] |> List.map (fun x -> x * x) |> List.ekle
 
 // 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 simplePatternMatch =
+let basitKalipEslestirme =
    let x = "a"
    match x with
-    | "a" -> printfn "x is a"
-    | "b" -> printfn "x is b"
-    | _ -> printfn "x is something else"   // alt çizgi bütün kalıplarla eşleşir
+    | "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 validValue = Some(99)
-let invalidValue = None
+let gecerliDeger = Some(99)
+let gecersizDeger = 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 optionPatternMatch input =
+let optionKalipEslestirme input =
    match input with
     | Some i -> printfn "input is an int=%d" i
     | None -> printfn "input is missing"
 
-optionPatternMatch validValue
-optionPatternMatch invalidValue
+optionKalipEslestirme gecerliDeger
+optionKalipEslestirme gecersizDeger
 
 // ------ Yazdırma ------
 // printf/printfn fonksiyonları C#'taki 
 // Console.Write/WriteLine fonksiyonlarına benzer.
-printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
-printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
+printfn "Bir int %i, bir ondalık %f, bir boolean %b yazdırma" 1 2.0 true
+printfn "Bir string %s, ve jenerik bir tip %A" "hello" [1; 2; 3; 4]
 
 // sprintf/sprintfn fonksiyonları ise veriyi string'e
 // çevirmek içindir, C#'taki String.Format gibi.
@@ -125,33 +125,33 @@ printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
 
 // Modüller fonksiyonları gruplamak için kullanılır.
 // Her bir modül için girinti gerekir.
-module FunctionExamples =
+module FonksiyonOrnekleri =
 
     // Temel bir ekleme fonksiyonu tanımla
-    let add x y = x + y
+    let topla x y = x + y
 
     // Bir fonksiyonun temel kullanımı
-    let a = add 1 2
+    let a = topla 1 2
     printfn "1 + 2 = %i" a
 
     // Parametreleri kaynaklamak için parçalı uygulama
-    let add42 = add 42
-    let b = add42 1
+    let kirkIkiEkle = topla 42
+    let b = kirkIkiEkle 1
     printfn "42 + 1 = %i" b
 
     // Fonksiyonları birleştirmek için kompozisyon
-    let add1 = add 1
-    let add2 = add 2
-    let add3 = add1 >> add2
-    let c = add3 7
+    let birEkle = topla 1
+    let ikiEkle = topla 2
+    let ucEkle = birEkle >> ikiEkle
+    let c = ucEkle 7
     printfn "3 + 7 = %i" c
 
     // Yüksek dereceli fonksiyonlar
-    [1..10] |> List.map add3 |> printfn "new list is %A"
+    [1..10] |> List.map ucEkle |> printfn "yeni liste: %A"
 
     // Fonksiyonlar listesi ve dahası
-    let add6 = [add1; add2; add3] |> List.reduce (>>)
-    let d = add6 7
+    let altiEkle = [birEkle; ikiEkle; ucEkle] |> List.reduce (>>)
+    let d = altiEkle 7
     printfn "1 + 2 + 3 + 7 = %i" d
 
 // ================================================
@@ -169,27 +169,27 @@ module FunctionExamples =
 module ListExamples =
 
     // listeler köşeli parantez kullanır
-    let list1 = ["a"; "b"]
-    let list2 = "c" :: list1    // :: baÅŸa eleman ekler
-    let list3 = list1 @ list2   // @ listeleri birbirine ekler
+    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 squares = [for i in 1..10 do yield i * i]
+    let kareler = [for i in 1..10 do yield i * i]
 
     // asal sayı jeneratörü
-    let rec sieve = function
-        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+    let rec elek = function
+        | (p::xler) -> p :: elek [ for x in xler do if x % p > 0 then yield x ]
         | []      -> []
-    let primes = sieve [2..50]
-    printfn "%A" primes
+    let asallar = elek [2..50]
+    printfn "%A" asallar
 
     // Listelerle kalıp eşleştirme
-    let listMatcher aList =
-        match aList with
-        | [] -> printfn "the list is empty"
-        | [first] -> printfn "the list has one element %A " first
-        | [first; second] -> printfn "list is %A and %A" first second
-        | _ -> printfn "the list has more than two elements"
+    let listMatcher 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"
 
     listMatcher [1; 2; 3; 4]
     listMatcher [1; 2]
@@ -197,58 +197,58 @@ module ListExamples =
     listMatcher []
 
     // Listeleri kullanarak recursion
-    let rec sum aList =
-        match aList with
+    let rec ekle liste =
+        match liste with
         | [] -> 0
-        | x::xs -> x + sum xs
-    sum [1..10]
+        | x::xler -> x + ekle xler
+    ekle [1..10]
 
     // -----------------------------------------
     // Standart kütüphane fonksiyonları
     // -----------------------------------------
 
     // map
-    let add3 x = x + 3
-    [1..10] |> List.map add3
+    let ucEkle x = x + 3
+    [1..10] |> List.map ucEkle
 
     // filter
-    let even x = x % 2 = 0
-    [1..10] |> List.filter even
+    let cift x = x % 2 = 0
+    [1..10] |> List.filter cift
 
-    // ve dahası -- dökümantasyonu bakınız
+    // ve dahası -- dökümantasyona bakınız
 
-module ArrayExamples =
+module DiziOrnekleri =
 
     // Diziler köşeli parantezle birlikte çubuk karakterini kullanır
-    let array1 = [| "a"; "b" |]
-    let first = array1.[0]        // nokta kullanarak indeks eriÅŸimi
+    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 arrayMatcher aList =
-        match aList with
-        | [| |] -> printfn "the array is empty"
-        | [| first |] -> printfn "the array has one element %A " first
-        | [| first; second |] -> printfn "array is %A and %A" first second
-        | _ -> printfn "the array has more than two elements"
+    let diziEslestirici 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"
 
-    arrayMatcher [| 1; 2; 3; 4 |]
+    diziEslestirici [| 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 "value is %i. ")
+    |> Array.iter (printfn "deÄŸer: %i. ")
 
 
-module SequenceExamples =
+module SeriOrnekleri =
 
     // seriler kıvrık parantez kullanır
-    let seq1 = seq { yield "a"; yield "b" }
+    let seri1 = seq { yield "a"; yield "b" }
 
     // seriler yield'ı kullanabilir
     // ve alt seriler barındırabilir
-    let strange = seq {
+    let garip = seq {
         // "yield" bir eleman ekliyor
         yield 1; yield 2;
 
@@ -258,47 +258,47 @@ module SequenceExamples =
             for i in 1..10 do
               if i % 2 = 0 then yield i }}
     // test
-    strange |> Seq.toList
+    garip |> Seq.toList
 
 
     // Seriler "unfold" kullanılarak oluşturulabilir
     // Fibonacci serisi örneği
-    let fib = Seq.unfold (fun (fst,snd) ->
-        Some(fst + snd, (snd, fst + snd))) (0,1)
+    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 "first 10 fibs are %A" fib10
+    printf "ilk 10 fibonacci sayısı: %A" fib10
 
 
 // ================================================
 // Veri Tipleri
 // ================================================
 
-module DataTypeExamples =
+module VeriTipiOrnekleri =
 
     // Bütün veriler varsayılan olarak değiştirilemezdir.
 
     // Tuple'lar çabuk ve kolay anonim tiplerdir.
-    // -- Tuple oluşturmak için virgül kullan
-    let twoTuple = 1, 2
-    let threeTuple = "a", 2, true
-
     // paketi açmak için kalıp eşleştirme kullan
-    let x, y = twoTuple  // x = 1, y = 2
+    let x, y = ikiliTuple  // x = 1, y = 2
+
+    // -- Tuple oluşturmak için virgül kullan
+    let ikiliTuple = 1, 2
+    let ucluTuple = "a", 2, true
 
     // ------------------------------------
     // Record tipi isimlendirilmiÅŸ alanlara sahiptir
     // ------------------------------------
 
     // "type" ile kıvrık parantezleri record tipi oluşturmak için kullan
-    type Person = {First:string; Last:string}
+    type Kisi = {birinci:string; Last:string}
 
     // "let" ile kıvrık parantezi record tipi oluşturmak için kullan
-    let person1 = {First="John"; Last="Doe"}
+    let kisi1 = {birinci="John"; Last="Doe"}
 
     // paketi açmak için kalıp eşleştirme kullan
-    let {First = first} = person1    // first="John"
+    let {birinci = birinci} = kisi1    // birinci="John"
 
     // ------------------------------------
     // Union tipleri (deÄŸiÅŸkenler olarak da bilinir) birden fazla
@@ -306,21 +306,21 @@ module DataTypeExamples =
     // ------------------------------------
 
     // "type" ile çubuk karakterini union tipi tanımlamak için kullan
-    type Temp =
-        | DegreesC of float
-        | DegreesF of float
+    type Derece =
+        | Santigrat of float
+        | Fahrenhayt of float
 
     // Seçeneklerden birini kullan
-    let temp1 = DegreesF 98.6
-    let temp2 = DegreesC 37.0
+    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 printTemp = function
-       | DegreesC t -> printfn "%f degC" t
-       | DegreesF t -> printfn "%f degF" t
+    let dereceYazdir = function
+       | Santigrat t -> printfn "%f C" t
+       | Fahrenhayt t -> printfn "%f F" t
 
-    printTemp temp1
-    printTemp temp2
+    dereceYazdir derece1
+    dereceYazdir derece2
 
     // ------------------------------------
     // Yinelgen (Recursive) tipler
@@ -328,40 +328,40 @@ module DataTypeExamples =
 
 	// Tipler alt sınıflar oluşturmadan karmaşık şekillerde
 	// yinelgen olarak birleÅŸtirilebilirler.
-    type Employee =
-      | Worker of Person
-      | Manager of Employee list
+    type Calisan =
+      | Isci of Kisi
+      | Yonetici of Calisan liste
 
-    let jdoe = {First="John"; Last="Doe"}
-    let worker = Worker jdoe
+    let falancaKisi = {birinci="John"; Last="Doe"}
+    let isci = Isci falancaKisi
 
     // ------------------------------------
     // Tipleri Kullanarak Modelleme
     // ------------------------------------
 
     // Union tipleri bayrak kullanmadan durum modelleme için harikadır.
-    type EmailAddress =
-        | ValidEmailAddress of string
-        | InvalidEmailAddress of string
+    type EpostaAdresi =
+        | GecerliEpostaAdresi of string
+        | GecersizEpostaAdresi of string
 
-    let trySendEmail email =
-        match email with // kalıp eşleştirme kullan
-        | ValidEmailAddress address -> ()   // gönder
-        | InvalidEmailAddress address -> () // gönderme
+    let epostaGondermeyiDene eposta =
+        match eposta with // kalıp eşleştirme kullan
+        | GecerliEpostaAdresi adres -> ()   	// gönder
+        | GecersizEpostaAdresi 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 CartItem = { ProductCode: string; Qty: int }
-    type Payment = Payment of float
-    type ActiveCartData = { UnpaidItems: CartItem list }
-    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+    type Urun = { UrunKodu: string; Miktar: int }
+    type Odeme = Odeme of float
+    type AktifSepetVerisi = { OdenmemisUrunler: Urun liste }
+    type OndenmisSepetVerisi = { OdenmisUrunler: Urun liste; Odeme: Odeme}
 
-    type ShoppingCart =
-        | EmptyCart  // veri yok
-        | ActiveCart of ActiveCartData
-        | PaidCart of PaidCartData
+    type AlisverisSepeti =
+        | BosSepet  // veri yok
+        | AktifSepet of AktifSepetVerisi
+        | OdenmisSepet of OndenmisSepetVerisi
 
     // ------------------------------------
     // Tipler için içgüdüsel davranış
@@ -375,29 +375,29 @@ module DataTypeExamples =
     // * Serialization
 
     // %A kullanarak yazdırma
-    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
-             twoTuple person1 temp1 worker
+    printfn "ikiliTuple=%A,\nKisi=%A,\nDerece=%A,\nCalisan=%A"
+             ikiliTuple kisi1 derece1 isci
 
     // Eşitlik ve kıyaslama içgüdüseldir.
     // İskambil kartlarıyla bir örnek
-    type Suit = Club | Diamond | Spade | Heart
-    type Rank = Two | Three | Four | Five | Six | Seven | Eight
-                | Nine | Ten | Jack | Queen | King | Ace
+    type Simge = Sinek | Karo | Maca | Kupa
+    type Sira = Iki | Uc | Dort | Bes | Alti | Yedi | Sekiz
+                | Dokuz | On | Bacak | Kiz | Papaz | As
 
-    let hand = [ Club, Ace; Heart, Three; Heart, Ace;
-                 Spade, Jack; Diamond, Two; Diamond, Ace ]
+    let el = [ Sinek, As; Kupa, Uc; Kupa, As;
+                 Maca, Bacak; Karo, Iki; Karo, As ]
 
     // Sıralama
-    List.sort hand |> printfn "sorted hand is (low to high) %A"
-    List.max hand |> printfn "high card is %A"
-    List.min hand |> printfn "low card is %A"
+    List.sirala 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 ActivePatternExamples =
+module AktifKalipOrnekleri =
 
     // F# "aktif kalıplar" denen bir kalıp eşleştirmeye sahiptir.
     // Kalıplar dinamik bir şekilde tespit edilip eşleştirilebilir.
@@ -405,22 +405,22 @@ module ActivePatternExamples =
     // Aktif kalıplar için söz dizimi (| ... |) şeklindedir
 
     // Örneğin, karakter tiplerini eşleyen bir "aktif" kalıp tanımlayın...
-    let (|Digit|Letter|Whitespace|Other|) ch =
-       if System.Char.IsDigit(ch) then Digit
-       else if System.Char.IsLetter(ch) then Letter
-       else if System.Char.IsWhiteSpace(ch) then Whitespace
-       else Other
+    let (|Rakam|Harf|Bosluk|Diger|) karakter =
+       if System.Char.IsDigit(karakter) then Rakam
+       else if System.Char.IsLetter(karakter) then Harf
+       else if System.Char.IsWhiteSpace(karakter) then Bosluk
+       else Diger
 
     // ... daha sonra eşleme mantığı çok daha net yapmak için bunu kullanın
-    let printChar ch =
-      match ch with
-      | Digit -> printfn "%c is a Digit" ch
-      | Letter -> printfn "%c is a Letter" ch
-      | Whitespace -> printfn "%c is a Whitespace" ch
-      | _ -> printfn "%c is something else" ch
+    let karakterYazdir karakter =
+      match karakter with
+      | Rakam -> printfn "%c bir rakamdır" karakter
+      | Harf -> printfn "%c bir harftir" karakter
+      | Bosluk -> printfn "%c bir boÅŸluktur" karakter
+      | _ -> printfn "%c baÅŸka bir ÅŸeydir" karakter
 
     // Bir liste yazdırma
-    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter karakterYazdir
 
     // -----------------------------------
     // Aktif Kalıpları Kullanarak FizzBuzz
@@ -428,15 +428,15 @@ module ActivePatternExamples =
 
 	// 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 (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
-    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+    let (|UcunKati|_|) i = if i % 3 = 0 then Some UcunKati else None
+    let (|BesinKati|_|) i = if i % 5 = 0 then Some BesinKati else None
 
     // Ana fonksiyon
     let fizzBuzz i =
       match i with
-      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
-      | MultOf3 -> printf "Fizz, "
-      | MultOf5 -> printf "Buzz, "
+      | UcunKati & BesinKati -> printf "FizzBuzz, "
+      | UcunKati -> printf "Fizz, "
+      | BesinKati -> printf "Buzz, "
       | _ -> printf "%i, " i
 
     // test
@@ -446,50 +446,50 @@ module ActivePatternExamples =
 // Sadelik
 // ================================================
 
-module AlgorithmExamples =
+module AlgoritmaOrnekleri =
 
     // F#'ın sinyal/gürültü oranı yüksektir, dolayısıyla
     // kod algoritmayla hemen hemen aynı görünür.
 
-    // ------ Örnek: sumOfSquares fonksiyonunu tanımla ------
-    let sumOfSquares n =
-       [1..n]              // 1) 1'den n'e kadar bütün sayıları al
-       |> List.map square  // 2) hepsinin karesini al
-       |> List.sum         // 3) sonuçları topla
+    // ------ Örnek: karelerToplami fonksiyonunu tanımla ------
+    let karelerToplami n =
+       [1..n]              	// 1) 1'den n'e kadar bütün sayıları al
+       |> List.map kare  	// 2) hepsinin karesini al
+       |> List.ekle         // 3) sonuçları topla
 
     // test
-    sumOfSquares 100 |> printfn "Sum of squares = %A"
+    karelerToplami 100 |> printfn "kareler toplamı = %A"
 
     // ------ Örnek: bir sıralama fonksiyonu tanımla ------
-    let rec sort list =
-       match list with
+    let rec sirala liste =
+       match liste with
        // Liste boÅŸsa
        | [] ->
-            []                            // boş listeyi döndür
+            []                            	// boş listeyi döndür
        // Liste boÅŸ deÄŸilse
-       | firstElem::otherElements ->      // İlk elemanı al
-            let smallerElements =         // Daha küçük elemanları 
-                otherElements             // diğerlerinden ayır
-                |> List.filter (fun e -> e < firstElem)
-                |> sort                   // ve sırala
-            let largerElements =          // Daha büyük elemanları
-                otherElements             // diğerlerinden ayır
-                |> List.filter (fun e -> e >= firstElem)
-                |> sort                   // ve sırala
+       | ilkEleman::digerElemanlar ->		// İlk elemanı al
+            let kucukElemanlar =         	// Daha küçük elemanları 
+                digerElemanlar             	// diğerlerinden ayır
+                |> List.filter (fun e -> e < ilkEleman)
+                |> sirala                   // ve sırala
+            let buyukElemanlar =          	// Daha büyük elemanları
+                digerElemanlar             	// diğerlerinden ayır
+                |> List.filter (fun e -> e >= ilkEleman)
+                |> sirala                   // ve sırala
             // 3 parçayı birbirine ekle ve listeyi döndür
-            List.concat [smallerElements; [firstElem]; largerElements]
+            List.concat [kucukElemanlar; [ilkEleman]; buyukElemanlar]
 
     // test
-    sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
+    sirala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sırala = %A"
 
 // ================================================
-// Eşzamanlı olmayan kod
+// Eşzamansız kod
 // ================================================
 
-module AsyncExample =
+module EszamansizOrnegi =
 
     // F# "pyramid of doom" durumuyla karşılaştırmayacak şekilde
-	// içgüdüsel eşzamanlı olmayan özelliklere sahiptir.
+	// içgüdüsel eşzamansız özelliklere sahiptir.
     //
     // Bir sonraki örnek bir web sayfasını paralel bir şekilde indirir.
 
@@ -498,39 +498,39 @@ module AsyncExample =
     open System.IO
     open Microsoft.FSharp.Control.CommonExtensions
 
-    // İçeriği eşzamanlı olmayan bir şekilde getir
-    let fetchUrlAsync url =
+    // İçeriği eşzamansız bir şekilde getir
+    let eszamansizUrlGetir url =
         async {   // "async" anahtar kelimesi ve kıvrık parantez
-                  // "async (eşzamanlı olmayan)" nesneyi oluşturur
-            let req = WebRequest.Create(Uri(url))
-            use! resp = req.AsyncGetResponse()
-                // use! eşzamanlı olmayan atamadır
-            use stream = resp.GetResponseStream()
+                  // "async (eşzamansız)" nesneyi oluşturur
+            let istek = WebRequest.Create(Uri(url))
+            use! cevap = istek.AsyncGetResponse()
+                // use! eşzamansız atamadır
+            use akis = cevap.GetResponseStream()
                 // "use" kullanılan bloğun dışına çıkınca
                 // close()'u otomatik olarak tetikler
-            use reader = new IO.StreamReader(stream)
-            let html = reader.ReadToEnd()
-            printfn "finished downloading %s" url
+            use okuyucu = new IO.StreamReader(akis)
+            let html = okuyucu.ReadToEnd()
+            printfn "İndirme tamamlandı: %s" url
             }
 
     // İndirmek için bir web sitesi listesi
-    let sites = ["http://www.bing.com";
+    let siteler = ["http://www.bing.com";
                  "http://www.google.com";
                  "http://www.microsoft.com";
                  "http://www.amazon.com";
                  "http://www.yahoo.com"]
 
     // Ä°ndir
-    sites
-    |> List.map fetchUrlAsync  // async görevlerden oluşan bir liste yap
-    |> Async.Parallel          // bu görevleri paralel çalışacak şekilde ayarla
-    |> Async.RunSynchronously  // baÅŸlat
+    siteler
+    |> List.map eszamansizUrlGetir  // 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 NetCompatibilityExamples =
+module NetUyumlulukOrnekleri =
 
     // F#, C#'ın yapabildiği hemen herşeyi yapabilir,
     // ve .NET ve Mono kütüphaneleriyle tereyağından kıl çeker gibi çalışır.
@@ -548,14 +548,14 @@ module NetCompatibilityExamples =
          with member this.Dispose() = printfn "%s disposed" name }
 
     let useAndDisposeResources =
-        use r1 = makeResource "first resource"
-        printfn "using first resource"
+        use r1 = makeResource "birinci resource"
+        printfn "using birinci resource"
         for i in [1..3] do
             let resourceName = sprintf "\tinner resource %d" i
             use temp = makeResource resourceName
             printfn "\tdo something with %s" resourceName
-        use r2 = makeResource "second resource"
-        printfn "using second resource"
+        use r2 = makeResource "ikinci resource"
+        printfn "using ikinci resource"
         printfn "done."
 
     // ------- Nesne yönelimli kod -------
@@ -616,7 +616,7 @@ module NetCompatibilityExamples =
 
     // test
     let myButton = new MyButton()
-    myButton.OnClick.Add(fun (sender, arg) ->
+    myButton.OnClick.topla(fun (sender, arg) ->
             printfn "Click event with arg=%O" arg)
 
     myButton.TestEvent("Hello World!")
-- 
cgit v1.2.3


From 8bd2fd283a5441f8be1382c536fb443baf1ab911 Mon Sep 17 00:00:00 2001
From: Mustafa Zengin <mzengin88@gmail.com>
Date: Mon, 25 Apr 2016 22:34:41 -0700
Subject: fsharp turkish translation, translation for code piece is also
 complete

---
 tr-tr/fsharp-tr.html.markdown | 368 +++++++++++++++++++++---------------------
 1 file changed, 184 insertions(+), 184 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
index c89b2e34..d88e2594 100644
--- a/tr-tr/fsharp-tr.html.markdown
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
 translators:
     - ["Mustafa Zengin", "http://zengin.github.com/"]
-filename: learnfsharp.fs
+filename: learnfsharp-tr.fs
 ---
 
 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.
@@ -20,8 +20,8 @@ Aşağıdaki kodu denemek istiyorsanız, [tryfsharp.org](http://www.tryfsharp.or
 
 ```csharp
 
-// tek satır yorumlar ikili bölme işareti kullanılır
-(* çok satırlı yorumlar (* . . . *) ikilisini kullanır
+// tek satır yorumlar ikili bölme işareti ile başlar
+(* çok satırlı yorumlar ( * . . . * ) ikilisini kullanır
 
 -çok satırlı yorumun sonu- *)
 
@@ -31,59 +31,59 @@ Aşağıdaki kodu denemek istiyorsanız, [tryfsharp.org](http://www.tryfsharp.or
 
 // ------ "DeÄŸiÅŸkenler" (tam da deÄŸil) ------
 // "let" anahtar kelimesi (değişmez) değer tanımlar
-let myInt = 5
-let myFloat = 3.14
-let myString = "merhaba"           	// tip bilgisi olmamasına dikkat
+let tamsayım = 5
+let ondalığım = 3.14
+let stringim = "merhaba"           // tip bilgisi olmamasına dikkat
 
 // ------ Listeler ------
-let ikidenBese = [2; 3; 4; 5]      	// Köşeli parantezler listeleri oluşturur,
-									// değerler ise noktalı virgülle ayrılır.
-let birdenBese = 1 :: ikidenBese   	// :: yeni birinci elemanı olan bir liste oluşturur.
+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 sifirdanBese = [0; 1] @ ikidenBese	// @ iki listeyi birbirine ekler.
+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 uygula. Yine parantez yok.
+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 uygula.
-
-// çok satırlı bir fonksiyon tanımlamak için sadece girinti kullan. Noktalıı virgül gerekmez.
-let ciftler liste =
-   let ciftMi x = x % 2 = 0 	// "ciftMi"yi alt fonksiyon olarak tanımla
-   List.filter ciftMi liste    	// List.filter boolean bir fonksiyon ve
-								// üzerinde çalışılacak bir liste parametrelerinden oluşan
-								// bir kütüphane fonksiyonu
+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
                               
-evens birdenBese               	// Åžimdi fonksiyonu uygula.
+çiftler birdenBeşe              // Şimdi fonksiyonu uygula.
 
-// Parantezleri önceliği netleştirmek için kullanabilirsin. Bu örnekte
-// "map"i önce iki argümanla uygula, sonra sonuç üzerinde "ekle" uygula.
-// Parantezler olmasaydı, "List.map" List.ekle'ın ilk argümanı olurdu.
-let yuzeKadarKarelerinToplami =
-   List.ekle ( List.map kare [1..100] )
+// 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 karelerToplami fonksiyonunun veri beslemeyle yazılmış hali var:
-let veriBeslemeyleYuzeKadarKarelerinToplami =
-   [1..100] |> List.map kare |> List.ekle  // "kare" önceden tanımlanmıştı
+// 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 funlaYuzeKadarKarelerinToplami =
-   [1..100] |> List.map (fun x -> x * x) |> List.ekle
+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 basitKalipEslestirme =
+let basitKalıpEşleştirme =
    let x = "a"
    match x with
     | "a" -> printfn "x a'dır"
@@ -93,24 +93,24 @@ let basitKalipEslestirme =
 // 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 gecerliDeger = Some(99)
-let gecersizDeger = None
+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 optionKalipEslestirme input =
+let optionKalıpEşleştirme input =
    match input with
     | Some i -> printfn "input is an int=%d" i
     | None -> printfn "input is missing"
 
-optionKalipEslestirme gecerliDeger
-optionKalipEslestirme gecersizDeger
+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 int %i, bir ondalık %f, bir boolean %b yazdırma" 1 2.0 true
-printfn "Bir string %s, ve jenerik bir tip %A" "hello" [1; 2; 3; 4]
+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.
@@ -135,23 +135,23 @@ module FonksiyonOrnekleri =
     printfn "1 + 2 = %i" a
 
     // Parametreleri kaynaklamak için parçalı uygulama
-    let kirkIkiEkle = topla 42
-    let b = kirkIkiEkle 1
+    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 ucEkle = birEkle >> ikiEkle
-    let c = ucEkle 7
+    let üçEkle = birEkle >> ikiEkle
+    let c = üçEkle 7
     printfn "3 + 7 = %i" c
 
     // Yüksek dereceli fonksiyonlar
-    [1..10] |> List.map ucEkle |> printfn "yeni liste: %A"
+    [1..10] |> List.map üçEkle |> printfn "yeni liste: %A"
 
     // Fonksiyonlar listesi ve dahası
-    let altiEkle = [birEkle; ikiEkle; ucEkle] |> List.reduce (>>)
-    let d = altiEkle 7
+    let altıEkle = [birEkle; ikiEkle; üçEkle] |> List.reduce (>>)
+    let d = altıEkle 7
     printfn "1 + 2 + 3 + 7 = %i" d
 
 // ================================================
@@ -166,7 +166,7 @@ module FonksiyonOrnekleri =
 // Değiştirilmez map'ler ve kümeler ve bütün .NET kolleksiyonları
 // diğer kolleksiyon türleridir.
 
-module ListExamples =
+module ListeÖrnekleri =
 
     // listeler köşeli parantez kullanır
     let liste1 = ["a"; "b"]
@@ -184,17 +184,17 @@ module ListExamples =
     printfn "%A" asallar
 
     // Listelerle kalıp eşleştirme
-    let listMatcher liste =
+    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"
 
-    listMatcher [1; 2; 3; 4]
-    listMatcher [1; 2]
-    listMatcher [1]
-    listMatcher []
+    listeEÅŸleyici [1; 2; 3; 4]
+    listeEÅŸleyici [1; 2]
+    listeEÅŸleyici [1]
+    listeEÅŸleyici []
 
     // Listeleri kullanarak recursion
     let rec ekle liste =
@@ -208,30 +208,30 @@ module ListExamples =
     // -----------------------------------------
 
     // map
-    let ucEkle x = x + 3
-    [1..10] |> List.map ucEkle
+    let üçEkle x = x + 3
+    [1..10] |> List.map üçEkle
 
     // filter
-    let cift x = x % 2 = 0
-    [1..10] |> List.filter cift
+    let çift x = x % 2 = 0
+    [1..10] |> List.filter çift
 
     // ve dahası -- dökümantasyona bakınız
 
-module DiziOrnekleri =
+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 diziEslestirici liste =
+    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"
 
-    diziEslestirici [| 1; 2; 3; 4 |]
+    diziEÅŸleÅŸtirici [| 1; 2; 3; 4 |]
 
     // Listede olduğu gibi kütüphane fonksiyonları
 
@@ -241,7 +241,7 @@ module DiziOrnekleri =
     |> Array.iter (printfn "deÄŸer: %i. ")
 
 
-module SeriOrnekleri =
+module SeriÖrnekleri =
 
     // seriler kıvrık parantez kullanır
     let seri1 = seq { yield "a"; yield "b" }
@@ -275,38 +275,38 @@ module SeriOrnekleri =
 // Veri Tipleri
 // ================================================
 
-module VeriTipiOrnekleri =
+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
 
-    // -- Tuple oluşturmak için virgül kullan
-    let ikiliTuple = 1, 2
-    let ucluTuple = "a", 2, true
-
     // ------------------------------------
     // Record tipi isimlendirilmiÅŸ alanlara sahiptir
     // ------------------------------------
 
     // "type" ile kıvrık parantezleri record tipi oluşturmak için kullan
-    type Kisi = {birinci:string; Last:string}
+    type KiÅŸi = {Ad:string; Soyad:string}
 
     // "let" ile kıvrık parantezi record tipi oluşturmak için kullan
-    let kisi1 = {birinci="John"; Last="Doe"}
+    let kiÅŸi1 = {Ad="Falanca"; Soyad="KiÅŸi"}
 
     // paketi açmak için kalıp eşleştirme kullan
-    let {birinci = birinci} = kisi1    // birinci="John"
+    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.
+    // seçeneğe sahiptir. Belli bir zamanda sadece bir tanesi geçerlidir.
     // ------------------------------------
 
     // "type" ile çubuk karakterini union tipi tanımlamak için kullan
-    type Derece =
+    type Sıcaklık =
         | Santigrat of float
         | Fahrenhayt of float
 
@@ -315,25 +315,25 @@ module VeriTipiOrnekleri =
     let derece2 = Santigrat 37.0
 
     // Paketi açmak için bütün seçenekler üzerinde kalıp eşleştirme kullan
-    let dereceYazdir = function
+    let dereceYazdır = function
        | Santigrat t -> printfn "%f C" t
        | Fahrenhayt t -> printfn "%f F" t
 
-    dereceYazdir derece1
-    dereceYazdir derece2
+    dereceYazdır derece1
+    dereceYazdır derece2
 
     // ------------------------------------
     // Yinelgen (Recursive) tipler
     // ------------------------------------
 
-	// Tipler alt sınıflar oluşturmadan karmaşık şekillerde
-	// yinelgen olarak birleÅŸtirilebilirler.
-    type Calisan =
-      | Isci of Kisi
-      | Yonetici of Calisan liste
+    // 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 falancaKisi = {birinci="John"; Last="Doe"}
-    let isci = Isci falancaKisi
+    let falancaKiÅŸi = {Ad="Falanca"; Soyad="KiÅŸi"}
+    let işçi = İşçi falancaKişi
 
     // ------------------------------------
     // Tipleri Kullanarak Modelleme
@@ -341,54 +341,54 @@ module VeriTipiOrnekleri =
 
     // Union tipleri bayrak kullanmadan durum modelleme için harikadır.
     type EpostaAdresi =
-        | GecerliEpostaAdresi of string
-        | GecersizEpostaAdresi of string
+        | GeçerliEpostaAdresi of string
+        | GeçersizEpostaAdresi of string
 
-    let epostaGondermeyiDene eposta =
-        match eposta with // kalıp eşleştirme kullan
-        | GecerliEpostaAdresi adres -> ()   	// gönder
-        | GecersizEpostaAdresi adres -> () 		// gönderme
+    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.
+    // 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 Urun = { UrunKodu: string; Miktar: int }
-    type Odeme = Odeme of float
-    type AktifSepetVerisi = { OdenmemisUrunler: Urun liste }
-    type OndenmisSepetVerisi = { OdenmisUrunler: Urun liste; Odeme: Odeme}
+    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 AlisverisSepeti =
+    type AlışverişSepeti =
         | BosSepet  // veri yok
         | AktifSepet of AktifSepetVerisi
-        | OdenmisSepet of OndenmisSepetVerisi
+        | ÖdenmişSepet of ÖdenmişSepetVerisi
 
     // ------------------------------------
     // Tipler için içgüdüsel davranış
     // ------------------------------------
 
     // Çekirdek tipler kendinden çok kullanışlı özelliklere sahiptir
-	// Ek kodlama gerektirmez
+    // Ek kodlama gerektirmez
     // * DeÄŸiÅŸmezlik
     // * Debug ederken yazdırma
     // * Eşitlik ve kıyaslama
     // * Serialization
 
     // %A kullanarak yazdırma
-    printfn "ikiliTuple=%A,\nKisi=%A,\nDerece=%A,\nCalisan=%A"
-             ikiliTuple kisi1 derece1 isci
+    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 | Maca | Kupa
-    type Sira = Iki | Uc | Dort | Bes | Alti | Yedi | Sekiz
-                | Dokuz | On | Bacak | Kiz | Papaz | As
+    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, Uc; Kupa, As;
-                 Maca, Bacak; Karo, Iki; Karo, As ]
+    let el = [ Sinek, As; Kupa, Üç; Kupa, As;
+                 Maça, Bacak; Karo, İki; Karo, As ]
 
     // Sıralama
-    List.sirala el |> printfn "artarak dizilen el: %A"
+    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"
 
@@ -397,7 +397,7 @@ module VeriTipiOrnekleri =
 // Aktif Kalıplar
 // ================================================
 
-module AktifKalipOrnekleri =
+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.
@@ -405,38 +405,38 @@ module AktifKalipOrnekleri =
     // 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|Bosluk|Diger|) karakter =
+    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 Bosluk
-       else Diger
+       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 karakterYazdir karakter =
+    let karakterYazdır karakter =
       match karakter with
       | Rakam -> printfn "%c bir rakamdır" karakter
       | Harf -> printfn "%c bir harftir" karakter
-      | Bosluk -> printfn "%c bir boÅŸluktur" 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 karakterYazdir
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter karakterYazdır
 
     // -----------------------------------
     // Aktif Kalıpları Kullanarak FizzBuzz
     // -----------------------------------
 
-	// Parçalı eşleşen kalıplar da oluşturabilirsiniz
+    // 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 (|UcunKati|_|) i = if i % 3 = 0 then Some UcunKati else None
-    let (|BesinKati|_|) i = if i % 5 = 0 then Some BesinKati else None
+    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
-      | UcunKati & BesinKati -> printf "FizzBuzz, "
-      | UcunKati -> printf "Fizz, "
-      | BesinKati -> printf "Buzz, "
+      | ÜçünKatı & BeşinKatı -> printf "FizzBuzz, "
+      | ÜçünKatı -> printf "Fizz, "
+      | BeşinKatı -> printf "Buzz, "
       | _ -> printf "%i, " i
 
     // test
@@ -446,50 +446,50 @@ module AktifKalipOrnekleri =
 // Sadelik
 // ================================================
 
-module AlgoritmaOrnekleri =
+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 karelerToplami n =
-       [1..n]              	// 1) 1'den n'e kadar bütün sayıları al
-       |> List.map kare  	// 2) hepsinin karesini al
-       |> List.ekle         // 3) sonuçları topla
+    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
-    karelerToplami 100 |> printfn "kareler toplamı = %A"
+    karelerToplamı 100 |> printfn "kareler toplamı = %A"
 
     // ------ Örnek: bir sıralama fonksiyonu tanımla ------
-    let rec sirala liste =
+    let rec sırala liste =
        match liste with
        // Liste boÅŸsa
        | [] ->
-            []                            	// boş listeyi döndür
+            []                              // boş listeyi döndür
        // Liste boÅŸ deÄŸilse
-       | ilkEleman::digerElemanlar ->		// İlk elemanı al
-            let kucukElemanlar =         	// Daha küçük elemanları 
-                digerElemanlar             	// diğerlerinden ayır
+       | 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)
-                |> sirala                   // ve sırala
-            let buyukElemanlar =          	// Daha büyük elemanları
-                digerElemanlar             	// diğerlerinden ayır
+                |> 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)
-                |> sirala                   // ve sırala
+                |> sırala                   // ve sırala
             // 3 parçayı birbirine ekle ve listeyi döndür
-            List.concat [kucukElemanlar; [ilkEleman]; buyukElemanlar]
+            List.concat [küçükElemanlar; [ilkEleman]; büyükElemanlar]
 
     // test
-    sirala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sırala = %A"
+    sırala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sırala = %A"
 
 // ================================================
 // Eşzamansız kod
 // ================================================
 
-module EszamansizOrnegi =
+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.
+    // içgüdüsel eşzamansız özelliklere sahiptir.
     //
     // Bir sonraki örnek bir web sayfasını paralel bir şekilde indirir.
 
@@ -499,16 +499,16 @@ module EszamansizOrnegi =
     open Microsoft.FSharp.Control.CommonExtensions
 
     // İçeriği eşzamansız bir şekilde getir
-    let eszamansizUrlGetir url =
+    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 akis = cevap.GetResponseStream()
+            use akış = cevap.GetResponseStream()
                 // "use" kullanılan bloğun dışına çıkınca
                 // close()'u otomatik olarak tetikler
-            use okuyucu = new IO.StreamReader(akis)
+            use okuyucu = new IO.StreamReader(akış)
             let html = okuyucu.ReadToEnd()
             printfn "İndirme tamamlandı: %s" url
             }
@@ -522,76 +522,76 @@ module EszamansizOrnegi =
 
     // Ä°ndir
     siteler
-    |> List.map eszamansizUrlGetir  // eşzamansız görevlerden oluşan bir liste yap
-    |> Async.Parallel          		// bu görevleri paralel çalışacak şekilde ayarla
-    |> Async.RunSynchronously  		// baÅŸlat
+    |> 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 NetUyumlulukOrnekleri =
+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 (i1success, i1) = System.Int32.TryParse("123");
-    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+    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ımla! -------
+    // ------- Arayüzleri yol üstünde tanımlayın! -------
 
     // IDisposable'ı sağlayan yeni bir nesne oluştur
-    let makeResource name =
+    let kaynakOluÅŸtur isim =
        { new System.IDisposable
-         with member this.Dispose() = printfn "%s disposed" name }
+         with member this.Dispose() = printfn "%s atıldı" isim }
 
-    let useAndDisposeResources =
-        use r1 = makeResource "birinci resource"
-        printfn "using birinci resource"
+    let kaynakKullanVeAt =
+        use r1 = kaynakOluÅŸtur "birinci kaynak"
+        printfn "birinci kaynağı kullanıyor"
         for i in [1..3] do
-            let resourceName = sprintf "\tinner resource %d" i
-            use temp = makeResource resourceName
-            printfn "\tdo something with %s" resourceName
-        use r2 = makeResource "ikinci resource"
-        printfn "using ikinci resource"
-        printfn "done."
+            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 ipli bir arayüz
+    // Genel tipli bir arayüz
     type IEnumerator<'a> =
-        abstract member Current : 'a
-        abstract MoveNext : unit -> bool
+        abstract member Åžimdiki : 'a
+        abstract SonrakineGeç : unit -> bool
 
     // Sanal metotları olan soyut temel sınıflar
     [<AbstractClass>]
-    type Shape() =
+    type Åžekil() =
         // sadece okunabilir özellikler
-        abstract member Width : int with get
-        abstract member Height : int with get
+        abstract member GeniÅŸlik : int with get
+        abstract member Yükseklik : int with get
         // sanal olmayan metot
-        member this.BoundingArea = this.Height * this.Width
+        member this.ÇevreleyenAlan = this.Yükseklik * this.Genişlik
         // temel uygulamasıyla bir sanal metot
-        abstract member Print : unit -> unit
-        default this.Print () = printfn "I'm a shape"
+        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 Rectangle(x:int, y:int) =
-        inherit Shape()
-        override this.Width = x
-        override this.Height = y
-        override this.Print ()  = printfn "I'm a Rectangle"
+    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 = Rectangle(2, 3)
-    printfn "The width is %i" r.Width
-    printfn "The area is %i" r.BoundingArea
-    r.Print()
+    let r = Dikdörtgen(2, 3)
+    printfn "GeniÅŸlik: %i" r.GeniÅŸlik
+    printfn "Çevreleyen Alan: %i" r.ÇevreleyenAlan
+    r.Yazdır()
 
     // ------- ekleme metotları -------
 
@@ -600,26 +600,26 @@ module NetUyumlulukOrnekleri =
        member this.StartsWithA = this.StartsWith "A"
 
     // test
-    let s = "Alice"
-    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+    let s = "Ahmet"
+    printfn "'%s' 'A' ile baÅŸlar = %A" s s.StartsWithA
 
     // ------- olaylar -------
 
-    type MyButton() =
-        let clickEvent = new Event<_>()
+    type Butonum() =
+        let tıklamaOlayı = new Event<_>()
 
         [<CLIEvent>]
-        member this.OnClick = clickEvent.Publish
+        member this.OnClick = tıklamaOlayı.Publish
 
-        member this.TestEvent(arg) =
-            clickEvent.Trigger(this, arg)
+        member this.DenemeOlayı(arg) =
+            tıklamaOlayı.Trigger(this, arg)
 
     // test
-    let myButton = new MyButton()
-    myButton.OnClick.topla(fun (sender, arg) ->
-            printfn "Click event with arg=%O" arg)
+    let butonum = new Butonum()
+    butonum.OnClick.Add(fun (sender, arg) ->
+            printfn "arg=%O ile beraber bir tıklama olayı" arg)
 
-    myButton.TestEvent("Hello World!")
+    butonum.DenemeOlayı("Merhaba Dünya!")
 
 ```
 
-- 
cgit v1.2.3


From 02fb96d6998df7f5ecfc3b546d323547c135584e Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Mon, 25 Apr 2016 22:51:05 -0700
Subject: Update fsharp-tr.html.markdown

---
 tr-tr/fsharp-tr.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'tr-tr')

diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
index d88e2594..8c47397c 100644
--- a/tr-tr/fsharp-tr.html.markdown
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -5,6 +5,7 @@ contributors:
 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.
-- 
cgit v1.2.3


From 2e6c386e9b1e742ac015ab424b3cf0f456c8d550 Mon Sep 17 00:00:00 2001
From: Mustafa Zengin <mzengin88@gmail.com>
Date: Wed, 27 Apr 2016 23:56:57 -0700
Subject: TypeScript Turkish translation (#2246)

---
 tr-tr/typescript-tr.html.markdown | 180 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 tr-tr/typescript-tr.html.markdown

(limited to 'tr-tr')

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/)
-- 
cgit v1.2.3


From 98abad6935b77e66a4b8f2ddff340d57dbfeb173 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Wed, 31 Aug 2016 15:18:38 -0700
Subject: Remove redundant nl markdown and fix fortran file

---
 tr-tr/c-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 2d4240ed..33544765 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -202,7 +202,7 @@ int main() {
     0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
 
     // Isaretli sayilari kaydirirken dikkatli olun - tanimsizlar sunlardir:
-    // - isaretli sayinin isaret bitinde yapÄilan kaydirma (int a = 1 << 32)
+    // - 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
-- 
cgit v1.2.3


From 20b2a9a29d485a52b8ab455b6b0fae65678174ef Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Sat, 28 Jan 2017 10:22:30 +0100
Subject: Fix swift-tr filename

fixes #2635
---
 tr-tr/swift-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 15056bb8..e694d95d 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -2,7 +2,7 @@
 language: swift
 contributors:
   - ["Özgür Şahin", "https://github.com/ozgurshn/"]
-filename: learnswift.swift
+filename: learnswift-tr.swift
 lang: tr-tr
 ---
 
-- 
cgit v1.2.3


From 305ca3611d1de1e5625bca743c0fcef7e4ccd535 Mon Sep 17 00:00:00 2001
From: cemyaras <cemyaras@gmail.com>
Date: Wed, 15 Mar 2017 11:07:29 +0200
Subject: dynamic-programming-tr (#2667)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* dynamic-programming-tr

Türkçe çeviri

* Rename dynamic-programming-tr to dynamic-programming-tr.html.markdown

added ".html.markdown" to the filename
---
 tr-tr/dynamic-programming-tr.html.markdown | 44 ++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 tr-tr/dynamic-programming-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
new file mode 100644
index 00000000..1900ee93
--- /dev/null
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -0,0 +1,44 @@
+---
+language: Dynamic Programming
+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.
+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
-- 
cgit v1.2.3


From a270849823677f27fca8fd7253913472fe22e01e Mon Sep 17 00:00:00 2001
From: baha <bahacan19@gmail.com>
Date: Fri, 28 Jul 2017 11:54:58 +0300
Subject: [kotlin/tr] kotlin turkish document

---
 tr-tr/kotlin-tr.html.markdown | 406 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 406 insertions(+)
 create mode 100644 tr-tr/kotlin-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
new file mode 100644
index 00000000..62756468
--- /dev/null
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -0,0 +1,406 @@
+---
+language: kotlin
+contributors:
+    - ["Baha Can Aydın", "https://github.com/bahacan19"]
+---
+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" keyword works in the same way as in Java.
+//  "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)}")
+    }
+
+    /*
+    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")
+    }
+
+    // The "with" function is similar to the JavaScript "with" statement.
+    // '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)
+
+    fun myFun(x:Int) : Any {
+        if (x>10) return "b"
+        else return 1
+    }
+
+    /*
+    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!
+
+    println(EnumExample.A) // => A
+    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/)
-- 
cgit v1.2.3


From 2858d077827308b8ca4ba7a8185715461503bee6 Mon Sep 17 00:00:00 2001
From: baha <bahacan19@gmail.com>
Date: Mon, 31 Jul 2017 15:53:26 +0300
Subject: [kotlin/tr] removed unused code

---
 tr-tr/kotlin-tr.html.markdown | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
index 62756468..cc8815a7 100644
--- a/tr-tr/kotlin-tr.html.markdown
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -326,10 +326,6 @@ fun helloWorld(val name : String) {
     }
     println(result)
 
-    fun myFun(x:Int) : Any {
-        if (x>10) return "b"
-        else return 1
-    }
 
     /*
     Bir objenin tipini 'is' operatörü ile tayin edebiliriz.
-- 
cgit v1.2.3


From 04c0ccb2ae6326edc4f17e41ff82fe8af9fa7b4a Mon Sep 17 00:00:00 2001
From: baha <bahacan19@gmail.com>
Date: Mon, 31 Jul 2017 16:05:22 +0300
Subject: [kotlin/tr] for loops added

---
 tr-tr/kotlin-tr.html.markdown | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
index cc8815a7..2dcb92e0 100644
--- a/tr-tr/kotlin-tr.html.markdown
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -14,7 +14,6 @@ Java %100 birlikte çalışabilir.
     Birkaç satırı yoruma almak için
 */
 
-//  "package" keyword works in the same way as in Java.
 //  "package" anahtar kelimesi tıpkı Java'da olduğu gibidir.
 package com.learnxinyminutes.kotlin
 
@@ -141,6 +140,18 @@ fun helloWorld(val name : String) {
         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.
-- 
cgit v1.2.3


From ef1cf7d71ecb3f9879397c0893bb8803b427240f Mon Sep 17 00:00:00 2001
From: baha <bahacan19@gmail.com>
Date: Mon, 31 Jul 2017 17:24:58 +0300
Subject: [kotlin/tr] Delegated properties added

---
 tr-tr/kotlin-tr.html.markdown | 57 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

(limited to 'tr-tr')

diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
index 2dcb92e0..e549ef8e 100644
--- a/tr-tr/kotlin-tr.html.markdown
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -381,6 +381,63 @@ fun helloWorld(val name : String) {
 
     println(EnumExample.A) // => A
     println(ObjectExample.hello()) // => Merhaba
+
+    //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
 }
 
 // Enum class lar Java'daki enum lara benzerdir.
-- 
cgit v1.2.3


From 8b3b05a48cd0a49cbf009430ab965b26d92040d0 Mon Sep 17 00:00:00 2001
From: baha <bahacan19@gmail.com>
Date: Thu, 10 Aug 2017 14:38:03 +0300
Subject: [kotlin/tr] some cleanup

---
 tr-tr/kotlin-tr.html.markdown | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
index e549ef8e..043cf31f 100644
--- a/tr-tr/kotlin-tr.html.markdown
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -215,7 +215,6 @@ fun helloWorld(val name : String) {
         println("$key -> $value")
     }
 
-    // The "with" function is similar to the JavaScript "with" statement.
     // '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)
@@ -379,8 +378,7 @@ fun helloWorld(val name : String) {
     }
     println("Merhaba, dünya!".remove('a')) // => Merhb, düny!
 
-    println(EnumExample.A) // => A
-    println(ObjectExample.hello()) // => Merhaba
+
 
     //Biraz detaylı Kotlin
 
@@ -438,6 +436,10 @@ fun helloWorld(val name : String) {
     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.
-- 
cgit v1.2.3


From 985d23a52b76593a120adff5381c2df3a80fe298 Mon Sep 17 00:00:00 2001
From: HairyFotr <hairyfotr@gmail.com>
Date: Wed, 23 Aug 2017 10:14:39 +0200
Subject: Fix a bunch of typos

---
 tr-tr/c-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 33544765..6042a609 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -481,7 +481,7 @@ 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.
 
-- 
cgit v1.2.3


From 924fc1901155b06bb33ab2a5cb043231d936247a Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 14:16:32 +0545
Subject: Add filename(#2832)

---
 tr-tr/dynamic-programming-tr.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'tr-tr')

diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
index 1900ee93..c0471fe1 100644
--- a/tr-tr/dynamic-programming-tr.html.markdown
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: Dynamic Programming
+filename: dynamic-tr.txt
 contributors:
     - ["Akashdeep Goel", "https://github.com/akashdeepgoel"]
 translators:
-- 
cgit v1.2.3


From e43c15454850557b4a3826fbf9ed2e0fa428ee75 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 14:40:38 +0545
Subject: fix download file(#2832)

---
 tr-tr/dynamic-programming-tr.html.markdown | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'tr-tr')

diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
index c0471fe1..606ecf04 100644
--- a/tr-tr/dynamic-programming-tr.html.markdown
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -28,6 +28,8 @@ En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini
 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
@@ -36,6 +38,8 @@ for i=0 to n-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
-- 
cgit v1.2.3


From d9b28d5726ea33f9b9bafc44c1a78fb113925af5 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 16:01:42 +0545
Subject: add filename and language

---
 tr-tr/kotlin-tr.html.markdown | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
index 043cf31f..4d2dd291 100644
--- a/tr-tr/kotlin-tr.html.markdown
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -1,7 +1,9 @@
 ---
 language: kotlin
+filename: kotlin-tr.kt
 contributors:
-    - ["Baha Can Aydın", "https://github.com/bahacan19"]
+        - ["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.
-- 
cgit v1.2.3


From d01e5242e16c522becc1b04f9692d2556f94c4f1 Mon Sep 17 00:00:00 2001
From: Damian Rzeszot <damian.rzeszot@gmail.com>
Date: Mon, 9 Oct 2017 12:01:15 +0200
Subject: swift | fix style guidelines

---
 tr-tr/swift-tr.html.markdown | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index e694d95d..c9473cb2 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -443,19 +443,19 @@ if let daire = benimBosDairem {
 // Sınıflar gibi metotlar içerebilirler.
 
 enum Kart {
-    case Kupa, Maca, Sinek, Karo
+    case kupa, maca, sinek, karo
     func getIcon() -> String {
         switch self {
-        case .Maca: return "♤"
-        case .Kupa: return "♡"
-        case .Karo: return "♢"
-        case .Sinek: return "♧"
+        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
+var kartTipi: Kart = .kupa
 
 // Integer olmayan enumlar direk deÄŸer (rawValue) atama gerektirir.
 enum KitapAdi: String {
-- 
cgit v1.2.3


From 9a9e52b54bf9bc6ebeefc996452f5944a234557f Mon Sep 17 00:00:00 2001
From: Damian Rzeszot <damian.rzeszot@gmail.com>
Date: Mon, 9 Oct 2017 12:02:29 +0200
Subject: swift | fix style guidelines

---
 tr-tr/swift-tr.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index c9473cb2..5e09daa9 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -459,10 +459,10 @@ var kartTipi: Kart = .kupa
 
 // Integer olmayan enumlar direk deÄŸer (rawValue) atama gerektirir.
 enum KitapAdi: String {
-    case John = "John"
-    case Luke = "Luke"
+    case john = "John"
+    case luke = "Luke"
 }
-print("Name: \(KitapAdi.John.rawValue)")
+print("Name: \(KitapAdi.john.rawValue)")
 
 // DeÄŸerlerle iliÅŸkilendirilmiÅŸ Enum
 enum Mobilya {
-- 
cgit v1.2.3


From e8ee66c854b8833fcb0fd76b5e9ace6ae8379397 Mon Sep 17 00:00:00 2001
From: Damian Rzeszot <damian.rzeszot@gmail.com>
Date: Mon, 9 Oct 2017 12:03:27 +0200
Subject: swift | fix style guidelines

---
 tr-tr/swift-tr.html.markdown | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 5e09daa9..4c2cf59b 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -467,23 +467,23 @@ print("Name: \(KitapAdi.john.rawValue)")
 // DeÄŸerlerle iliÅŸkilendirilmiÅŸ Enum
 enum Mobilya {
     // Int ile iliÅŸkilendirilmiÅŸ
-    case Masa(yukseklik: Int)
+    case masa(yukseklik: Int)
     // String ve Int ile iliÅŸkilendirilmiÅŸ
-    case Sandalye(String, Int)
-    
+    case sandalye(String, Int)
+
     func aciklama() -> String {
         switch self {
-        case .Masa(let yukseklik):
+        case .masa(let yukseklik):
             return "Masa boyu \(yukseklik) cm"
-        case .Sandalye(let marka, let yukseklik):
+        case .sandalye(let marka, let yukseklik):
             return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
         }
     }
 }
 
-var masa: Mobilya = .Masa(yukseklik: 80)
+var masa: Mobilya = .masa(yukseklik: 80)
 print(masa.aciklama())     // "Masa boyu 80 cm"
-var sandalye = Mobilya.Sandalye("Foo", 40)
+var sandalye = Mobilya.sandalye("Foo", 40)
 print(sandalye.aciklama())    // "Foo marka sandalyenin boyu 40 cm"
 
 
-- 
cgit v1.2.3