Merge pull request #3943 from dvska/patch-1

Deeper translation

1 files changed, 130 insertions, 124 deletions

diff --git a/ru-ru/nim-ru.html.markdown b/ru-ru/nim-ru.html.markdown
index d05583d7..0e08f1bf 100644
--- a/ru-ru/nim-ru.html.markdown
+++ b/ru-ru/nim-ru.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Dennis Felsing", "http://felsin9.de/nnis/"]
 translators:
     - ["Nomadic", "https://github.com/n0madic"]
+    - ["dvska", "https://github.com/dvska"]
 lang: ru-ru
 ---
 
@@ -16,25 +17,25 @@ Nim (ранее известный, как Nimrod) — язык программ
 Nim эффективный, выразительный и элегантный.
 
 ```nim
-var                     # Объявление (и присваивание) переменных,
-  letter: char = 'n'    # с указанием типа или без
-  lang = "N" & "im"
-  nLength : int = len(lang)
+var                    # Объявление (и присваивание) переменных,
+  буква: char = 'n'    # с указанием типа или без
+  язык = "N" & "im"
+  nLength : int = len(язык)
   boat: float
-  truth: bool = false
+  правда: bool = false
 
-let            # Используйте let *сразу* для объявления и связывания переменных.
-  legs = 400   # legs неизменяемый.
-  arms = 2_000 # Символ _ игнорируется и удобен для длинных чисел.
-  aboutPi = 3.15
+let              # Используйте let *сразу* для объявления и связывания переменных.
+  ноги = 400     # ноги неизменяемый.
+  руки = 2_000   # Символ _ игнорируется и удобен для длинных чисел.
+  почтиПи = 3.15
 
 const            # Константы вычисляются во время компиляции. Это обеспечивает
   debug = true   # производительность и полезно в выражениях этапа компиляции.
-  compileBadCode = false
+  компилироватьПлохойКод = false
 
-when compileBadCode:            # `when` это `if` этапа компиляции.
-  legs = legs + 1               # Эта ошибка никогда не будет скомпилирована.
-  const input = readline(stdin) # Значения констант должны быть известны во
+when компилироватьПлохойКод:    # `when` это `if` этапа компиляции.
+  ноги = ноги + 1               # Эта ошибка никогда не будет скомпилирована.
+  const ввод = readline(stdin)  # Значения констант должны быть известны во
                                 # время компиляции.
 
 discard 1 > 2 # Примечание. Компилятор будет жаловаться, если результат
@@ -52,27 +53,27 @@ discard """
 # Кортежи
 
 var
-  child: tuple[name: string, age: int]   # Кортежи определяют *как* имя поля
-  today: tuple[sun: string, temp: float] # так *и* порядок полей.
+  дитя: tuple[имя: string, возраст: int]             # Кортежи определяют *как* имя поля
+  сегодня: tuple[солнце: string, температура: float] # так *и* порядок полей.
 
-child = (name: "Rudiger", age: 2) # Присвоить все сразу литералом ()
-today.sun = "Overcast"            # или отдельно по полям.
-today.temp = 70.1
+дитя = (имя: "Rudiger", возраст: 2) # Присвоить все сразу литералом ()
+сегодня.солнце = "Пасмурно"         # или отдельно по полям.
+сегодня.температура = 20.1
 
 # Последовательности
 
 var
-  drinks: seq[string]
+  напитки: seq[string]
 
-drinks = @["Water", "Juice", "Chocolate"] # @[V1,..,Vn] является литералом
-                                          # последовательности
+напитки = @["Вода", "Сок", "Какао"] # @[V1,..,Vn] является литералом
+                                    # последовательности
 
-drinks.add("Milk")
+напитки.add("Молоко")
 
-if "Milk" in drinks:
-  echo "We have Milk and ", drinks.len - 1, " other drinks"
+if "Молоко" in напитки:
+  echo "У нас тут Молоко и ещё", напитки.len - 1, " напиток(ов)"
 
-let myDrink = drinks[2]
+let мойНапиток = напитки[2]
 
 #
 # Определение типов
@@ -82,30 +83,30 @@ let myDrink = drinks[2]
 # Это то, что делает статическую типизацию мощной и полезной.
 
 type
-  Name = string # Псевдоним типа дает вам новый тип, который равнозначен
-  Age = int     # старому типу, но более нагляден.
-  Person = tuple[name: Name, age: Age] # Определение структур данных.
-  AnotherSyntax = tuple
+  Имя = string      # Псевдоним типа дает вам новый тип, который равнозначен
+  Возраст = int     # старому типу, но более нагляден.
+  Человек = tuple[имя: Имя, возраст: Возраст] # Определение структур данных.
+  АльтернативныйСинтаксис = tuple
     fieldOne: string
     secondField: int
 
 var
-  john: Person = (name: "John B.", age: 17)
-  newage: int = 18 # Было бы лучше использовать Age, чем int
+  джон: Человек = (имя: "John B.", возраст: 17)
+  новыйВозраст: int = 18 # Было бы лучше использовать Возраст, чем int
 
-john.age = newage # Но это все же работает, потому что int и Age синонимы.
+джон.возраст = новыйВозраст # Но это все же работает, потому что int и Возраст синонимы.
 
 type
-  Cash = distinct int    # `distinct` делает новый тип несовместимым с его
-  Desc = distinct string # базовым типом.
+  Нал = distinct int          # `distinct` делает новый тип несовместимым с его
+  Описание = distinct string  # базовым типом.
 
 var
-  money: Cash = 100.Cash # `.Cash` преобразует int в наш тип
-  description: Desc  = "Interesting".Desc
+  money: Нал = 100.Нал   # `.Нал` преобразует int в наш тип
+  описание: Описание  = "Interesting".Описание
 
-when compileBadCode:
-  john.age  = money        # Error! age is of type int and money is Cash
-  john.name = description  # Компилятор говорит: "Нельзя!"
+when компилироватьПлохойКод:
+  джон.возраст  = money       # Error! возраст is of type int and money is Нал
+  джон.имя = описание         # Компилятор говорит: "Нельзя!"
 
 #
 # Дополнительные типы и структуры данных
@@ -114,50 +115,50 @@ when compileBadCode:
 # Перечисления позволяют типу иметь одно из ограниченного числа значений
 
 type
-  Color = enum cRed, cBlue, cGreen
-  Direction = enum # Альтернативный формат
-    dNorth
-    dWest
-    dEast
-    dSouth
+  Цвет = enum цКрасный, цГолубой, цЗеленый
+  Направление = enum  # Альтернативный формат
+    нСевер
+    нЗапад
+    нВосток
+    нЮг
 var
-  orient = dNorth # `orient` имеет тип Direction, со значением `dNorth`
-  pixel = cGreen # `pixel` имеет тип Color, со значением `cGreen`
+  напр = нСевер     # `напр` имеет тип Направление, со значением `нСевер`
+  точка = цЗеленый  # `точка` имеет тип Цвет, со значением `цЗеленый`
 
-discard dNorth > dEast # Перечисления обычно являются "порядковыми" типами
+discard нСевер > нВосток  # Перечисления обычно являются "порядковыми" типами
 
 # Поддиапазоны определяют ограниченный допустимый диапазон
 
 type
-  DieFaces = range[1..20] # Допустимым значением являются только int от 1 до 20
+  Кости = range[1..20]  # 🎲 Допустимым значением являются только int от 1 до 20
 var
-  my_roll: DieFaces = 13
+  мой_бросок: Кости = 13
 
-when compileBadCode:
-  my_roll = 23 # Error!
+when компилироватьПлохойКод:
+  мой_бросок = 23  # Error!
 
-# Arrays
+# Массивы
 
 type
-  RollCounter = array[DieFaces, int]  # Массивы фиксированной длины и
-  DirNames = array[Direction, string] # индексируются любым порядковым типом.
-  Truths = array[42..44, bool]
+  СчетчикБросков = array[Кости, int]             # Массивы фиксированной длины и
+  ИменаНаправлений = array[Направление, string]  # индексируются любым порядковым типом.
+  Истины = array[42..44, bool]
 var
-  counter: RollCounter
-  directions: DirNames
-  possible: Truths
+  счетчик: СчетчикБросков
+  направления: ИменаНаправлений
+  возможны: Истины
 
-possible = [false, false, false] # Массивы создаются литералом [V1,..,Vn]
-possible[42] = true
+возможны = [false, false, false]  # Массивы создаются литералом [V1,..,Vn]
+возможны[42] = true
 
-directions[dNorth] = "Ahh. The Great White North!"
-directions[dWest] = "No, don't go there."
+направления[нСевер] = "ОО. Великий белый Север!"
+направления[нЗапад] = "Нет, не иди туда."
 
-my_roll = 13
-counter[my_roll] += 1
-counter[my_roll] += 1
+мой_бросок = 13
+счетчик[мой_бросок] += 1
+счетчик[мой_бросок] += 1
 
-var anotherArray = ["Default index", "starts at", "0"]
+var ещеМассив = ["Идекс по умолчанию", "начинается с", "0"]
 
 # Доступны другие структуры данных, в том числе таблицы, множества,
 # списки, очереди и crit-bit деревья.
@@ -169,89 +170,94 @@ var anotherArray = ["Default index", "starts at", "0"]
 
 # `case`, `readLine()`
 
-echo "Read any good books lately?"
+echo "Читали какие-нибудь хорошие книги в последнее время?"
+
 case readLine(stdin)
-of "no", "No":
-  echo "Go to your local library."
-of "yes", "Yes":
-  echo "Carry on, then."
+of "нет", "Нет":
+  echo "Пойдите в свою местную библиотеку."
+of "да", "Да":
+  echo "Тогда продолжим"
 else:
-  echo "That's great; I assume."
+  echo "Здорово!"
 
 # `while`, `if`, `continue`, `break`
 
-import strutils as str # http://nim-lang.org/docs/strutils.html (EN)
-echo "I'm thinking of a number between 41 and 43. Guess which!"
-let number: int = 42
+import strutils as str  # http://nim-lang.org/docs/strutils.html (EN)
+echo "Я загадало число между 41 и 43. Отгадай!"
+let число: int = 42
 var
-  raw_guess: string
-  guess: int
-while guess != number:
-  raw_guess = readLine(stdin)
-  if raw_guess == "": continue # Пропустить эту итерацию
-  guess = str.parseInt(raw_guess)
-  if guess == 1001:
+  ввод_догадка: string
+  догадка: int
+
+while догадка != число:
+  ввод_догадка = readLine(stdin)
+
+  if ввод_догадка == "": continue  # Пропустить эту итерацию
+  
+  догадка = str.parseInt(ввод_догадка)
+
+  if догадка == 1001:
     echo("AAAAAAGGG!")
     break
-  elif guess > number:
-    echo("Nope. Too high.")
-  elif guess < number:
-    echo(guess, " is too low")
+  elif догадка > число:
+    echo("Неа. Слишком большое.")
+  elif догадка < число:
+    echo(догадка, " это слишком мало")
   else:
-    echo("Yeeeeeehaw!")
+    echo("Точнооооо!")
 
 #
 # Итерации (циклы)
 #
 
-for i, elem in ["Yes", "No", "Maybe so"]: # Или просто `for elem in`
-  echo(elem, " is at index: ", i)
+for i, элем in ["Да", "Нет", "Может быть"]:  # Или просто `for элем in`
+  echo(элем, " по индексу: ", i)
 
-for k, v in items(@[(person: "You", power: 100), (person: "Me", power: 9000)]):
-  echo v
+for ключ, значение in items(@[(человек: "You", сила: 100), (человек: "Me", сила: 9000)]):
+  echo значение
 
-let myString = """
-an <example>
-`string` to
-play with
+let мояСтрока = """
+<пример>
+`строки` для
+тренировки
 """ # Многострочная "сырая" строка
 
-for line in splitLines(myString):
-  echo(line)
+for строка in splitLines(мояСтрока):
+  echo(строка)
 
-for i, c in myString:       # Индекс и символ. Или `for j in` только для символов
-  if i mod 2 == 0: continue # Компактная форма `if`
-  elif c == 'X': break
-  else: echo(c)
+for i, симв in мояСтрока:     # Индекс и символ. Или `for j in` только для символов
+  if i mod 2 == 0: continue   # Компактная форма `if`
+  elif симв == 'X': break
+  else: echo(симв)
 
 #
 # Процедуры
 #
 
-type Answer = enum aYes, aNo
+type Ответ = enum оДа, оНет
 
-proc ask(question: string): Answer =
-  echo(question, " (y/n)")
+proc спрос(вопрос: string): Ответ =
+  echo(вопрос, " (д/н)")
   while true:
     case readLine(stdin)
-    of "y", "Y", "yes", "Yes":
-      return Answer.aYes  # Перечисления могут быть квалифицированы
-    of "n", "N", "no", "No":
-      return Answer.aNo
-    else: echo("Please be clear: yes or no")
-
-proc addSugar(amount: int = 2) = # Значение поумолчанию 2, ничего не возвращает
-  assert(amount > 0 and amount < 9000, "Crazy Sugar")
-  for a in 1..amount:
-    echo(a, " sugar...")
-
-case ask("Would you like sugar in your tea?")
-of aYes:
-  addSugar(3)
-of aNo:
-  echo "Oh do take a little!"
-  addSugar()
-# Здесь нет необходимости в `else`. Возможны только `yes` и `no`.
+    of "д", "Д", "да", "Да":
+      return Ответ.оДа  # Перечисления могут быть квалифицированы
+    of "н", "Н", "нет", "Нет":
+      return Ответ.оНет
+    else: echo("Поточнее, да или нет")
+
+proc добавьСахар(количество: int = 2) =   # Значение по умолчанию 2, ничего не возвращает
+  assert(количество > 0 and количество < 9000, "Диабет ☠")
+  for a in 1..количество:
+    echo(a, " кубик...")
+
+case спрос("Сахарку?")
+of оДа:
+  добавьСахар(3)
+of оНет:
+  echo "Ну немнооожко!"
+  добавьСахар()
+# Здесь нет необходимости в `else`. Возможны только `да` и `нет`.
 
 #
 # FFI (интерфейс внешних функций)
@@ -261,7 +267,7 @@ of aNo:
 
 proc strcmp(a, b: cstring): cint {.importc: "strcmp", nodecl.}
 
-let cmp = strcmp("C?", "Easy!")
+let cmp = strcmp("C?", "Легко!")
 ```
 
 Кроме того, Nim выделяется среди себе подобных метапрограммированием,