Merge remote-tracking branch 'upstream/master' into json-ru

perl6.html.markdown

@@ -157,7 +157,6 @@ sub named-def(:$def = 5) {
   say $def;
 }
 named-def; #=> 5
-named-def(:10def); #=> 10
 named-def(def => 15); #=> 15
 
 # Since you can omit parenthesis to call a function with no arguments,
@@ -653,7 +652,7 @@ class A {
   has Int $!private-field = 10;
 
   method get-value {
-    $.field + $!private-field + $n;
+    $.field + $!private-field;
   }
   
   method set-value($n) {
@@ -671,7 +670,7 @@ class A {
 # Create a new instance of A with $.field set to 5 :
 # Note: you can't set private-field from here (more later on).
 my $a = A.new(field => 5);
-$a.get-value; #=> 18
+$a.get-value; #=> 15
 #$a.field = 5; # This fails, because the `has $.field` is immutable
 $a.other-field = 10; # This, however, works, because the public field
                      #  is mutable (`rw`).

r.html.markdown

@@ -229,6 +229,13 @@ FALSE != FALSE	# FALSE
 FALSE != TRUE	# TRUE
 # Missing data (NA) is logical, too
 class(NA)	# "logical"
+# Use | and & for logic operations.
+# OR
+TRUE | FALSE	# TRUE
+# AND
+TRUE & FALSE	# FALSE
+# You can test if x is TRUE
+isTRUE(TRUE)	# TRUE
 # Here we get a logical vector with many elements:
 c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
 c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE

ru-ru/python-ru.html.markdown

@@ -10,20 +10,20 @@ filename: learnpython-ru.py
 ---
 
 Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
-самых популярных языков. Я люблю его за понятный и доходчивый синтаксис  — это
+самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис  — это
-почти что исполняемый псевдокод.
+почти исполняемый псевдокод.
 
 С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
 или louiedinh [at] [почтовый сервис Google]
 
-Замечание: Эта статья относится к Python 2.7, но должно работать и в Python 2.x.
+Замечание: Эта статья относится к Python 2.7, но должно работать и в других версиях Python 2.x.
-Скоро будет версия и для Python 3!
+Чтобы изучить Python 3.x, обратитесь к статье по Python 3.
 
 ```python
 # Однострочные комментарии начинаются с символа решётки.
 """ Многострочный текст может быть 
     записан, используя 3 знака " и обычно используется
-    в качестве комментария
+    в качестве встроенной документации
 """
 
 ####################################################
@@ -43,7 +43,7 @@ filename: learnpython-ru.py
 # целых чисел, и результат автоматически округляется в меньшую сторону.
 5 / 2 #=> 2
 
-# Чтобы научиться делить, сначала нужно немного узнать о числах
+# Чтобы делить правильно, сначала нужно немного узнать о числах
 # с плавающей запятой.
 2.0     # Это число с плавающей запятой
 11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше
@@ -59,14 +59,22 @@ filename: learnpython-ru.py
 7 % 3 # => 1
 
 # Возведение в степень
-2 ** 4 # => 16
+2**4 # => 16
 
 # Приоритет операций указывается скобками
 (1 + 3) * 2 #=> 8
 
-# Логические (булевы) значения являются примитивами
+# Логические операторы
-True
+# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
-False
+True and False #=> False
+False or True #=> True
+
+# Обратите внимание, что логические операторы используются и с целыми числами
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
 
 # Для отрицания используется ключевое слово not
 not True #=> False
@@ -86,7 +94,7 @@ not False #=> True
 2 <= 2 #=> True
 2 >= 2 #=> True
 
-# Сравнения могут быть соединены в цепь!
+# Сравнения могут быть записаны цепочкой!
 1 < 2 < 3 #=> True
 2 < 3 < 2 #=> False
 
@@ -94,9 +102,12 @@ not False #=> True
 "Это строка."
 'Это тоже строка.'
 
-# И строки тоже могут складываться!
+# И строки тоже можно складывать!
 "Привет " + "мир!" #=> "Привет мир!"
 
+# ... или умножать
+"Привет" * 3  # => "ПриветПриветПривет"
+
 # Со строкой можно работать, как со списком символов
 "Это строка"[0] #=> 'Э'
 
@@ -122,7 +133,7 @@ None is None  #=> True
 # очень полезен при работе с примитивными типами, но 
 # зато просто незаменим при работе с объектами.
 
-# None, 0, и пустые строки/списки равны False.
+# None, 0 и пустые строки/списки равны False.
 # Все остальные значения равны True
 0 == False  #=> True
 "" == False #=> True
@@ -132,12 +143,14 @@ None is None  #=> True
 ## 2. Переменные и коллекции
 ####################################################
 
-# У Python есть функция Print, доступная в версиях 2.7 и 3,
+# В Python есть оператор print, доступный в версиях 2.x, но удалённый в версии 3
-print("Я Python. Приятно познакомиться!")
+print "Я Python. Приятно познакомиться!"
-# ...и старый оператор print, доступный в версиях 2.x, но удалённый в версии 3.
+# В Python также есть функция print(), доступная в версиях 2.7 и 3,
-print "И я тоже Python!"
+# Но для версии 2.7 нужно добавить следующий импорт модуля (раскомментируйте)):
+# from __future__ import print_function
+print("Я тоже Python! ")
 
-# Необязательно объявлять переменные перед их инициализацией.
+# Объявлять переменные перед инициализацией не нужно.
 some_var = 5    # По соглашению используется нижний_регистр_с_подчёркиваниями
 some_var #=> 5
 
@@ -151,7 +164,7 @@ some_other_var  # Выбрасывает ошибку именования
 
 # Списки хранят последовательности
 li = []
-# Можно сразу начать с заполненным списком
+# Можно сразу начать с заполненного списка
 other_li = [4, 5, 6]
 
 # Объекты добавляются в конец списка методом append
@@ -166,13 +179,17 @@ li.append(3)    # [1, 2, 4, 3].
 
 # Обращайтесь со списком, как с обычным массивом
 li[0] #=> 1
+# Присваивайте новые значения уже инициализированным индексам с помощью =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Обратите внимание: возвращаемся на исходное значение
 # Обратимся к последнему элементу
 li[-1] #=> 3
 
 # Попытка выйти за границы массива приведёт к ошибке индекса
 li[4] # Выдаёт IndexError
 
-# Можно обращаться к диапазону, используя "кусочный синтаксис" (slice syntax)
+# Можно обращаться к диапазону, используя так называемые срезы
 # (Для тех, кто любит математику, это называется замкнуто-открытый интервал).
 li[1:3] #=> [2, 4]
 # Опускаем начало
@@ -183,14 +200,15 @@ li[:3] #=> [1, 2, 4]
 li[::2]   # =>[1, 4]
 # Переворачиваем список
 li[::-1]   # => [3, 4, 2, 1]
-# Используйте сочетания всего вышеназванного для выделения более сложных кусков
+# Используйте сочетания всего вышеназванного для выделения более сложных срезов
 # li[начало:конец:шаг]
 
 # Удаляем произвольные элементы из списка оператором del
-del li[2] # [1, 2, 3]
+del li[2] # li теперь [1, 2, 3]
 
-# Вы можете складывать списки
+# Вы можете складывать, или, как ещё говорят, конкатенировать списки
 li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
+# Обратите внимание: значения li и other_li при этом не изменились.
 
 # Объединять списки можно методом extend
 li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
@@ -226,7 +244,8 @@ empty_dict = {}
 # Вот так описывается предзаполненный словарь
 filled_dict = {"one": 1, "two": 2, "three": 3}
 
-# Значения ищутся по ключу с помощью оператора []
+# Значения извлекаются так же, как из списка, с той лишь разницей,
+# что индекс — у словарей он называется ключом — не обязан быть числом
 filled_dict["one"] #=> 1
 
 # Можно получить все ключи в виде списка с помощью метода keys
@@ -245,24 +264,33 @@ filled_dict.values() #=> [3, 2, 1]
 # Попытка получить значение по несуществующему ключу выбросит ошибку ключа
 filled_dict["four"] # KeyError
 
-# Чтобы избежать этого, используйте метод get
+# Чтобы избежать этого, используйте метод get()
 filled_dict.get("one") #=> 1
 filled_dict.get("four") #=> None
 # Метод get также принимает аргумент по умолчанию, значение которого будет
 # возвращено при отсутствии указанного ключа
 filled_dict.get("one", 4) #=> 1
 filled_dict.get("four", 4) #=> 4
+# Обратите внимание, что filled_dict.get("four") всё ещё => None
+# (get не устанавливает значение элемента словаря)
 
-# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
+# Присваивайте значение ключам так же, как и в списках
+filled_dict["four"] = 4  # теперь filled_dict["four"] => 4
+
+# Метод setdefault вставляет() пару ключ-значение, только если такого ключа нет
 filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
 
 
 # Множества содержат... ну, в общем, множества
+# (которые похожи на списки, только в них не может быть дублирующихся элементов)
 empty_set = set()
 # Инициализация множества набором значений
 some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4])
 
+# Порядок сортировки не гарантируется, хотя иногда они выглядят отсортированными
+another_set = set([4, 3, 2, 2, 1])  # another_set теперь set([1, 2, 3, 4])
+
 # Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество
 filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
 
@@ -345,7 +373,7 @@ try:
     # Чтобы выбросить ошибку, используется raise
     raise IndexError("Это ошибка индекса")
 except IndexError as e:
-    # pass это просто отсутствие оператора. Обычно здесь происходит
+    # pass — это просто отсутствие оператора. Обычно здесь происходит
     # восстановление после ошибки.
     pass
 except (TypeError, NameError):
@@ -362,7 +390,7 @@ else:   # Необязательное выражение. Должно след
 # Используйте def для создания новых функций
 def add(x, y):
     print("x равен %s, а y равен %s" % (x, y))
-    return x + y    # Возвращайте результат выражением return
+    return x + y    # Возвращайте результат с помощью ключевого слова return
 
 # Вызов функции с аргументами
 add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11
@@ -370,15 +398,17 @@ add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвр
 # Другой способ вызова функции — вызов с именованными аргументами
 add(y=6, x=5)   # Именованные аргументы можно указывать в любом порядке.
 
-# Вы можете определить функцию, принимающую изменяемое число аргументов
+# Вы можете определить функцию, принимающую переменное число аргументов,
+# которые будут интерпретированы как кортеж, если вы не используете *
 def varargs(*args):
     return args
 
 varargs(1, 2, 3) #=> (1,2,3)
 
 
-# А также можете определить функцию, принимающую изменяемое число
+# А также можете определить функцию, принимающую переменное число
-# именованных аргументов
+# именованных аргументов, которые будут интерпретированы как словарь,
+# если вы не используете **
 def keyword_args(**kwargs):
     return kwargs
 
@@ -396,13 +426,21 @@ all_the_args(1, 2, a=3, b=4) выводит:
 """
 
 # Вызывая функции, можете сделать наоборот!
-# Используйте символ * для передачи кортежей и ** для передачи словарей
+# Используйте символ * для распаковки кортежей и ** для распаковки словарей
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
 all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
 all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
 all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
 
+# вы можете передавать переменное число позиционных или именованных аргументов
+# другим функциям, которые их принимают, распаковывая их с помощью
+# * или ** соответственно
+def pass_all_the_args(*args, **kwargs):
+    all_the_args(*args, **kwargs)
+    print varargs(*args)
+    print keyword_args(**kwargs)
+
 # Область определения функций
 x = 5
 
@@ -420,7 +458,7 @@ def setGlobalX(num):
 setX(43)
 setGlobalX(6)
 
-# В Python есть функции первого класса
+# В Python функции — «объекты первого класса»
 def create_adder(x):
     def adder(y):
         return x + y
@@ -514,6 +552,9 @@ from math import *
 # Можете сокращать имена модулей
 import math as m
 math.sqrt(16) == m.sqrt(16) #=> True
+# Вы также можете убедиться, что функции эквивалентны
+from math import sqrt
+math.sqrt == m.sqrt == sqrt  # => True
 
 # Модули в Python — это обычные Python-файлы. Вы
 # можете писать свои модули и импортировать их. Название
@@ -544,7 +585,7 @@ def double_numbers(iterable):
 # мы используем подчёркивание в конце
 xrange_ = xrange(1, 900000000)
 
-# Будет удваивать все числа, пока результат не будет >= 30
+# Будет удваивать все числа, пока результат не превысит 30
 for i in double_numbers(xrange_):
     print(i)
     if i >= 30:

ru-ru/python3-ru.html.markdown

@@ -10,7 +10,7 @@ filename: learnpython3-ru.py
 ---
 
 Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
-самых популярных языков. Я люблю его за понятный и доходчивый синтаксис  — это
+самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис  — это
 почти что исполняемый псевдокод.
 
 С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
@@ -56,7 +56,7 @@ filename: learnpython3-ru.py
 7 % 3 # => 1
 
 # Возведение в степень
-2 ** 4 # => 16
+2**4 # => 16
 
 # Приоритет операций указывается скобками
 (1 + 3) * 2 #=> 8
@@ -69,6 +69,18 @@ False
 not True #=> False
 not False #=> True
 
+# Логические операторы
+# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
+True and False #=> False
+False or True #=> True
+
+# Обратите внимание, что логические операторы используются и с целыми числами
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
 # Равенство — это ==
 1 == 1 #=> True
 2 == 1 #=> False
@@ -91,7 +103,7 @@ not False #=> True
 "Это строка."
 'Это тоже строка.'
 
-# И строки тоже могут складываться! Хотя лучше этого не делайте.
+# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим.
 "Привет " + "мир!" #=> "Привет мир!"
 
 # Со строкой можно работать, как со списком символов
@@ -134,10 +146,10 @@ bool({}) #=> False
 ## 2. Переменные и коллекции
 ####################################################
 
-# У Python есть функция Print
+# В Python есть функция Print
 print("Я Python. Приятно познакомиться!")
 
-# Необязательно объявлять переменные перед их инициализацией.
+# Объявлять переменные перед инициализацией не нужно.
 # По соглашению используется нижний_регистр_с_подчёркиваниями
 some_var = 5
 some_var #=> 5
@@ -149,7 +161,7 @@ some_unknown_var  # Выбрасывает ошибку именования
 
 # Списки хранят последовательности
 li = []
-# Можно сразу начать с заполненным списком
+# Можно сразу начать с заполненного списка
 other_li = [4, 5, 6]
 
 # Объекты добавляются в конец списка методом append
@@ -170,7 +182,7 @@ li[-1] #=> 3
 # Попытка выйти за границы массива приведёт к ошибке индекса
 li[4] # Выдаёт IndexError
 
-# Можно обращаться к диапазону, используя "кусочный синтаксис" (slice syntax)
+# Можно обращаться к диапазону, используя так называемые срезы
 # (Для тех, кто любит математику, это называется замкнуто-открытый интервал).
 li[1:3] #=> [2, 4]
 # Опускаем начало
@@ -181,13 +193,14 @@ li[:3] #=> [1, 2, 4]
 li[::2]   # =>[1, 4]
 # Переворачиваем список
 li[::-1]   # => [3, 4, 2, 1]
-# Используйте сочетания всего вышеназванного для выделения более сложных кусков
+# Используйте сочетания всего вышеназванного для выделения более сложных срезов
 # li[начало:конец:шаг]
 
 # Удаляем произвольные элементы из списка оператором del
 del li[2] # [1, 2, 3]
 
-# Вы можете складывать списки
+# Вы можете складывать, или, как ещё говорят, конкатенировать списки
+# Обратите внимание: значения li и other_li при этом не изменились.
 li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
 
 # Объединять списки можно методом extend
@@ -224,10 +237,11 @@ empty_dict = {}
 # Вот так описывается предзаполненный словарь
 filled_dict = {"one": 1, "two": 2, "three": 3}
 
-# Значения ищутся по ключу с помощью оператора []
+# Значения извлекаются так же, как из списка, с той лишь разницей,
+# что индекс — у словарей он называется ключом — не обязан быть числом
 filled_dict["one"] #=> 1
 
-# Все значения в виде списка получаются с помощью метода keys(). 
+# Все ключи в виде списка получаются с помощью метода keys(). 
 # Его вызов нужно обернуть в list(), так как обратно мы получаем
 # итерируемый объект, о которых поговорим позднее.
 list(filled_dict.keys())   # => ["three", "two", "one"]
@@ -247,7 +261,7 @@ list(filled_dict.values())   # => [3, 2, 1]
 # Попытка получить значение по несуществующему ключу выбросит ошибку ключа
 filled_dict["four"] # KeyError
 
-# Чтобы избежать этого, используйте метод get
+# Чтобы избежать этого, используйте метод get()
 filled_dict.get("one") #=> 1
 filled_dict.get("four") #=> None
 # Метод get также принимает аргумент по умолчанию, значение которого будет
@@ -259,6 +273,10 @@ filled_dict.get("four", 4) #=> 4
 filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
 
+# Добавление элементов в словарь
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  # Другой способ добавления элементов
+
 # Удаляйте ключи из словаря с помощью оператора del
 del filled_dict["one"]  # Удаляет ключ «one» из словаря
 
@@ -345,7 +363,7 @@ try:
     # Чтобы выбросить ошибку, используется raise
     raise IndexError("Это ошибка индекса")
 except IndexError as e:
-    # pass это просто отсутствие оператора. Обычно здесь происходит
+    # pass — это просто отсутствие оператора. Обычно здесь происходит
     # восстановление после ошибки.
     pass
 except (TypeError, NameError):
@@ -393,7 +411,7 @@ list(filled_dict.keys())  #=> Возвращает ["one", "two", "three"]
 # Используйте def для создания новых функций
 def add(x, y):
     print("x равен %s, а y равен %s" % (x, y))
-    return x + y    # Возвращайте результат выражением return
+    return x + y    # Возвращайте результат с помощью ключевого слова return
 
 # Вызов функции с аргументами
 add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11
@@ -401,14 +419,14 @@ add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвр
 # Другой способ вызова функции — вызов с именованными аргументами
 add(y=6, x=5)   # Именованные аргументы можно указывать в любом порядке.
 
-# Вы можете определить функцию, принимающую изменяемое число аргументов
+# Вы можете определить функцию, принимающую переменное число аргументов
 def varargs(*args):
     return args
 
 varargs(1, 2, 3) #=> (1,2,3)
 
 
-# А также можете определить функцию, принимающую изменяемое число
+# А также можете определить функцию, принимающую переменное число
 # именованных аргументов
 def keyword_args(**kwargs):
     return kwargs
@@ -427,7 +445,7 @@ all_the_args(1, 2, a=3, b=4) выводит:
 """
 
 # Вызывая функции, можете сделать наоборот!
-# Используйте символ * для передачи кортежей и ** для передачи словарей
+# Используйте символ * для распаковки кортежей и ** для распаковки словарей
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
 all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
@@ -451,7 +469,7 @@ def setGlobalX(num):
 setX(43)
 setGlobalX(6)
 
-# В Python функции — «объекты первого класса». Это означает, что их можно использовать наравне с любыми другими значениями
+# В Python функции — «объекты первого класса»
 def create_adder(x):
     def adder(y):
         return x + y

ru-ru/swift-ru.html.markdown

@@ -9,11 +9,11 @@ translators:
 lang: ru-ru
 ---
 
-Swift - это язык программирования, созданный компанией Apple, для разработки
+Swift - это язык программирования, созданный компанией Apple, для приложений
-приложений iOS и OS X. Разработанный, чтобы сосуществовать с Objective-C и
+под iOS и OS X. Разработанный, чтобы сосуществовать с Objective-C и
 быть более устойчивым к ошибочному коду, Swift был представлен в 2014 году на
 конференции разработчиков Apple, WWDC. Приложения на Swift собираются
-с помощью LLVM компилятора, включенного в Xcode 6+.
+с помощью LLVM-компилятора, включенного в Xcode 6+.
 
 Официальная книга по [языку программирования Swift](https://itunes.apple.com/us/book/swift-programming-language/id881256329) от Apple доступна в iBooks.
 
@@ -27,7 +27,7 @@ import UIKit
 // MARK: Основы
 //
 
-// Xcode поддерживает заметные маркеры, чтобы давать примечания свою коду
+// Xcode поддерживает маркеры, чтобы давать примечания своему коду
 // и вносить их в список обозревателя (Jump Bar)
 // MARK: Метка раздела
 // TODO: Сделайте что-нибудь вскоре
@@ -44,7 +44,7 @@ let π = 3.1415926
 let convenience = "Ключевое слово" // контекстное имя переменной
 let weak = "Ключевое слово"; let override = "еще ключевое слово" // операторы
                                       // могут быть отделены точкой с запятой
-let `class` = "Ключевое слово" // одинарные кавычки позволяют использовать
+let `class` = "Ключевое слово" // обратные апострофы позволяют использовать
                                // ключевые слова в именовании переменных
 let explicitDouble: Double = 70
 let intValue = 0007 // 7
@@ -63,17 +63,17 @@ let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Вставка переменны
 println("Значение сборки: \(buildValue)") // Значение сборки: 7
 
 /*
-    Optional - это особенность языка Swift, которая допускает вам сохранять
+    Опционалы - это особенность языка Swift, которая допускает вам сохранять
     `некоторое` или `никакое` значения.
 
     Язык Swift требует, чтобы каждое свойство имело значение, поэтому даже nil
-    должен явно сохранен как Optional значение.
+    должен быть явно сохранен как опциональное значение.
 
     Optional<T> является перечислением.
 */
-var someOptionalString: String? = "optional" // Может быть nil
+var someOptionalString: String? = "опционал" // Может быть nil
-// как и выше, только ? это постфиксный оператор (синтаксический сахар)
+// как и выше, только ? - это постфиксный оператор (синтаксический сахар)
-var someOptionalString2: Optional<String> = "optional"
+var someOptionalString2: Optional<String> = "опционал"
 
 if someOptionalString != nil {
     // я не nil
@@ -85,9 +85,9 @@ if someOptionalString != nil {
 }
 someOptionalString = nil
 
-// неявная развертка переменной Optional
+// неявная развертка опциональной переменной
 var unwrappedString: String! = "Ожидаемое значение."
-// как и выше, только ! постфиксный оператор (с еще одним синтаксическим сахаром)
+// как и выше, только ! - постфиксный оператор (с еще одним синтаксическим сахаром)
 var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Ожидаемое значение."
 
 if let someOptionalStringConstant = someOptionalString {
@@ -97,7 +97,7 @@ if let someOptionalStringConstant = someOptionalString {
     }
 }
 
-// Swift поддерживает сохранение значение любого типа
+// Swift поддерживает сохранение значения любого типа
 // AnyObject == id
 // В отличие от `id` в Objective-C, AnyObject работает с любым значением (Class,
 // Int, struct и т.д.)
@@ -119,7 +119,7 @@ anyObjectVar = "Изменять значение на строку не явл
 /*
     Массив (Array) и словарь (Dictionary) являются структурами (struct). Так
     `let` и `var` также означают, что они изменяются (var) или не изменяются (let)
-    при объявлении типов.
+    при объявлении переменных этих типов.
 */
 
 // Массив
@@ -186,13 +186,13 @@ do {
 let vegetable = "красный перец"
 switch vegetable {
 case "сельдерей":
-    let vegetableComment = "Добавьте немного изюма и make ants on a log."
+    let vegetableComment = "Добавьте немного изюма, имитируя муравьев на бревнышке."
-case "огурец", "жеруха":
+case "огурец", "кресс-салат":
     let vegetableComment = "Было бы неплохо сделать бутерброд с чаем."
 case let localScopeValue where localScopeValue.hasSuffix("перец"):
     let vegetableComment = "Это острый \(localScopeValue)?"
-default: // обязательный (чтобы преодолеть все возможные вхождения)
+default: // обязательный (чтобы предусмотреть все возможные вхождения)
-    let vegetableComment = "Все вкусы хороши для супа."
+    let vegetableComment = "В супе все овощи вкусные."
 }
 
 
@@ -208,8 +208,8 @@ default: // обязательный (чтобы преодолеть все в
 /**
     Операция приветствия
 
-    - Жирная метка в документировании
+    - Маркер в документировании
-    - Еще одна жирная метка в документации
+    - Еще один маркер в документации
 
     :param: name - это имя
     :param: day - это день
@@ -289,7 +289,7 @@ numbers = numbers.map({ number in 3 * number })
 
 print(numbers) // [3, 6, 18]
 
-// Упрощение замыкания
+// Хвостовое замыкание
 numbers = sorted(numbers) { $0 > $1 }
 
 print(numbers) // [18, 6, 3]
@@ -367,7 +367,7 @@ internal class Rect: Shape {
     
     init(sideLength: Int) {
         self.sideLength = sideLength
-        // всегда вызывается super.init последним, когда init с параметрами
+        // последним всегда вызывается super.init, когда init с параметрами
         super.init()
     }
     
@@ -397,7 +397,7 @@ print(mySquare.sideLength) // 4
 // преобразование объектов
 let aShape = mySquare as Shape
 
-// сравнение объектов, но не как операция ==, которая проверяет эквивалентность
+// сравнение экземпляров, в отличие от ==, которая проверяет эквивалентность
 if mySquare === mySquare {
     println("Ага, это mySquare")
 }
@@ -422,14 +422,14 @@ enum Suit {
     }
 }
 
-// Значения перечислений допускают жесткий синтаксис, нет необходимости
+// Значения перечислений допускают сокращенный синтаксис, нет необходимости
 // указывать тип перечисления, когда переменная объявляется явно
 var suitValue: Suit = .Hearts
 
 // Нецелочисленные перечисления требуют прямого указания значений
 enum BookName: String {
-    case John = "John"
+    case John = "Иоанн"
-    case Luke = "Luke"
+    case Luke = "Лука"
 }
 println("Имя: \(BookName.John.rawValue)")
 
@@ -459,7 +459,9 @@ class MyShape: Rect {
     
     func grow() {
         sideLength += 2
-        
+        // Размещайте знак вопроса перед опционным свойством, методом
+        // или индексом, чтобы не учитывать nil-значение и возвратить nil
+        // вместо выбрасывания ошибки выполнения (т.н. "опционная цепочка")
         if let allow = self.delegate?.canReshape?() {
             // проверка делегата на выполнение метода
             self.delegate?.reshaped?()