From 10405c42fdbcfa97f856c1de5237cfc5e313cf2d Mon Sep 17 00:00:00 2001
From: Volodymyr Korniichuk <9173519@gmail.com>
Date: Sun, 1 Sep 2019 10:55:27 +0300
Subject: Added translation for [Rust/uk-ua] (#3613)

* Added uk-ua tranlation for Rust

* fixed lang

* fixed "80-symbols per line" limit

* Fix filename
---
 uk-ua/rust-ua.html.markdown | 331 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 331 insertions(+)
 create mode 100644 uk-ua/rust-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/rust-ua.html.markdown b/uk-ua/rust-ua.html.markdown
new file mode 100644
index 00000000..4ec2b7c9
--- /dev/null
+++ b/uk-ua/rust-ua.html.markdown
@@ -0,0 +1,331 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+  - ["Volodymyr Korniichuk", "https://github.com/ezhikus"]
+filename: learnrust-uk.rs
+lang: uk-ua
+---
+
+Rust - це мова програмування, що розрабляється спільнотою Mozilla Research
+Rust поєднує в собі низькорівневий контроль швидкодії з високорівневими 
+інструментами забезпечення гарантій цілісності та безпеки.
+
+Rust досягає своїх цілей без автоматичного збирання сміття і не вимагає 
+наявності певного середовища виконання, що робить можливим пряму заміну 
+бібліотек, написаних на мові С на бібліотеки, написані на Rust.
+
+Перший реліз Rust (версія 0.1) вийшла в січні 2012 року і з тих пір оновлення 
+виходили так часто, що загальною порадою розробникам було не чекати якоїсь 
+стабільної версії, а використовувати нічні збірки компілятора.
+
+15 травня 2015 року вийшла версія Rust 1.0. Для цієї версії була дана гарантія
+зворотної сумісності. Подальші нічні збірки покращили швидкість компіляції та
+деякі інші аспекти. На даний момент оновлення Rust виходять кожні 6 тижнів.
+Бета-версія Rust 1.1 вийшла одночасно з релізом Rust 1.0.
+
+Не зважаючи на те, що Rust є відносно низькорівневою мовою програмування, в
+ній є деякі концепти, притаманні високорівневим мовам. Це робить Rust не лише
+швидким, але й досить зручним та ефективним інструментом розробки.
+
+```rust
+// Це коментар. Він починається в цьому рядку...
+// і продовжується в цьому
+
+/// Цей коментар включає в себе документацію і підтримує markdown.
+/// # Приклади
+///
+/// ```
+/// let five = 5
+/// ```
+
+///////////////
+// 1. Основи //
+///////////////
+
+#[allow(dead_code)]
+// Функції
+// `i32` - це 32-бітний цілочислений знаковий тип даних
+fn add2(x: i32, y: i32) -> i32 {
+    // неявне повернення результату (в кінці рядку немає крапки з комою)
+    x + y
+}
+
+#[allow(unused_variables)]
+#[allow(unused_assignments)]
+#[allow(dead_code)]
+// Головна функція
+fn main() {
+    // Числа //
+
+    // Незмінне число
+    let x: i32 = 1;
+
+    // суфікси для позначення цілого числа та числа з плаваючою змінною
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Вивід типів
+    // Як правило, Rust може самостійно визначити тип змінної, отож
+    // ви можете не прописувати його явно
+    // В даному документі типи явно прописані в багатьох місцях, це зроблено 
+    // виключно в навчальних цілях. В реальному коді вивід типів спрацює 
+    // в більшості випадків
+    let implicit_x = 1;
+    let implicit_f = 1.3;
+
+    // арифметика
+    let sum = x + y + 13;
+
+    // Змінні
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Строки //
+
+    // Строкові літерали
+    let x: &str = "Привіт, світ!";
+
+    // Друк на екран
+    println!("{} {}", f, x); // 1.3 Привіт, світ!
+
+    // `String` – строка, що розміщується в "купі"
+    let s: String = "hello world".to_string();
+
+    // Строковий зріз - це незмінне відображення якоїсь строки (або її частини)
+    // Зріз можна розглядати як константну пару покажчиків (на початок та кінець
+    // якоїсь строки)
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // Привіт, світ! Привіт, світ!
+
+    // Вектори/масиви //
+
+    // Масив фіксованого розміру
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Масив змінного розміру (вектор)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Зріз - незмінне відображення масиву
+    // Це схоже на строковий зріз, але в даному випадку мова йде про вектори
+    let slice: &[i32] = &vector;
+
+    // Використовуйте `{:?}` щоб вивести щось в цілях відлагодження
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Кортеж //
+
+    // Кортеж - це набір фіксованого розміру, що включає значення кількох типів
+    let x: (i32, &str, f64) = (1, "привіт", 3.4);
+
+    // розбираємо кортеж "х" на окремі змінні "a", "b" та "с"
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 привіт 3.4
+
+    // доступ по індексу
+    println!("{}", x.1); // привіт
+
+    //////////////
+    // 2. Типи //
+    //////////////
+
+    // Структура
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origin: Point = Point { x: 0, y: 0 };
+
+    // Структура з безіменними полями, "кортежна структура"
+    struct Point2(i32, i32);
+
+    let origin2 = Point2(0, 0);
+
+    // перелічуваний тип даних
+    enum Direction {
+        Left,
+        Right,
+        Up,
+        Down,
+    }
+
+    let up = Direction::Up;
+
+    // перелічуваний тип даних з полями
+    enum OptionalI32 {
+        AnI32(i32),
+        Nothing,
+    }
+
+    let two: OptionalI32 = OptionalI32::AnI32(2);
+    let nothing = OptionalI32::Nothing;
+
+    // Узагальнене програмування //
+
+    struct Foo<T> { bar: T }
+
+    // Ось так стандартна бібліотека Rust оголошує `Option`
+    enum Optional<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Методи //
+
+    impl<T> Foo<T> {
+        // Методи приймають неявний параметр `self`
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Типажі (в інших мовах програмування схожою сутністю є інтерфейси) //
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    /////////////////////////
+    // 3. Відповідність шаблону //
+    /////////////////////////
+
+    let foo = OptionalI32::AnI32(1);
+    match foo {
+        OptionalI32::AnI32(n) => println!("Це тип i32: {}", n),
+        OptionalI32::Nothing  => println!("Це ніщо!"),
+    }
+
+    // Складніший приклад
+    struct FooBar { x: i32, y: OptionalI32 }
+    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+            println!("Числа рівні нулю!"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+            println!("Числа однакові"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+            println!("Числа різні: {} {}", n, m),
+        FooBar { x: _, y: OptionalI32::Nothing } =>
+            println!("Друге число - ніщо!"),
+    }
+
+    /////////////////////
+    // 4. Потік керування //
+    /////////////////////
+
+    // Цикл `for` 
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Діапазони
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // друкує `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Математика працює!");
+    } else {
+        println!("Ой, лишенько...");
+    }
+
+    // `if` як вираз
+    let value = if true {
+        "добре"
+    } else {
+        "погано"
+    };
+
+    // Цикл `while`
+    while 1 == 1 {
+        println!("Всесвіт функціонує стабільно.");
+        // Вираз break перериває цикл
+        break
+    }
+
+    // Нескінченний цикл
+    loop {
+        println!("Привіт!");
+        // Вираз break перериває цикл
+        break
+    }
+
+    /////////////////////////////////
+    // 5. Вказівники і безпека пам'яті //
+    /////////////////////////////////
+
+    // Володіючий вказівник - тільки хтось один може "володіти" вказівником в 
+    // будь-який момент. Це означає, що коли "Box" вийде за межі області 
+    // видимості - його можна безпечно звільнити
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // розіменування `mine` з присвоєнням йому нового значення
+    // `now_its_mine` перебирає на себе володіння над `mine`. Іншими словами, 
+    // `mine` переміщується.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", mine); // цей код не скомпілюється, оскільки тепер 
+    // покажчиком на дані володіє `now_its_mine`
+
+    // Посилання – незмінний вказівник на дані
+    // При створенні посилання на якесь значення, ми говоримо, що значення 
+    // було "запозичене". Поки значення є запозиченим - воно не може бути 
+    // змінене або переміщене. Запозичення пропадає, як тільки стається вихід з 
+    // області видимості, де було створене посилання
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // На відміну від `mine`, `var` можна використати
+    println!("{}", *ref_var);
+    // var = 5; // цей код не скомпілюється, оскільки `var` зараз є запозиченим
+    // *ref_var = 6; // цей код також не зкомпілюється, оскільки `ref_var` 
+    // є незмінним посиланням
+
+    // Змінне посилання
+    // Значення можна запозичити з можливістю зміни. У цьому випадку доступ до 
+    // оригінального значення втрачається.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;    // '*' використовується для доступу до змінного посилання
+
+    println!("{}", *ref_var2); // 6 , // при заміні на var2 код не зкомпілюється
+    // ref_var2 має тип &mut i32, отож зберігає посилання на i32, а не  значення
+    // var2 = 2; // цей рядок не зкомпілюється, оскільки `var2` є запозиченим.
+}
+```
+
+## Матеріали для самовдосконалення
+
+В даному матеріалі ми оглянули лише основи Rust. Більше матеріалу ви можете 
+знайти на сайті 
+[The Rust Programming Language](http://doc.rust-lang.org/book/index.html)
+Також існує Reddit-розділ [/r/rust](http://reddit.com/r/rust). Люди на каналі
+irc.mozilla.org також завжди раді допомогти новачкам.
+
+Ви можете спробувати можливості Rust за допомогою онлайн-компілятора на сторінці
+[Rust playpen](http://play.rust-lang.org) або 
+[Rust website](http://rust-lang.org).
-- 
cgit v1.2.3


From 4fafc4a432ff9008db111d5f269464d5c67ce5a5 Mon Sep 17 00:00:00 2001
From: Oleh Hromiak <o.a.gromyak@gmail.com>
Date: Mon, 7 Oct 2019 17:18:34 +0300
Subject: Add [wasm/uk-ua] and update name in [python/uk-ua]

---
 uk-ua/python-ua.html.markdown |   2 +-
 uk-ua/wasm.html.markdown      | 225 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 226 insertions(+), 1 deletion(-)
 create mode 100644 uk-ua/wasm.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/python-ua.html.markdown b/uk-ua/python-ua.html.markdown
index 23bc1796..4091e433 100644
--- a/uk-ua/python-ua.html.markdown
+++ b/uk-ua/python-ua.html.markdown
@@ -9,7 +9,7 @@ contributors:
     - ["asyne", "https://github.com/justblah"]
     - ["habi", "http://github.com/habi"]
 translators:
-    - ["Oleg Gromyak", "https://github.com/ogroleg"]
+    - ["Oleh Hromiak", "https://github.com/ogroleg"]
 filename: learnpython-ua.py
 ---
 
diff --git a/uk-ua/wasm.html.markdown b/uk-ua/wasm.html.markdown
new file mode 100644
index 00000000..b5a1f4dd
--- /dev/null
+++ b/uk-ua/wasm.html.markdown
@@ -0,0 +1,225 @@
+---
+language: WebAssembly
+filename: learnwasm-ua.wast
+contributors:
+    - ["Dean Shaff", "http://dean-shaff.github.io"]
+translators:
+    - ["Oleh Hromiak", "https://github.com/ogroleg"]
+---
+
+```
+;; learnwasm-ua.wast
+
+(module
+  ;; У WebAssembly весь код знаходиться в модулях. Будь-яка операція
+  ;; може бути записана за допомогою s-виразу. Також існує синтаксис "стек машини",
+  ;; втім, він не сумісний з проміжним бінарним представленням коду.
+
+  ;; Формат бінарного проміжного представлення майже повністю сумісний 
+  ;; з текстовим форматом WebAssembly.
+  ;; Деякі відмінності:
+  ;; local_set -> local.set
+  ;; local_get -> local.get
+
+  ;; Код розміщується у функціях
+
+  ;; Типи даних
+  (func $data_types
+    ;; WebAssembly має чотири типи даних:
+    ;; i32 - ціле число, 32 біти
+    ;; i64 - ціле число, 64 біти (не підтримується у JavaScript)
+    ;; f32 - число з плаваючою комою, 32 біти
+    ;; f64 - число з плаваючою комою, 64 біти
+
+    ;; Створити локальну змінну можна за допомогою ключового слова "local".
+    ;; Змінні потрібно оголошувати на початку функції.
+
+    (local $int_32 i32)
+    (local $int_64 i64)
+    (local $float_32 f32)
+    (local $float_64 f64)
+
+    ;; Змінні, оголошені вище, ще не ініціалізовані, себто, не мають значення.
+    ;; Давайте присвоїмо їм значення за допомогою <тип даних>.const:
+
+    (local.set $int_32 (i32.const 16))
+    (local.set $int_32 (i64.const 128))
+    (local.set $float_32 (f32.const 3.14))
+    (local.set $float_64 (f64.const 1.28))
+  )
+
+  ;; Базові операції
+  (func $basic_operations
+
+    ;; Нагадаємо, у WebAssembly будь-що є s-виразом, включно
+    ;; з математичними виразами або зчитуванням значень змінних
+
+    (local $add_result i32)
+    (local $mult_result f64)
+
+    (local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
+    ;; тепер add_result дорівнює 6!
+
+    ;; Для кожної операції потрібно використовувати правильний тип:
+    ;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; Ніт! mult_result має тип f64!
+    (local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; Ніт! mult_result має тип f64!
+
+    ;; У WebAssembly є вбудовані функції накшталт математики та побітових операцій.
+    ;; Варто зазначити, що тут відсутні вбудовані тригонометричні функції.
+    ;; Тож нам потрібно:
+    ;; - написати їх самостійно (не найкраща ідея)
+    ;; - звідкись їх імпортувати (як саме - побачимо згодом)
+  )
+
+  ;; Функції
+  ;; Параметри вказуються ключовим словом `param`, значення, що повертається - `result`
+  ;; Поточне значення стеку і є значенням функції, що повертається
+
+  ;; Ми можемо викликати інші функції за допомогою `call`
+
+  (func $get_16 (result i32)
+    (i32.const 16)
+  )
+
+  (func $add (param $param0 i32) (param $param1 i32) (result i32)
+    (i32.add
+      (local.get $param0)
+      (local.get $param1)
+    )
+  )
+
+  (func $double_16 (result i32)
+    (i32.mul
+      (i32.const 2)
+      (call $get_16))
+  )
+
+  ;; Досі ми не могли що-небудь вивести на консоль і не мали доступу
+  ;; до високорівневої математики (степеневі функції, обрахунок експоненти або тригонометрія).
+  ;; Більше того, ми навіть не могли викликати WASM функції у Javascript!
+  ;; Виклик цих функцій у WebAssembly залежить від того,
+  ;; де ми знаходимось - чи це Node.js, чи середовище браузера.
+
+  ;; Якщо ми у Node.js, то потрібно виконати два кроки. По-перше, ми маємо сконвертувати
+  ;; текстове представлення WASM у справжній код webassembly.
+  ;; Наприклад, ось так (Binaryen):
+
+  ;; wasm-as learn-wasm.wast -o learn-wasm.wasm
+
+  ;; Давай також застосуємо оптимізації:
+
+  ;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
+
+  ;; Тепер наш скомпільований WebAssembly можна завантажити у Node.js:
+  ;; const fs = require('fs')
+  ;; const instantiate = async function (inFilePath, _importObject) {
+  ;;  var importObject = {
+  ;;     console: {
+  ;;       log: (x) => console.log(x),
+  ;;     },
+  ;;     math: {
+  ;;       cos: (x) => Math.cos(x),
+  ;;     }
+  ;;   }
+  ;;  importObject = Object.assign(importObject, _importObject)
+  ;;
+  ;;  var buffer = fs.readFileSync(inFilePath)
+  ;;  var module = await WebAssembly.compile(buffer)
+  ;;  var instance = await WebAssembly.instantiate(module, importObject)
+  ;;  return instance.exports
+  ;; }
+  ;;
+  ;; const main = function () {
+  ;;   var wasmExports = await instantiate('learn-wasm.wasm')
+  ;;   wasmExports.print_args(1, 0)
+  ;; }
+
+  ;; Цей код зчитує функції з importObject
+  ;; (вказано у асинхронній JavaScript функції instantiate), а потім експортує функцію
+  ;; "print_args", яку ми викликаємо у Node.js
+
+  (import "console" "log" (func $print_i32 (param i32)))
+  (import "math" "cos" (func $cos (param f64) (result f64)))
+
+  (func $print_args (param $arg0 i32) (param $arg1 i32)
+    (call $print_i32 (local.get $arg0))
+    (call $print_i32 (local.get $arg1))
+  )
+  (export "print_args" (func $print_args))
+
+  ;; Завантаження даних з пам'яті WebAssembly.
+  ;; Наприклад, ми хочемо порахувати cos для елементів Javascript масиву.
+  ;; Нам потрібно отримати доступ до масиву і можливість ітерувати по ньому.
+  ;; У прикладі нижче ми змінимо існуючий масив.
+  ;; f64.load і f64.store приймають адресу числа у пам'яті *у байтах*.
+  ;; Для того, щоб отримати доступ до 3-го елементу масиву, ми маємо передати щось
+  ;; накшталт (i32.mul (i32.const 8) (i32.const 2)) у функцію f64.store.
+
+  ;; У JavaScript ми викличемо `apply_cos64` таким чином
+  ;; (використаємо функцію instantiate з попереднього прикладу):
+  ;;
+  ;; const main = function () {
+  ;;   var wasm = await instantiate('learn-wasm.wasm')
+  ;;   var n = 100
+  ;;   const memory = new Float64Array(wasm.memory.buffer, 0, n)
+  ;;   for (var i=0; i<n; i++) {
+  ;;     memory[i] = i;
+  ;;   }
+  ;;   wasm.apply_cos64(n)
+  ;; }
+  ;;
+  ;; Ця функція не буде працювати, якщо ми виділимо пам'ять для (створимо) Float32Array у JavaScript.
+
+  (memory (export "memory") 100)
+
+  (func $apply_cos64 (param $array_length i32)
+    ;; визначаємо змінну циклу або лічильник
+    (local $idx i32)
+    ;; визначаємо змінну для доступу до пам'яті
+    (local $idx_bytes i32)
+    ;; константа - кількість байтів у числі типу f64.
+    (local $bytes_per_double i32)
+
+    ;; визначаємо змінну, яка зберігатиме значення з пам'яті
+    (local $temp_f64 f64)
+
+    (local.set $idx (i32.const 0))
+    (local.set $idx_bytes (i32.const 0)) ;; не обов'язково
+    (local.set $bytes_per_double (i32.const 8))
+
+    (block
+      (loop
+        ;; записуємо у idx_bytes необхідне зміщення в пам'яті - для поточного числа.
+        (local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
+
+        ;; отримуємо число з пам'яті (за зміщенням):
+        (local.set $temp_f64 (f64.load (local.get $idx_bytes)))
+
+        ;; рахуємо cos:
+        (local.set $temp_64 (call $cos (local.get $temp_64)))
+
+        ;; тепер зберігаємо результат обчислень у пам'ять:
+        (f64.store
+          (local.get $idx_bytes)
+          (local.get $temp_64))
+
+        ;; або робимо все за один крок (альтернативний код)
+        (f64.store
+          (local.get $idx_bytes)
+          (call $cos
+            (f64.load
+              (local.get $idx_bytes))))
+
+        ;; збільшуємо лічильник на одиницю (інкремент)
+        (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
+
+        ;; якщо лічильник дорівнює довжині масиву, то завершуємо цикл
+        (br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
+        (br 0)
+      )
+    )
+  )
+  (export "apply_cos64" (func $apply_cos64))
+)
+
+```
-- 
cgit v1.2.3


From 3024f90a397cfef7e51577d232417b8f753b771d Mon Sep 17 00:00:00 2001
From: Oleh Hromiak <o.a.gromyak@gmail.com>
Date: Mon, 7 Oct 2019 22:35:03 +0300
Subject: Fix [wasm/ua] filename

---
 uk-ua/wasm-ua.html.markdown | 225 ++++++++++++++++++++++++++++++++++++++++++++
 uk-ua/wasm.html.markdown    | 225 --------------------------------------------
 2 files changed, 225 insertions(+), 225 deletions(-)
 create mode 100644 uk-ua/wasm-ua.html.markdown
 delete mode 100644 uk-ua/wasm.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/wasm-ua.html.markdown b/uk-ua/wasm-ua.html.markdown
new file mode 100644
index 00000000..b5a1f4dd
--- /dev/null
+++ b/uk-ua/wasm-ua.html.markdown
@@ -0,0 +1,225 @@
+---
+language: WebAssembly
+filename: learnwasm-ua.wast
+contributors:
+    - ["Dean Shaff", "http://dean-shaff.github.io"]
+translators:
+    - ["Oleh Hromiak", "https://github.com/ogroleg"]
+---
+
+```
+;; learnwasm-ua.wast
+
+(module
+  ;; У WebAssembly весь код знаходиться в модулях. Будь-яка операція
+  ;; може бути записана за допомогою s-виразу. Також існує синтаксис "стек машини",
+  ;; втім, він не сумісний з проміжним бінарним представленням коду.
+
+  ;; Формат бінарного проміжного представлення майже повністю сумісний 
+  ;; з текстовим форматом WebAssembly.
+  ;; Деякі відмінності:
+  ;; local_set -> local.set
+  ;; local_get -> local.get
+
+  ;; Код розміщується у функціях
+
+  ;; Типи даних
+  (func $data_types
+    ;; WebAssembly має чотири типи даних:
+    ;; i32 - ціле число, 32 біти
+    ;; i64 - ціле число, 64 біти (не підтримується у JavaScript)
+    ;; f32 - число з плаваючою комою, 32 біти
+    ;; f64 - число з плаваючою комою, 64 біти
+
+    ;; Створити локальну змінну можна за допомогою ключового слова "local".
+    ;; Змінні потрібно оголошувати на початку функції.
+
+    (local $int_32 i32)
+    (local $int_64 i64)
+    (local $float_32 f32)
+    (local $float_64 f64)
+
+    ;; Змінні, оголошені вище, ще не ініціалізовані, себто, не мають значення.
+    ;; Давайте присвоїмо їм значення за допомогою <тип даних>.const:
+
+    (local.set $int_32 (i32.const 16))
+    (local.set $int_32 (i64.const 128))
+    (local.set $float_32 (f32.const 3.14))
+    (local.set $float_64 (f64.const 1.28))
+  )
+
+  ;; Базові операції
+  (func $basic_operations
+
+    ;; Нагадаємо, у WebAssembly будь-що є s-виразом, включно
+    ;; з математичними виразами або зчитуванням значень змінних
+
+    (local $add_result i32)
+    (local $mult_result f64)
+
+    (local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
+    ;; тепер add_result дорівнює 6!
+
+    ;; Для кожної операції потрібно використовувати правильний тип:
+    ;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; Ніт! mult_result має тип f64!
+    (local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; Ніт! mult_result має тип f64!
+
+    ;; У WebAssembly є вбудовані функції накшталт математики та побітових операцій.
+    ;; Варто зазначити, що тут відсутні вбудовані тригонометричні функції.
+    ;; Тож нам потрібно:
+    ;; - написати їх самостійно (не найкраща ідея)
+    ;; - звідкись їх імпортувати (як саме - побачимо згодом)
+  )
+
+  ;; Функції
+  ;; Параметри вказуються ключовим словом `param`, значення, що повертається - `result`
+  ;; Поточне значення стеку і є значенням функції, що повертається
+
+  ;; Ми можемо викликати інші функції за допомогою `call`
+
+  (func $get_16 (result i32)
+    (i32.const 16)
+  )
+
+  (func $add (param $param0 i32) (param $param1 i32) (result i32)
+    (i32.add
+      (local.get $param0)
+      (local.get $param1)
+    )
+  )
+
+  (func $double_16 (result i32)
+    (i32.mul
+      (i32.const 2)
+      (call $get_16))
+  )
+
+  ;; Досі ми не могли що-небудь вивести на консоль і не мали доступу
+  ;; до високорівневої математики (степеневі функції, обрахунок експоненти або тригонометрія).
+  ;; Більше того, ми навіть не могли викликати WASM функції у Javascript!
+  ;; Виклик цих функцій у WebAssembly залежить від того,
+  ;; де ми знаходимось - чи це Node.js, чи середовище браузера.
+
+  ;; Якщо ми у Node.js, то потрібно виконати два кроки. По-перше, ми маємо сконвертувати
+  ;; текстове представлення WASM у справжній код webassembly.
+  ;; Наприклад, ось так (Binaryen):
+
+  ;; wasm-as learn-wasm.wast -o learn-wasm.wasm
+
+  ;; Давай також застосуємо оптимізації:
+
+  ;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
+
+  ;; Тепер наш скомпільований WebAssembly можна завантажити у Node.js:
+  ;; const fs = require('fs')
+  ;; const instantiate = async function (inFilePath, _importObject) {
+  ;;  var importObject = {
+  ;;     console: {
+  ;;       log: (x) => console.log(x),
+  ;;     },
+  ;;     math: {
+  ;;       cos: (x) => Math.cos(x),
+  ;;     }
+  ;;   }
+  ;;  importObject = Object.assign(importObject, _importObject)
+  ;;
+  ;;  var buffer = fs.readFileSync(inFilePath)
+  ;;  var module = await WebAssembly.compile(buffer)
+  ;;  var instance = await WebAssembly.instantiate(module, importObject)
+  ;;  return instance.exports
+  ;; }
+  ;;
+  ;; const main = function () {
+  ;;   var wasmExports = await instantiate('learn-wasm.wasm')
+  ;;   wasmExports.print_args(1, 0)
+  ;; }
+
+  ;; Цей код зчитує функції з importObject
+  ;; (вказано у асинхронній JavaScript функції instantiate), а потім експортує функцію
+  ;; "print_args", яку ми викликаємо у Node.js
+
+  (import "console" "log" (func $print_i32 (param i32)))
+  (import "math" "cos" (func $cos (param f64) (result f64)))
+
+  (func $print_args (param $arg0 i32) (param $arg1 i32)
+    (call $print_i32 (local.get $arg0))
+    (call $print_i32 (local.get $arg1))
+  )
+  (export "print_args" (func $print_args))
+
+  ;; Завантаження даних з пам'яті WebAssembly.
+  ;; Наприклад, ми хочемо порахувати cos для елементів Javascript масиву.
+  ;; Нам потрібно отримати доступ до масиву і можливість ітерувати по ньому.
+  ;; У прикладі нижче ми змінимо існуючий масив.
+  ;; f64.load і f64.store приймають адресу числа у пам'яті *у байтах*.
+  ;; Для того, щоб отримати доступ до 3-го елементу масиву, ми маємо передати щось
+  ;; накшталт (i32.mul (i32.const 8) (i32.const 2)) у функцію f64.store.
+
+  ;; У JavaScript ми викличемо `apply_cos64` таким чином
+  ;; (використаємо функцію instantiate з попереднього прикладу):
+  ;;
+  ;; const main = function () {
+  ;;   var wasm = await instantiate('learn-wasm.wasm')
+  ;;   var n = 100
+  ;;   const memory = new Float64Array(wasm.memory.buffer, 0, n)
+  ;;   for (var i=0; i<n; i++) {
+  ;;     memory[i] = i;
+  ;;   }
+  ;;   wasm.apply_cos64(n)
+  ;; }
+  ;;
+  ;; Ця функція не буде працювати, якщо ми виділимо пам'ять для (створимо) Float32Array у JavaScript.
+
+  (memory (export "memory") 100)
+
+  (func $apply_cos64 (param $array_length i32)
+    ;; визначаємо змінну циклу або лічильник
+    (local $idx i32)
+    ;; визначаємо змінну для доступу до пам'яті
+    (local $idx_bytes i32)
+    ;; константа - кількість байтів у числі типу f64.
+    (local $bytes_per_double i32)
+
+    ;; визначаємо змінну, яка зберігатиме значення з пам'яті
+    (local $temp_f64 f64)
+
+    (local.set $idx (i32.const 0))
+    (local.set $idx_bytes (i32.const 0)) ;; не обов'язково
+    (local.set $bytes_per_double (i32.const 8))
+
+    (block
+      (loop
+        ;; записуємо у idx_bytes необхідне зміщення в пам'яті - для поточного числа.
+        (local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
+
+        ;; отримуємо число з пам'яті (за зміщенням):
+        (local.set $temp_f64 (f64.load (local.get $idx_bytes)))
+
+        ;; рахуємо cos:
+        (local.set $temp_64 (call $cos (local.get $temp_64)))
+
+        ;; тепер зберігаємо результат обчислень у пам'ять:
+        (f64.store
+          (local.get $idx_bytes)
+          (local.get $temp_64))
+
+        ;; або робимо все за один крок (альтернативний код)
+        (f64.store
+          (local.get $idx_bytes)
+          (call $cos
+            (f64.load
+              (local.get $idx_bytes))))
+
+        ;; збільшуємо лічильник на одиницю (інкремент)
+        (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
+
+        ;; якщо лічильник дорівнює довжині масиву, то завершуємо цикл
+        (br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
+        (br 0)
+      )
+    )
+  )
+  (export "apply_cos64" (func $apply_cos64))
+)
+
+```
diff --git a/uk-ua/wasm.html.markdown b/uk-ua/wasm.html.markdown
deleted file mode 100644
index b5a1f4dd..00000000
--- a/uk-ua/wasm.html.markdown
+++ /dev/null
@@ -1,225 +0,0 @@
----
-language: WebAssembly
-filename: learnwasm-ua.wast
-contributors:
-    - ["Dean Shaff", "http://dean-shaff.github.io"]
-translators:
-    - ["Oleh Hromiak", "https://github.com/ogroleg"]
----
-
-```
-;; learnwasm-ua.wast
-
-(module
-  ;; У WebAssembly весь код знаходиться в модулях. Будь-яка операція
-  ;; може бути записана за допомогою s-виразу. Також існує синтаксис "стек машини",
-  ;; втім, він не сумісний з проміжним бінарним представленням коду.
-
-  ;; Формат бінарного проміжного представлення майже повністю сумісний 
-  ;; з текстовим форматом WebAssembly.
-  ;; Деякі відмінності:
-  ;; local_set -> local.set
-  ;; local_get -> local.get
-
-  ;; Код розміщується у функціях
-
-  ;; Типи даних
-  (func $data_types
-    ;; WebAssembly має чотири типи даних:
-    ;; i32 - ціле число, 32 біти
-    ;; i64 - ціле число, 64 біти (не підтримується у JavaScript)
-    ;; f32 - число з плаваючою комою, 32 біти
-    ;; f64 - число з плаваючою комою, 64 біти
-
-    ;; Створити локальну змінну можна за допомогою ключового слова "local".
-    ;; Змінні потрібно оголошувати на початку функції.
-
-    (local $int_32 i32)
-    (local $int_64 i64)
-    (local $float_32 f32)
-    (local $float_64 f64)
-
-    ;; Змінні, оголошені вище, ще не ініціалізовані, себто, не мають значення.
-    ;; Давайте присвоїмо їм значення за допомогою <тип даних>.const:
-
-    (local.set $int_32 (i32.const 16))
-    (local.set $int_32 (i64.const 128))
-    (local.set $float_32 (f32.const 3.14))
-    (local.set $float_64 (f64.const 1.28))
-  )
-
-  ;; Базові операції
-  (func $basic_operations
-
-    ;; Нагадаємо, у WebAssembly будь-що є s-виразом, включно
-    ;; з математичними виразами або зчитуванням значень змінних
-
-    (local $add_result i32)
-    (local $mult_result f64)
-
-    (local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
-    ;; тепер add_result дорівнює 6!
-
-    ;; Для кожної операції потрібно використовувати правильний тип:
-    ;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; Ніт! mult_result має тип f64!
-    (local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; Ніт! mult_result має тип f64!
-
-    ;; У WebAssembly є вбудовані функції накшталт математики та побітових операцій.
-    ;; Варто зазначити, що тут відсутні вбудовані тригонометричні функції.
-    ;; Тож нам потрібно:
-    ;; - написати їх самостійно (не найкраща ідея)
-    ;; - звідкись їх імпортувати (як саме - побачимо згодом)
-  )
-
-  ;; Функції
-  ;; Параметри вказуються ключовим словом `param`, значення, що повертається - `result`
-  ;; Поточне значення стеку і є значенням функції, що повертається
-
-  ;; Ми можемо викликати інші функції за допомогою `call`
-
-  (func $get_16 (result i32)
-    (i32.const 16)
-  )
-
-  (func $add (param $param0 i32) (param $param1 i32) (result i32)
-    (i32.add
-      (local.get $param0)
-      (local.get $param1)
-    )
-  )
-
-  (func $double_16 (result i32)
-    (i32.mul
-      (i32.const 2)
-      (call $get_16))
-  )
-
-  ;; Досі ми не могли що-небудь вивести на консоль і не мали доступу
-  ;; до високорівневої математики (степеневі функції, обрахунок експоненти або тригонометрія).
-  ;; Більше того, ми навіть не могли викликати WASM функції у Javascript!
-  ;; Виклик цих функцій у WebAssembly залежить від того,
-  ;; де ми знаходимось - чи це Node.js, чи середовище браузера.
-
-  ;; Якщо ми у Node.js, то потрібно виконати два кроки. По-перше, ми маємо сконвертувати
-  ;; текстове представлення WASM у справжній код webassembly.
-  ;; Наприклад, ось так (Binaryen):
-
-  ;; wasm-as learn-wasm.wast -o learn-wasm.wasm
-
-  ;; Давай також застосуємо оптимізації:
-
-  ;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
-
-  ;; Тепер наш скомпільований WebAssembly можна завантажити у Node.js:
-  ;; const fs = require('fs')
-  ;; const instantiate = async function (inFilePath, _importObject) {
-  ;;  var importObject = {
-  ;;     console: {
-  ;;       log: (x) => console.log(x),
-  ;;     },
-  ;;     math: {
-  ;;       cos: (x) => Math.cos(x),
-  ;;     }
-  ;;   }
-  ;;  importObject = Object.assign(importObject, _importObject)
-  ;;
-  ;;  var buffer = fs.readFileSync(inFilePath)
-  ;;  var module = await WebAssembly.compile(buffer)
-  ;;  var instance = await WebAssembly.instantiate(module, importObject)
-  ;;  return instance.exports
-  ;; }
-  ;;
-  ;; const main = function () {
-  ;;   var wasmExports = await instantiate('learn-wasm.wasm')
-  ;;   wasmExports.print_args(1, 0)
-  ;; }
-
-  ;; Цей код зчитує функції з importObject
-  ;; (вказано у асинхронній JavaScript функції instantiate), а потім експортує функцію
-  ;; "print_args", яку ми викликаємо у Node.js
-
-  (import "console" "log" (func $print_i32 (param i32)))
-  (import "math" "cos" (func $cos (param f64) (result f64)))
-
-  (func $print_args (param $arg0 i32) (param $arg1 i32)
-    (call $print_i32 (local.get $arg0))
-    (call $print_i32 (local.get $arg1))
-  )
-  (export "print_args" (func $print_args))
-
-  ;; Завантаження даних з пам'яті WebAssembly.
-  ;; Наприклад, ми хочемо порахувати cos для елементів Javascript масиву.
-  ;; Нам потрібно отримати доступ до масиву і можливість ітерувати по ньому.
-  ;; У прикладі нижче ми змінимо існуючий масив.
-  ;; f64.load і f64.store приймають адресу числа у пам'яті *у байтах*.
-  ;; Для того, щоб отримати доступ до 3-го елементу масиву, ми маємо передати щось
-  ;; накшталт (i32.mul (i32.const 8) (i32.const 2)) у функцію f64.store.
-
-  ;; У JavaScript ми викличемо `apply_cos64` таким чином
-  ;; (використаємо функцію instantiate з попереднього прикладу):
-  ;;
-  ;; const main = function () {
-  ;;   var wasm = await instantiate('learn-wasm.wasm')
-  ;;   var n = 100
-  ;;   const memory = new Float64Array(wasm.memory.buffer, 0, n)
-  ;;   for (var i=0; i<n; i++) {
-  ;;     memory[i] = i;
-  ;;   }
-  ;;   wasm.apply_cos64(n)
-  ;; }
-  ;;
-  ;; Ця функція не буде працювати, якщо ми виділимо пам'ять для (створимо) Float32Array у JavaScript.
-
-  (memory (export "memory") 100)
-
-  (func $apply_cos64 (param $array_length i32)
-    ;; визначаємо змінну циклу або лічильник
-    (local $idx i32)
-    ;; визначаємо змінну для доступу до пам'яті
-    (local $idx_bytes i32)
-    ;; константа - кількість байтів у числі типу f64.
-    (local $bytes_per_double i32)
-
-    ;; визначаємо змінну, яка зберігатиме значення з пам'яті
-    (local $temp_f64 f64)
-
-    (local.set $idx (i32.const 0))
-    (local.set $idx_bytes (i32.const 0)) ;; не обов'язково
-    (local.set $bytes_per_double (i32.const 8))
-
-    (block
-      (loop
-        ;; записуємо у idx_bytes необхідне зміщення в пам'яті - для поточного числа.
-        (local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
-
-        ;; отримуємо число з пам'яті (за зміщенням):
-        (local.set $temp_f64 (f64.load (local.get $idx_bytes)))
-
-        ;; рахуємо cos:
-        (local.set $temp_64 (call $cos (local.get $temp_64)))
-
-        ;; тепер зберігаємо результат обчислень у пам'ять:
-        (f64.store
-          (local.get $idx_bytes)
-          (local.get $temp_64))
-
-        ;; або робимо все за один крок (альтернативний код)
-        (f64.store
-          (local.get $idx_bytes)
-          (call $cos
-            (f64.load
-              (local.get $idx_bytes))))
-
-        ;; збільшуємо лічильник на одиницю (інкремент)
-        (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
-
-        ;; якщо лічильник дорівнює довжині масиву, то завершуємо цикл
-        (br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
-        (br 0)
-      )
-    )
-  )
-  (export "apply_cos64" (func $apply_cos64))
-)
-
-```
-- 
cgit v1.2.3


From e598dfb5b48f3699a82a685864f84d1f0eaed32f Mon Sep 17 00:00:00 2001
From: Oleh Hromiak <o.a.gromyak@gmail.com>
Date: Tue, 8 Oct 2019 11:49:21 +0300
Subject: Fix [wasm/ua] lang param

---
 uk-ua/wasm-ua.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'uk-ua')

diff --git a/uk-ua/wasm-ua.html.markdown b/uk-ua/wasm-ua.html.markdown
index b5a1f4dd..34f8cef8 100644
--- a/uk-ua/wasm-ua.html.markdown
+++ b/uk-ua/wasm-ua.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: WebAssembly
+lang: uk-ua
 filename: learnwasm-ua.wast
 contributors:
     - ["Dean Shaff", "http://dean-shaff.github.io"]
-- 
cgit v1.2.3


From 6b5938017b5105066d27484605af8dd88fab183d Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Mon, 28 Oct 2019 01:20:19 +0200
Subject: [mips/uk-ua] Add ukrainian translation for MIPS Assemly

---
 uk-ua/mips-ua.html.markdown | 366 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 366 insertions(+)
 create mode 100644 uk-ua/mips-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
new file mode 100644
index 00000000..20fa7638
--- /dev/null
+++ b/uk-ua/mips-ua.html.markdown
@@ -0,0 +1,366 @@
+---
+language: "MIPS Assembly"
+filename: MIPS.asm
+contributors:
+  - ["Stanley Lim", "https://github.com/Spiderpig86"]
+translators:
+  - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Мова асемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропорцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
+
+[Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```asm
+# Коментарі позначені як'#'
+
+# Всі символи після '#' ігноруються лексичним аналізатором асемблера.
+
+# Зазвичай програми поділяються на .data та .text частини
+
+.data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
+	   # в мовах програмування вищого рівня
+
+  # Змінна оголошується наступним чином: [назва]: .[тип] [значенння] 
+  # Наприклад:
+  hello_world: .asciiz "Hello World\n"      # Оголосити текстову змінну
+  num1: .word 42                            # word - це чисельний тип 32-бітного розряду
+
+  arr1: .word 1, 2, 3, 4, 5                 # Масив чисел
+  arr2: .byte 'a', 'b'                      # Масив буквених символів (розмір кожного - 1 байт)
+  buffer: .space 60                         # Виділити місце в RAM 
+                                            # (не очищується, тобто не заповнюється 0)
+
+  # Розміри типів даних
+  _byte: .byte 'a'                          # 1 байт
+  _halfword: .half 53                       # 2 байти
+  _word: .word 3                            # 4 байти
+  _float: .float 3.14                       # 4 байти
+  _double: .double 7.0                      # 8 байтів
+
+  .align 2                                  # Вирівнення пам'яті даних, де число
+                                            # показує кількість байтів, вирівнених 
+                                            # у степені 2. (.align 2 означає 
+                                            # чисельне (word) вирівнювання оскільки 
+                                            # 2^2 = 4 байти)
+
+.text                                       # Розділ, що містить інструкції та
+                                            # логіку програми
+
+.globl _main                                # Оголошує назву інструкції як 
+                                            # глобальну, тобто, яка є доступною для
+                                            # всіх інших файлів
+
+  _main:                                    # програми MIPS виконують інструкції
+                                            # послідовно, тобто першочергово код
+                                            # буде виконуватись після цієї позначки
+
+    # Виведемо на екран "hello world"
+    la $a0, hello_world                     # Завантажує адресу тексту у пам'яті
+    li $v0, 4                               # Завантажує значення системної
+                                            # команди (вказуючи тип функціоналу)
+    syscall                                 # Виконує зазначену системну команду
+                                            # з обраним аргументом ($a0)
+
+    # Регісти (використовуються, щоб тримати дані протягом виконання програми)
+    # $t0 - $t9                             # Тимчасові регістри використовуються
+                                            # для проміжних обчислень всередині
+                                            # підпрограм (не зберігаються між 
+                                            # викликами функцій)
+
+    # $s0 - $s7                             # Збережені регісти, у яких значення 
+                                            # збегіраються між викликами підпрограм.
+                                            # Зазвичай збегрігаються у стеку.
+
+    # $a0 - $a3                             # Регістри для передачі аргументів для 
+                                            # підпрограм
+    # $v0 - $v1                             # Регістри для значень, що повертаються
+                                            # від викликаної функції
+
+    # Типи інструкції завантаження / збереження
+    la $t0, label                           # Скопіювати адресу в пам'яті, де 
+                                            # зберігається значення змінної label 
+                                            # в регістр $t0
+    lw $t0, label                           # Скопівати чисельне значення з пам'яті
+    lw $t1, 4($s0)                          # Скопівати чисельне значення з адреси
+                                            # пам'яті ресгіста зі зміщенням в 
+                                            # 4 байти (адреса + 4)
+    lb $t2, label                           # Скопіювати буквений символ в частину
+                                            # нижчого порядку регістра $t2
+    lb $t2, 0($s0)                          # Скопіювати буквений символ з адреси
+                                            # в $s0 із зсувом 0
+    # Подіне використання і 'lh' для halfwords
+
+    sw $t0, label                           # Збегігти чисельне значення в адресу в 
+                                            # пам'яті, що відповідає змінній label
+    sw $t0, 8($s0)                          # Збегігти чисельне значення в адресу, 
+                                            # зазначеній у $s0, та зі зсувом у 8 байтів
+    # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords. 
+    # 'sa' не існує
+    
+    
+### Математичні операції ###
+  _math:
+    # Пам'ятаємо, що попередньо потрібно завантажити данні в пам'ять
+    lw $t0, num                             # Із розділа з данними
+    li $t0, 5                               # Або безпосередньо з константи
+    li $t1, 6
+    add $t2, $t0, $t1                       # $t2 = $t0 + $t1
+    sub $t2, $t0, $t1                       # $t2 = $t0 - $t1
+    mul $t2, $t0, $t1                       # $t2 = $t0 * $t1
+    div $t2, $t0, $t1                       # $t2 = $t0 / $t1 (Може не підтримуватись
+                                            # деякими версіями MARS)
+    div $t0, $t1                            # Виконує $t0 / $t1. Отримати частку можна
+                                            # за допомогою команди 'mflo', остаток - 'mfhi'
+
+    # Bitwise Shifting
+    sll $t0, $t0, 2                         # Побітовий здвиг вліво з безпосереднім
+                                            # значенням (константою) 2
+    sllv $t0, $t1, $t2                      # Здвиг вліво зі змінною кількістю у
+                                            # регістрі
+    srl $t0, $t0, 5                         # Побітовий здвиг вправо (не збегігає 
+                                            # знак, знак розширюється 0)
+    srlv $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у
+                                            # регістрі
+    sra $t0, $t0, 7                         # Побітовий арифметичний збвиг вправо 
+                                            # (зберігає знак)
+    srav $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у 
+                                            # регістрі
+
+    # Bitwise operators
+    and $t0, $t1, $t2                       # Побітове І (AND)
+    andi $t0, $t1, 0xFFF                    # Побітове І з беспосереднім значенням
+    or $t0, $t1, $t2                        # Побітове АЛЕ (OR)
+    ori $t0, $t1, 0xFFF                     # Побітове АЛЕ з беспосереднім значенням
+    xor $t0, $t1, $t2                       # Побітова виключна диз'юнкція (XOR)
+    xori $t0, $t1, 0xFFF                    # Побітове XOR з беспосереднім значенням
+    nor $t0, $t1, $t2                       # Побітова стрілка Пірса (NOR)
+
+## Розгалуження ##
+  _branching:
+    # В овсновному інструкції розгалуження мають наступну форму:
+    # <instr> <reg1> <reg2> <label>
+    # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
+    # правдиве
+
+    beq $t0, $t1, reg_eq                    # Перейдемо у розгалуження reg_eq
+                                            # якщо $t0 == $t1, інакше -
+                                            # винонати наступну строку
+    bne $t0, $t1, reg_neq                   # Розгалужується, якщо $t0 != $t1
+    b branch_target                         # Розгалуження без умови завжди виконується
+    beqz $t0, req_eq_zero                   # Розгалужується, якщо $t0 == 0
+    bnez $t0, req_neq_zero                  # Розгалужується, якщо $t0 != 0
+    bgt $t0, $t1, t0_gt_t1                  # Розгалужується, якщо $t0 > $t1
+    bge $t0, $t1, t0_gte_t1                 # Розгалужується, якщо $t0 >= $t1
+    bgtz $t0, t0_gt0                        # Розгалужується, якщо $t0 > 0
+    blt $t0, $t1, t0_gt_t1                  # Розгалужується, якщо $t0 < $t1
+    ble $t0, $t1, t0_gte_t1                 # Розгалужується, якщо $t0 <= $t1
+    bltz $t0, t0_lt0                        # Розгалужується, якщо $t0 < 0
+    slt $s0, $t0, $t1                       # Інструкція, що посилає сигнал коли
+                                            # $t0 < $t1, результат зберігається в $s0 
+                                            # (1 - правдиве твердження)
+
+    # Просте твердження якщо (if)
+    # if (i == j)
+    #     f = g + h;
+    #  f = f - i;
+
+    # Нехай $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
+    bne $s3, $s4, L1 # if (i !=j)
+    add $s0, $s1, $s2 # f = g + h
+
+    L1:
+      sub $s0, $s0, $s3 # f = f - i
+    
+    # Нижще наведений приклад знаходження максимального значееня з 3 чисел
+    # Пряма трансляція в Java з логіки MIPS:
+    # if (a > b)
+    #   if (a > c)
+    #     max = a;
+    #   else
+    #     max = c;
+    # else
+    #     max = b;
+    #   else
+    #     max = c;
+
+    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регіст
+    ble $s0, $s1, a_LTE_b                   # якщо (a <= b) розгалуження(a_LTE_b)
+    ble $s0, $s2, max_C                     # якщо (a > b && a <=c) розгалуження(max_C)
+    move $v0, $s1                           # інакше [a > b && a > c] max = a
+    j done                                  # Перейти в кінець програми
+
+    a_LTE_b:                                # Мітка розгаруження, коли a <= b
+      ble $s1, $s2, max_C                   # якщо (a <= b && b <= c) розгалуження(max_C)
+      move $v0, $s1                         # якщо (a <= b && b > c) max = b
+      j done                                # Перейти в кінець програми
+
+    max_C:
+      move $v0, $s2                         # max = c
+
+    done:                                   # Кінець програми
+
+## Цикли ##
+  _loops:
+    # Цикл складається з умови виходу та з інстукції переходу після його завершення
+    li $t0, 0
+    while:
+      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати інтерації
+      addi $t0, $t0, 1                      # Збільшити значення
+      j while                               # Перейти на початок циклу
+    end_while:
+
+    # Транспонування 2D матриці
+    # Припустмо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
+    li $t0, 0                               # Лічильник для i
+    li $t1, 0                               # Лічильник для j
+    matrix_row:
+      bgt $t0, 3, matrix_row_end
+
+      matrix_col:
+        bgt $t1, 3, matrix_col_end
+
+        # ...
+
+        addi $t1, $t1, 1                  # Збільшити лічильник стовпця (col)
+      matrix_col_end:
+
+      # ...
+
+      addi $t0, $t0, 1
+    matrix_row_end:
+
+## Функції ##
+  _functions:
+    # Фукнції - це процедури, що викликаються, приймають аргументи та повертають значення
+
+    main:                                 # Програма починається з головної функції
+      jal return_1                        # jal збереже поточний PC в $ra,
+                                          # а потім перейде до return_1
+
+      # Як передати аргументи?
+      # По-перше, ми маємо передати значення аргументів у регістри аргументів
+      li $a0, 1
+      li $a1, 2
+      jal sum                             # Тепер ми можемо викликати функцію
+
+      # Як щодо рекурсії?
+      # Тут потрібно дещо більше роботи оскільки ми маємо впевнетись, що ми збережемо
+      # та зчитаємо попередній PC в $ra, оскільки jal автоматично перепише її при виклику
+      li $a0, 3
+      jal fact
+
+      li $v0, 10
+      syscall
+    
+    # Ця функйія повертає 1
+    return_1:
+      li $v0, 1                           # Завантажити val в регіст $v0
+      jr $ra                              # Повернутись до попереднього PC і продовжити виконання 
+
+
+    # Function with 2 args
+    sum:
+      add $v0, $a0, $a1
+      jr $ra                              # Повернутись
+
+    # Фекурсивна функція, яка знаходить факторіал
+    fact:
+      addi $sp, $sp, -8                   # Виділити місце в стеку
+      sw $s0, ($sp)                       # Зберегти регістр, що містить поточне число
+      sw $ra, 4($sp)                      # Зберегти попереднє PC
+
+      li $v0, 1                           # Проініціліазувати значення, що повертатиметься
+      beq $a0, 0, fact_done               # Закінчити, якщо параметр 0
+
+      # Інакше, продовжити рекурсію
+      move $s0, $a0                       # Скоріювати $a0 в $s0
+      sub $a0, $a0, 1
+      jal fact
+
+      mul $v0, $s0, $v0                   # Множення
+
+      fact_done:
+        lw $s0, ($sp)
+        lw $ra, ($sp)                     # Відновити PC
+        addi $sp, $sp, 8
+
+        jr $ra
+
+## Макроси ##
+  _macros:
+    # Макроси надзвичайно корисні для заміни блоків коду, що повторюються, за допомогою
+    # однієї змінної, для покращення читабельності
+    # Це не заміна функцій.
+    # Вони мають бути оголошені перед використанням
+
+    # Макрос для виведення нових строк (оскільки операція лосить часто виконується)
+    .macro println()
+      la $a0, newline                     # Значення нової строки зберігатиметься тут
+      li $v0, 4
+      syscall
+    .end_macro
+
+    println()                             # Асемблер скопіює цей блок коду сюди
+                                          # перед тим, як виконувати його
+
+    # Можна передавати параметри у макроси.
+    # Параметри позначаються знаком '%' з довільною назвою
+    .macro print_int(%num)
+      li $v0, 1
+      lw $a0, %num
+      syscall
+    .end_macro
+    
+    li $t0, 1
+    print_int($t0)
+    
+    # Ми таком можемо передавати безпосередньо значення в макроси
+    .macro immediates(%a, %b)
+      add $t0, %a, %b
+    .end_macro
+
+    immediates(3, 5)
+
+    # Одночасно із назвами змінних
+    .macro print(%string)
+      la $a0, %string
+      li $v0, 4
+      syscall
+    .end_macro
+
+    print(hello_world)
+
+## Масиви ##
+.data
+  list: .word 3, 0, 1, 2, 6                 # Це масив чисел
+  char_arr: .asciiz "hello"                 # Це текстовий масив
+  buffer: .space 128                        # Видтляє блок пам'яті, що
+                                            # автоматично не очищується
+                                            # Ці блоки пам'яті вирівнюють
+                                            # оддин одного
+
+.text
+  la $s0, list                              # Завантажити адрегу у список
+  li $t0, 0                                 # Лічильник
+  li $t1, 5                                 # Довжина списку
+
+  loop:
+    bgt $t0, $t1, end_loop
+
+    lw $a0, ($s0)
+    li $v0, 1
+    syscall                                 # Вивести число
+
+    addi $s0, $s0, 4                        # Розмір числа - 4 байти
+    addi $t0, $t0, 1                        # Збільшити
+    j loop
+  end_loop:
+
+## Включення ##
+# Це потрібно для імпорту стороннії файлівв програму (але насправді, код з цього файлу 
+# копіюється та вставляється в місце, де оголошений імпорт)
+.include "somefile.asm"
+
+```
-- 
cgit v1.2.3


From 10c2fbf75ec35371f044962124f9dee556847b2f Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Tue, 29 Oct 2019 19:17:03 +0200
Subject: [kotlin/uk-ua] Add ukrainian translation for Kotlin

---
 uk-ua/kotlin-ua.html.markdown | 463 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 463 insertions(+)
 create mode 100644 uk-ua/kotlin-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown
new file mode 100644
index 00000000..f32a43cd
--- /dev/null
+++ b/uk-ua/kotlin-ua.html.markdown
@@ -0,0 +1,463 @@
+---
+language: kotlin
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+	= ["AstiaSun", "https://github.com/AstiaSun"]
+filename: LearnKotlin.kt
+lang: uk-ua
+---
+
+Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера. Вона має 100% сумісність із Java.
+
+[Детальніше](https://kotlinlang.org/)
+
+```kotlin
+// Однорядкові коментарі починаються з //
+/*
+Такий вигляд мають багаторядкові коментарі
+*/
+
+// Ключове слово package працює так само, як і в Java.
+package com.learnxinyminutes.kotlin
+
+/*
+Точкою входу для програм на Kotlin є функція під назвою main.
+Вона приймає масив із аргументів, що були передані через командний рядок.
+Починаючи з Kotlin 1.3, функція main може бути оголошена без параметрів взагалі.
+*/
+fun main(args: Array<String>) {
+    /*
+    Оголошення змінних відбувається за допомогою ключових слів var або val.
+    Відмінність між ними полягає в тому, що значення змінних, оголошених через 
+    val, не можна змінювати. Водночас, змінній "var" можна переприсвоїти нове 
+    значення в подальшому.
+    */
+    val fooVal = 10 // більше ми не можемо змінити значення fooVal на інше
+    var fooVar = 10
+    fooVar = 20 // fooVar може змінювати значення
+
+    /*
+    В більшості випадків Kotlin може визначати, якого типу змінна, тому не 
+    потрібно щоразу точно вказувати її тип.
+    Тип змінної вказується наступним чином:
+    */
+    val foo: Int = 7
+
+    /*
+    Рядки мають аналогічне з Java представлення. Спеціальні символи 
+    позначаються за допомогою зворотнього слеша.
+    */
+    val fooString = "My String Is Here!"
+    val barString = "Printing on a new line?\nNo Problem!"
+    val bazString = "Do you want to add a tab?\tNo Problem!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    Необроблений рядок розмежовується за допомогою потрійтих лапок (""").
+    Необроблені рядки можуть містити переніс рядка (не спеціальний символ \n) та 
+    будь-які інші символи.
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hello, world!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    Рядки можуть містити шаблонні вирази.
+    Шаблонний вираз починається із символа доллара "$".
+    */
+    val fooTemplateString = "$fooString has ${fooString.length} characters"
+    println(fooTemplateString) // => My String Is Here! has 18 characters
+
+    /*
+    Щоб змінна могла мати значення null, потрібно це додатково вказати. 
+    Для цього після оголошеного типу змінної додається спеціальний символ "?".
+    Отримати значення такої змінної можна використавши оператор "?.".
+    Оператор "?:" застосовується, щоб оголосити альтернативне значення змінної 
+    у випадку, якщо вона буде рівна null.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    Функції оголошуються з використанням ключового слова fun.
+    Аргументи функції перелічуються у круглих дужках після назви функції.
+    Аргументи можуть мати значення за замовчуванням. Тип значення, що повертатиметься
+    функцією, вказується після оголошення аргументів за необхідністю.
+    */
+    fun hello(name: String = "world"): String {
+        return "Hello, $name!"
+    }
+    println(hello("foo")) // => Hello, foo!
+    println(hello(name = "bar")) // => Hello, bar!
+    println(hello()) // => Hello, world!
+
+    /*
+    Параменти функції можуть бути помічені ключовим словом vararg. Це дозволяє 
+    приймати довільну кількість аргументів функції зазначеного типу.
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument has ${names.size} elements")
+    }
+    varargExample() // => Argument has 0 elements
+    varargExample(1) // => Argument has 1 elements
+    varargExample(1, 2, 3) // => Argument has 3 elements
+
+    /*
+    Коли фукнція складається з одного виразу, фігурні дужки не є обов'язковими. 
+    Тіло функції вказується після оператора "=".
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // Якщо значення, що повертається функцією, може бути однозначно визначено, 
+    // його непотрібно вказувати.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Функції можуть приймати інші функції як аргументи, а також повертати інші функції.
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // Іменовані функції можуть бути вказані як аргументи за допомогою оператора "::".
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // Лямбда-вирази також можуть бути аргументами функції.
+    val notZero = not {n -> n == 0}
+    /*
+    Якщо лямбда-вираз приймає лише один параметр, його оголошення може бути пропущене
+    (разом із ->). Всередині виразу до цього параметра можна звернутись через 
+    змінну "it".
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // Ключове слово class використовується для оголошення класів.
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    Щоб створити новий об'єкт, потрібно викликали конструктор класу.
+    Зазначте, що в Kotlin немає ключового слова new.
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Методи класу викликаються через крапку.
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    Якщо функція була позначена ключовим словом infix, тоді її можна викликати через 
+    інфіксну нотацію.
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    Класи даних - це лаконічний спосіб створювати класи, що містимуть тільки дані.
+    Методи "hashCode"/"equals" та "toString" автоматично генеруються.
+    */
+    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)
+
+    // Класи даних також мають функцію "copy".
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Об'єкти можуть бути знищенні кількома способами. 
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+
+    // знищення у циклі for
+    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 також знищується
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // Функція із "with" працює майже так само як це ж твердження у JavaScript.
+    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.
+    Список буде незмінним, тобто елементи не можна буде додавати або видаляти.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // доступ до елементів злійснюється через їх порядковий номер.
+    println(fooList[1]) // => b
+
+    // Змінні списки можна створити використовуючи функцію mutableListOf.
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // Функція setOf  створює об'єкт типу множина.
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // mapOf створює асоціативний масив.
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Доступ до значень в асоціативних масивах здійснюється через їх ключі.
+    println(fooMap["a"]) // => 8
+
+    /*
+    Послідовності представленні як колекції лінивих обчислень. Функція generateSequence
+    створює послідовність.
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Приклад використання послідовностей, генерація чисел Фібоначі:
+    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 має функції вищого порядку для роботи з колекціями.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // Цикл for може використовуватись з будь-чим, що має ітератор.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // Принцип роботи циклів "while" не відрізняється від інших мов програмування.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    if може бути використаний як вираз, що повертає значення. Тому тернарний 
+    оператор ?: не потрібний в Kotlin.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // "when" використовується як альтернатива в ланцюзі "if-else if".
+    val i = 10
+    when {
+        i < 7 -> println("first block")
+        fooString.startsWith("hello") -> println("second block")
+        else -> println("else block")
+    }
+
+    // "when" може приймати аргумент.
+    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" також може використовуватись як функція, що повератє значення.
+    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)
+
+    /*
+    Тип об'єкта можна перевірити використавши оператор is. Якщо перевірка проходить 
+    успішно, тоді можна використовувати об'єкт як данний тип не приводячи до ного 
+    додатково.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x тепер має тип Boolean
+            return x
+        } else if (x is Int) {
+            // x тепер має тип Int
+            return x > 0
+        } else if (x is String) {
+            // x тепер має тип String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hello, world!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // Smartcast (розумне приведення) також працює з блоком when
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    Розширення - це ще один спобів розширити функціонал класу.
+    Подібні методи розширення реалізовані у С#.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hello, world!".remove('l')) // => Heo, word!
+}
+
+// Класи перелічення також подібні до тих типів, що і в Java.
+enum class EnumExample {
+    A, B, C // Константи перелічення розділені комами.
+}
+fun printEnum() = println(EnumExample.A) // => A
+
+// Оскільки кожне перелічення - це об'єкт класу enum, воно може бути 
+// проініціалізоване наступним чином:
+enum class EnumExample(val value: Int) {
+    A(value = 1),
+    B(value = 2),
+    C(value = 3)
+}
+fun printProperty() = println(EnumExample.A.value) // => 1
+
+// Кожне перелічення має властивості, які дозволяють отримати його ім'я 
+// та порядок (позицію) в класі enum:
+fun printName() = println(EnumExample.A.name) // => A
+fun printPosition() = println(EnumExample.A.ordinal) // => 0
+
+/*
+Ключове слово object можна виокристати для створення об'єкту сінглтону. Об'єкт не 
+можна інстанціювати, проте на його унікальний екземпляр можна посилатись за іменем.
+Подібна можливість є в сінглтон об'єктах у Scala. 
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "hello"
+    }
+
+    override fun toString(): String {
+        return "Hello, it's me, ${ObjectExample::class.simpleName}"
+    }
+}
+
+
+fun useSingletonObject() {
+    println(ObjectExample.hello()) // => hello
+    // В Kotlin, "Any" - це корінь ієрархії класів, так само, як і "Object" у Java.
+    val someRef: Any = ObjectExample
+    println(someRef) // => Hello, it's me, ObjectExample
+}
+
+
+/* 
+Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає ексепшн, якщо значення рівне null.
+*/
+var b: String? = "abc"
+val l = b!!.length
+
+// Далі - приклади перевизначення методів класу Any в класі-насліднику
+data class Counter(var value: Int) {
+    // перевизначити Counter += Int
+    operator fun plusAssign(increment: Int) {
+        this.value += increment
+    }
+
+    // перевизначити Counter++ та ++Counter
+    operator fun inc() = Counter(value + 1)
+
+    // перевизначити Counter + Counter
+    operator fun plus(other: Counter) = Counter(this.value + other.value)
+
+    // перевизначити Counter * Counter
+    operator fun times(other: Counter) = Counter(this.value * other.value)
+
+    // перевизначити Counter * Int
+    operator fun times(value: Int) = Counter(this.value * value)
+
+    // перевизначити Counter in Counter
+    operator fun contains(other: Counter) = other.value == this.value
+
+    // перевизначити Counter[Int] = Int
+    operator fun set(index: Int, value: Int) {
+        this.value = index + value
+    }
+
+    // перевизначити виклик екземпляру Counter
+    operator fun invoke() = println("The value of the counter is $value")
+
+}
+// Можна також перевизначити оператори через методи розширення.
+// перевизначити -Counter
+operator fun Counter.unaryMinus() = Counter(-this.value)
+
+fun operatorOverloadingDemo() {
+    var counter1 = Counter(0)
+    var counter2 = Counter(5)
+    counter1 += 7
+    println(counter1) // => Counter(value=7)
+    println(counter1 + counter2) // => Counter(value=12)
+    println(counter1 * counter2) // => Counter(value=35)
+    println(counter2 * 2) // => Counter(value=10)
+    println(counter1 in Counter(5)) // => false
+    println(counter1 in Counter(7)) // => true
+    counter1[26] = 10
+    println(counter1) // => Counter(value=36)
+    counter1() // => The value of the counter is 36
+    println(-counter2) // => Counter(value=-5)
+}
+```
+
+### Подальше вивчення
+
+* [Уроки Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Спробувати попрацювати з Kotlin в браузері](https://play.kotlinlang.org/)
+* [Список корисних посилань](http://kotlin.link/)
-- 
cgit v1.2.3


From d7af01bda2a7c5cad433502de6780a1ccc05b8aa Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Mon, 28 Oct 2019 21:26:47 +0200
Subject: [go/uk-ua] Add ukrainian translation for Go language

---
 uk-ua/go-ua.html.markdown | 450 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 450 insertions(+)
 create mode 100644 uk-ua/go-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
new file mode 100644
index 00000000..8c9e9de7
--- /dev/null
+++ b/uk-ua/go-ua.html.markdown
@@ -0,0 +1,450 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+    - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Go був створений для того, щоб виконати задачу. Це не останній тренд в теорії мов програмування, а спосіб вирішення реальних проблем.
+
+Він увібрав принципи з імперативних мов зі статичною типізацією.
+Go швидко компілюється та виконується, а його багатопоточність легка для
+вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 міліонів в Google, Inc.)
+
+Go має чудову стандартну бібліотеку та чимале ком'юніті.
+
+```go
+// Однорядковий коментар
+/* Багато-
+ рядковий коментар */
+
+// Кожен файл вихідного коду має почитанитсь із ключового слова package.
+// main - це спеціальна назва, що оголошує виконуваний код, а не бібліотеку.
+package main
+
+// import оголошує бібліотеки, що використовуються в данному файлі.
+import (
+	"fmt"       // Пакет стандартної бібліотеки Go.
+	"io/ioutil" // Цей пакет реалізує деякі I/O функції утиліт.
+	m "math"    // Бібліотека математичних операцій з локальним псевдонімом m.
+	"net/http"  // Так, веб сервер!
+	"os"        // Функції операційної системи, такі як робота з файловою системою.
+	"strconv"   // Перетворення текстових змінних.
+)
+
+// Оголошення функції. 
+// Функція main - особлива. Це вхідна точка для виконуваних програм.
+// Ви можете любити це, або ж ненавидіти, але Go використовує фігурні дужки.
+func main() {
+	// Println виводить рядок в stdout.
+	// Ця функція входить у пакет fmt.
+	fmt.Println("Hello world!")
+
+	// Викликати іншу функцію з цього файлу.
+	beyondHello()
+}
+
+// Аргумети функцій описуються у круглих дужках.
+// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обовязкові.
+func beyondHello() {
+	var x int // Оголошення змінної. Перед використанням змінні обов'язково мають бути оголошені.
+	x = 3     // Присвоєння значення.
+	// "Короткі" оголошення використовують := щоб окреслити тип, оголосити та присвоїти значення.
+	y := 4
+	sum, prod := learnMultiple(x, y)        // Функція повертає два значення.
+	fmt.Println("sum:", sum, "prod:", prod) // Просто вивід.
+	learnTypes()                            // < y хвилин, потрібно вивчити більше!
+}
+
+/* <- багаторядковий коментар
+Функції можуть мати параметри та повертати довільну кількість значень.
+В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертається.
+Зверніть увагу, що `x` та `sum` мають тип `int`.
+*/
+func learnMultiple(x, y int) (sum, prod int) {
+	return x + y, x * y // Повернути два значення.
+}
+
+// Кілька вбудованих типів та літералів.
+func learnTypes() {
+	// Короткі оголошення зазвичай виконують все, що необхідно.
+	str := "Вчи Go!" // рядок (string).
+
+	s2 := `"Необроблений" текст
+може містити переноси рядків.` // Те й же рядок.
+
+	// Не ASCII символи. Go використовує UTF-8.
+	g := 'Σ' // руничний тип, псевдонім для int32, містить позицію юнікод кода.
+
+	f := 3.14195 // float64, IEEE-754 64-бітне число з плавуючою крапкою.
+	c := 3 + 4i  // complex128, комплекстні числа, що уявляють собою два float64.
+
+	// Синтакс ініціалізації з var.
+	var u uint = 7 // Беззнаковий цілочисельний тип, проте розмір залежить від імплементації, так само як і int.
+	var pi float32 = 22. / 7
+
+	// Синтакс перетворення типів з коротним оголошенням.
+	n := byte('\n') // Байт - це переіменований uint8.
+
+	// Розмір масива фіксований протягом часу виконання.
+	var a4 [4]int           // Масив з 4 чисел, всі проініціалізовані 0.
+	a5 := [...]int{3, 1, 5, 10, 100} // Масив проініціалізованих чисел з фіксованим розміром у 
+	// п'ять елементів, що мають значення 3, 1, 5, 10, та 100.
+
+	// Зрізи мають динамічний розмір. Переваги є і у масивів, й у зрізів, проте
+	// останні викоритовуються частіше.
+	s3 := []int{4, 5, 9}    // Порівняйте з a5. Тут немає трьокрапки.
+	s4 := make([]int, 4)    // Виділяє пам'ять для зрізу з 4 чисел, проініціалізованих 0.
+	var d2 [][]float64      // Декларація, нічого не виділяється.
+	bs := []byte("a slice") // Синтаксис переведення у інший тип.
+
+	// Оскільки зрізи динамічні, до них можна додавати елементи за необхідністю.
+	// Для цієї операції використовується вбудована функція append().
+	// Перший аргумент - це зріз, до якого додається елемент. Зазвичай 
+	// змінна масиву оновлюється на місці, як у прикладі нище.
+	s := []int{1, 2, 3}		// В результаті отримуємо зріз із 3 чисел.
+	s = append(s, 4, 5, 6)	// додаємо 3 елементи. Зріз тепер довжини 6.
+	fmt.Println(s) // Оновлений зріз тепер має значення [1 2 3 4 5 6]
+
+	// Щоб об'єднати два зрізи, замість того, щоб проходитись по всім елементам,
+	// можна передати посилання на зріз із трьокрамкою, як у прикладі нище. Таким чином,
+	// зріз розпакується і його елементи додадуться до зріза s.
+	s = append(s, []int{7, 8, 9}...)
+	fmt.Println(s)	// Оновлений зріз тепер дорівнює [1 2 3 4 5 6 7 8 9]
+
+	p, q := learnMemory() // Оголошує змінні p, q, що є вказівниками на числа.
+	fmt.Println(*p, *q)   // * іде попереду вказівника. Таким чином, видодяться числа.
+
+	// Асоціативний масив (map) - це динамічно розширюваний тип данних, як хеш
+	// або словник в інших мовах програмування
+	m := map[string]int{"three": 3, "four": 4}
+	m["one"] = 1
+
+	// В Go  змінні, які не використовуються, вважаються помилкою.
+	// Нижнє підкреслювання дозволяє "використати" змінну, але проігноруванти значення.
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs
+	// Зазвичай це використовується, щоб проігнорувати значення, що повертає функція.
+	// Наприклад, в скрипті нашвидкоруч можна проігнорувати помилку, яку повертає
+	// функція os.Create, вважаючи, що файл буде створений за будь-яких умов.
+	file, _ := os.Create("output.txt")
+	fmt.Fprint(file, "Приклад, як відбувається запис у файл.")
+	file.Close()
+	
+	// Вивід значень змінних.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	learnFlowControl() // Рухаємось далі.
+}
+
+// Навідмінну від більшості інших мов програмування, функції в Go підтримують 
+// іменоване значення, що повертається. 
+// Змінні, значення яких повертається функцією, вказуються із зазначенням типу при
+// оголошенні функції. Таким чином, можна з легкістю повернути їх значення в різних
+// точках коду, не перелічуючи їх після ключового слова return.
+func learnNamedReturns(x, y int) (z int) {
+	z = x * y
+	return // z не потрібно вказувати, при оголошенні описано змінну для повернення.
+}
+
+// Go використовує сміттєзбірник. В ньому використовуються вказіники, проте немає 
+// операцій з вказівниками. Можлива помилка при використовуванні вказівника nil, але не 
+// при збільшенні значення вказівника (перехід по адресам пам'яті). 
+func learnMemory() (p, q *int) {
+	// Іменованні змінні, що повертаються, p та q, мають тип вказівника на чисельне значення.
+	p = new(int) // Вбудована функція виділяє нову пам'ять.
+	// Виділена адреса пам'яті чисельного типу int ініціалізовується 0, p більше не nil.
+	s := make([]int, 20) // Виділити пам'ять для 20 чисел у вигляді суцільного блоку в пам'яті.
+	s[3] = 7             // Присвоїти значення одному з них.
+	r := -2              // Оголосити нову локальну змінну.
+	return &s[3], &r     // Оператор & повертає адресу в пам'яті об'єкта.
+}
+
+func expensiveComputation() float64 {
+	return m.Exp(10)
+}
+
+func learnFlowControl() {
+	// if твердження вимагає фігурні дужки, але не вимагає округлих.
+	if true {
+		fmt.Println("Кажу ж")
+	}
+	// Форматування стандартизовано командою командного рядка "go fmt". 
+	if false {
+		// Pout.
+	} else {
+		// Gloat.
+	}
+	// Використання перемикача (switch) замість ланцюга if-стверджень.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// Кейси не "провалюються". Натомість, є ключове слово `fallthrough`:
+		// https://github.com/golang/go/wiki/Switch#fall-through (англ)
+	case 43:
+		// Недоступний.
+	default:
+		// Кейс за замовчуванням не обов'язковий.
+	}
+	// Як і if, формат оголошення циклу for не вимагає круглих дужок:
+	// Змінні, оголошені всередині if та for - належать цій області видимості.
+	for x := 0; x < 3; x++ { // ++ - це твердження.
+		fmt.Println("iteration", x)
+	}
+	// Тут x == 42.
+
+	// For - це єдиний в Go, але він бає кілька різних форм.
+	for { // Ініціалізація циклу.
+		break    // Упс, помилково зайшли.
+		continue // Недоступне твердження.
+	}
+
+	// Можна використовувати діапазони, зрізи, рядки, асоціативні масиви, або ж
+	// канал для ітерації в циклі. Діапазон (range) повертає один (канал) або два
+	// значення (масив, зріз, рядок та асоціативний масив).
+	for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
+		// для кожної пари в асоціативному масиві, надрукувати ключ та значення
+		fmt.Printf("key=%s, value=%d\n", key, value)
+	}
+	// якщо потрібне тільки значення, можна застосувати нижнє підкреслення як ключ
+	for _, name := range []string{"Bob", "Bill", "Joe"} {
+		fmt.Printf("Hello, %s\n", name)
+	}
+
+	// так само, як і з циклом for, оператор := в розгалудженні if одначає оголосити 
+	// локальну змінну y в області видимості if та присвоїти їх значення. Далі
+	// значення змінної проходить перевірку y > x.
+	if y := expensiveComputation(); y > x {
+		x = y
+	}
+	// Літерали функцій та замикання
+	// Function literals are closures.
+	xBig := func() bool {
+		return x > 10000 // Посилання на x, що був оголошений раніше, перед switch.
+	}
+	x = 99999
+	fmt.Println("xBig:", xBig()) // true
+	x = 1.3e3                    // Тобто, тепер x == 1300
+	fmt.Println("xBig:", xBig()) // false тепер.
+
+	// Функція може бути оголошена та викликана в одному рядку, поводячи себе 
+	// як аргумент функції, алк за наступних умов:
+	// 1) літерал функціх негайно викликається за допомогою ()
+	// 2) тип значення, що повертається, точно відповідає очікуваному типу аргументу
+	fmt.Println("Add + double two numbers: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Викликаємо з аргументами 10 та 2
+	// => Додати + подвоїти два числа: 24
+
+	// Коли вам це знадобиться, ви полюбите це
+	goto love
+love:
+
+	learnFunctionFactory() // функція, що повертає функцію - це весело(3)(3)
+	learnDefer()      // Швидкий обхід до важливого ключового слова.
+	learnInterfaces() // Тут на вас чекає крута штука!
+}
+
+func learnFunctionFactory() {
+	// Два наступних твердження роблять однакові дії, але другий приклад частіше 
+	// застосовується
+	fmt.Println(sentenceFactory("summer")("A beautiful", "day!"))
+
+	d := sentenceFactory("summer")
+	fmt.Println(d("A beautiful", "day!"))
+	fmt.Println(d("A lazy", "afternoon!"))
+}
+
+// Декоратори звична річ для багатьох мов прогрмування. В Go їх можна реалізувати
+// за допомогою літералів функцій, що прикмають агрументи.
+func sentenceFactory(mystring string) func(before, after string) string {
+	return func(before, after string) string {
+		return fmt.Sprintf("%s %s %s", before, mystring, after) // новий рядок
+	}
+}
+
+func learnDefer() (ok bool) {
+	// Відкладете тверодження змушує функцію посилатись по список. Список 
+	// збережених викликів виконується ПІСЛЯ того, як оточуюча функція закінчує
+	// виконання.
+	defer fmt.Println("відкладені твердження виконуються у зворотньому порядку (LIFO).")
+	defer fmt.Println("\nЦей рядок надрукується першим, тому що")
+	// Відкладення зазвичай використовується для того, щоб закрити файл. Таким чином,
+	// функція, що закриває файл, залишається близькою до функції, що вікриває файл.
+	return true
+}
+
+// Оголошує Stringer як тип інтерфейсу з одним методом, String.
+type Stringer interface {
+	String() string
+}
+
+// Оголошує pair як структуру з двома полями, цілими числами x та y.
+type pair struct {
+	x, y int
+}
+
+// Оголошує метод для типу pair. pair тепер реалізує Stringer, оскільки pair оголосив
+// всі методи в цьому інтерфейсі.
+func (p pair) String() string { // p тепер називається "приймачем"
+	// Sprintf - ще ожна функція з пакету fmt.
+	// Крапка використовується, щоб звернутись до полів об'єкту p.
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+	// Синтакс з використанням фігурних дужок називається "літералом стуктури".
+	// Він застосовується до ініціалізованої структури. Оператор := оголошує
+	// на ініціалізовує p цією структурою.
+	p := pair{3, 4}
+	fmt.Println(p.String()) // Викликає метод String об'єкта p типу pair.
+	var i Stringer          // Оголошує і інтерфейсного типу Stringer.
+	i = p                   // Допустиме, оскільки pair реалізує Stringer
+	// Викликає метод String об'єкта і, що має тип Stringer. Виводить те ж саме, що й 
+	// аналогічний метод вище.
+	fmt.Println(i.String())
+
+	// Функції з бібліотеки fmt викликають метод String, щоб запросити у об'єкта
+	// своє представлення, яке можна надрукувати.
+	fmt.Println(p) // Виводить те ж саме, що й раніше.
+	fmt.Println(i) // Виводить те ж саме, що й раніше.
+
+	learnVariadicParams("great", "learning", "here!")
+}
+
+// Кількість аргументів функції може бути змінною.
+func learnVariadicParams(myStrings ...interface{}) {
+	// Пройтись по значенням всіх аргументів.
+	// _ - це ігнорування порядкового номеру аргумента в масиві.
+	for _, param := range myStrings {
+		fmt.Println("param:", param)
+	}
+
+	// Передати значення аргументів як параметр змінної величини.
+	fmt.Println("params:", fmt.Sprintln(myStrings...))
+
+	learnErrorHandling()
+}
+
+func learnErrorHandling() {
+	// Ідіома ", ok"використовується, щоб повідомичи чи щось спрацювало, чи ні.
+	m := map[int]string{3: "three", 4: "four"}
+	if x, ok := m[1]; !ok { // ok буде мати значення false, тому що 1 не знаходиться 
+							// в асоціативному масиві.
+		fmt.Println("немає таких")
+	} else {
+		fmt.Print(x) // x буде мати значення 1, якщо 1 знаходиться в m.
+	}
+	// Значення помилки повідомляє не тільки, що все добре, але й може розповісти 
+	// більше про проблему.
+	if _, err := strconv.Atoi("non-int"); err != nil { // _ ігнорує значення
+		// виводить помилку 'strconv.ParseInt: parsing "non-int": invalid syntax'
+		fmt.Println(err)
+	}
+	// Ми розглянемо інтерфейси дещо пізніше. А поки, розглянемо багатопоточність.
+	learnConcurrency()
+}
+
+// Канал с - це потокозохіщений об'єкт для спілкування між потоками.
+func inc(i int, c chan int) {
+	c <- i + 1 // Оператор <- виконує операцію "надіслати",якщо змінна каналу 
+			   // знаходиться зліва від нього.
+}
+
+// inc виконує збільшення значення на 1. Ви використаємо його, щоб інкрементувати
+// числа рівночасно.
+func learnConcurrency() {
+	// вже знайома функція make, яка раніше використовувалась для виділення пам'яті, 
+	// тут використовується для створення каналу. Make виділяє пам'ять та ініціалізує
+	// зрізи, асоціовані масиви та канали. Новостворений канал буде передавати 
+	// цілочисельні значення.
+	c := make(chan int)
+	// Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовіно
+	// паралельно якщо пристрій здатний до цього та правильно сконфігурований.
+	// Всі три ґорутини надсилають значення в один канал.
+	go inc(0, c) // Твердження go запускає нову ґорутину.
+	go inc(10, c)
+	go inc(-805, c)
+	// Читаємо три результати з каналу та друкуємо їх.
+	// Порядок результатів - невідомий!
+	fmt.Println(<-c, <-c, <-c) // якщо канал знаходиться справа від оператора <-, 
+								// він виконує функцію "приймача".
+
+	cs := make(chan string)       // Ще один канал, який примає рядки.
+	ccs := make(chan chan string) // Канал каналів рядків.
+	go func() { c <- 84 }()       // Запустимо нову ґорутину, щоб надіслати значення в канал с.
+	go func() { cs <- "wordy" }() // Надсилаємо "wordy" в канал cs.
+	// Ключове слово select має подібний до синтаксис до switch, проте кожен кейс
+	// включає в себе операцію з каналом. Він обирає довільний кейс з наявних, які готові
+	// комунікувати (передавати дані).
+	select {
+	case i := <-c: // Отримане значення може бути присвоєне змінній,
+		fmt.Printf("it's a %T", i)
+	case <-cs: // або значення може бути проігнороване.
+		fmt.Println("it's a string")
+	case <-ccs: // Пустий канал, не готовий комунікувати.
+		fmt.Println("Не відбудеться.")
+	}
+	// На цьому етапі, значення було прочитане або з с або з cs. Одна з двох
+	// ґорутин завершилась, але інша все ще заблокована.
+
+	learnWebProgramming() // Go вмає й веб. Так, ти хочеш зробити це.
+}
+
+// Лиш одна функція з пакету http запускає веб сервер.
+func learnWebProgramming() {
+	
+	// перший аргумент ListenAndServe - це TCP адрес, який сервер буде слухати.
+	// Другий аргумент - це інтерфейс, а точніше http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", pair{})
+		fmt.Println(err) // не ігноруйте помилки
+	}()
+
+	requestServer()
+}
+
+// pair матиме тип http.Handler, якщо реалізувати один його метод, ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Відповідати на запити можна методом, що належить http.ResponseWriter.
+	w.Write([]byte("Ти вивчив Go за Y хвилин!"))
+}
+
+func requestServer() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nWebserver said: `%s`", string(body))
+}
+```
+
+## Подальше вивчення
+
+Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно погратись та багато про що почитати.
+Окрім туру, у [документації](https://golang.org/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів.
+
+Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами).
+
+Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) до тестів та коду в твоєму браузері, без встановлення Go.
+
+В списку для прочитання новичкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно продукоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
+Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/pkg/) щоб перейти до її реалізації.
+
+Іншим прекрасним посиланням для вивчення Go є [Go by example](https://gobyexample.com/).
+
+Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go  для мобільних застосунків або написати бібіотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile).
-- 
cgit v1.2.3


From 2c8c0caa16d8deaed4139b152caeea037ac9e8fe Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Wed, 30 Oct 2019 22:53:44 +0200
Subject: [cypher/uk-ua] Add ukrainian translation for Cypher query language

---
 uk-ua/cypher-ua.html.markdown | 254 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 254 insertions(+)
 create mode 100644 uk-ua/cypher-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/cypher-ua.html.markdown b/uk-ua/cypher-ua.html.markdown
new file mode 100644
index 00000000..9cfa35ca
--- /dev/null
+++ b/uk-ua/cypher-ua.html.markdown
@@ -0,0 +1,254 @@
+---
+language: cypher
+filename: LearnCypher.cql
+contributors:
+    - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтакс SQL та перемішує його з таким собі ascii стилем для відображення стуктури графа.
+Цей навчальний матеріал передбачає, що ви вже знайомі із концепцією графів, зобрема що таке вершини та зв'язки між ними.
+
+[Деталі тут](https://neo4j.com/developer/cypher-query-language/)
+
+
+Вершини
+---
+
+**Відображує запис у графі.**
+
+`()`
+Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
+
+`(n)`
+Це вершина яка має назву **n**, можна повторно користуватись нею у запиті. Звернення до вершини **n** починається з нижнього підкреслення та викоритовує camelCase (верблюжий регіст).
+
+`(p:Person)`
+Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та викоритовує верблюжу нотацію.
+
+`(p:Person:Manager)`
+Вершина може мати кілька *ярликів*.
+
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
+Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починаєтися з великої літери та використовувати верблюжу нотацію.
+
+Наступні типи дозволяється викоритовувати у властивостях:
+
+ - Чиселиний
+ - Булевий
+ - Рядок
+ - Списки попередніх примітивних типів
+
+*Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.*
+
+`p.name`
+За допомогою крапки можна звернутись до властивості вершини.
+
+
+Зв'язки (або ребра)
+---
+
+**Сполучають дві вершини**
+
+`[:KNOWS]`
+Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
+
+`[k:KNOWS]`
+Те же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково. 
+
+`[k:KNOWS {since:2017}]`
+Те й же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивіть - це  **since**.
+
+`[k:KNOWS*..4]`
+Це стуктурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
+
+
+Шляхи
+---
+
+**Спосіб поєднувати вершини та зв'язки.**
+
+`(a:Person)-[:KNOWS]-(b:Person)`
+Шлях описує, що вершини **a** та **b** знають (knows) один одного.
+
+`(a:Person)-[:MANAGES]->(b:Person)`
+Шлях може бути направленим. Цей описує, що **а** є менеджером **b**.
+
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
+Можна створювати ланцюги зі зв'язків. Цей шлях описує друга друга (**a** знає **b**, який в свою чергу знає **c**).
+
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
+Ланцюг, аналогічно, також може бути направленим. Шлях описує, що **a** -  бос **b** і супер бос для **c**.
+
+Шаблони, які часто викоритовуються (з документації Neo4j):
+
+```
+// Друг-мого-друга 
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Найкоротший шлях
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Спільна фільтрація
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Навігація по дереву
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Запити на створення
+---
+
+Створити нову вершину:
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN`  дозволяє повернути результат після виконання запиту. Можна повертати кілька значень, наприклад, `RETURN a, b`.*
+
+Створити новий зв'язок (із двома вершинами):
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Запити на знаходження
+---
+
+Знайти всі вершини:
+```
+MATCH (n)
+RETURN n
+```
+
+Знайти вершини за ярликом:
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Знайти вершини за ярликом та властивостю:
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Знайти вершини відовідно до зв'язків (ненаправлених):
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Знайти вершини відовідно до зв'язків (направлених):
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Знайти вершини зо допомогою `WHERE`:
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`:
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Запити на оновлення
+---
+
+Оновити окрему властивість вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Оновити всі властивості вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Додати нову властивіть до вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Повісити ярлик на вершину:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Запити на видалення
+---
+
+Зидалити окрему вершину (пов'язані ребра повинні бути видалені перед цим): 
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Видалити властивість певної вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+
+*Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й  `DELETE`!*
+
+Видалити ярлик певної вершини: 
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Видалити всю базу даних: 
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+
+*Так, це `rm -rf /` на мові Cypher !*
+
+
+Інші корисні запити
+---
+
+`PROFILE`
+Перед виконанням, показати план виконання запитів.
+
+`COUNT(e)`
+Порахувати елементи (вершини та зв'язки), що відповідають **e**.
+
+`LIMIT x`
+Обмежити результат до x перших результатів.
+
+
+Особливі підказки
+---
+
+- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
+- Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
+- Використовуйте команднйи рядок Neo4j для написання запитів Cypher, це легко і швидко.
+- Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як  **OpenCypher**).
-- 
cgit v1.2.3


From b54c2de7e42095cce89a0400211680d04824ba90 Mon Sep 17 00:00:00 2001
From: Anastasiia Bondarenko <anastasiia.bondarenko@ring.com>
Date: Thu, 31 Oct 2019 20:44:37 +0200
Subject: Update uk-ua/kotlin-ua.html.markdown

Co-Authored-By: Andre Polykanine <ap@oire.me>
---
 uk-ua/kotlin-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown
index f32a43cd..6fd78323 100644
--- a/uk-ua/kotlin-ua.html.markdown
+++ b/uk-ua/kotlin-ua.html.markdown
@@ -3,7 +3,7 @@ language: kotlin
 contributors:
     - ["S Webber", "https://github.com/s-webber"]
 translators:
-	= ["AstiaSun", "https://github.com/AstiaSun"]
+    - ["AstiaSun", "https://github.com/AstiaSun"]
 filename: LearnKotlin.kt
 lang: uk-ua
 ---
-- 
cgit v1.2.3


From 172d93aae70577164de0c9a8d81e931562450508 Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Thu, 31 Oct 2019 22:03:05 +0200
Subject: remove mistakes in words according to the review

---
 uk-ua/kotlin-ua.html.markdown | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown
index f32a43cd..6e29a721 100644
--- a/uk-ua/kotlin-ua.html.markdown
+++ b/uk-ua/kotlin-ua.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["S Webber", "https://github.com/s-webber"]
 translators:
 	= ["AstiaSun", "https://github.com/AstiaSun"]
-filename: LearnKotlin.kt
+filename: LearnKotlin-uk.kt
 lang: uk-ua
 ---
 
@@ -56,7 +56,7 @@ fun main(args: Array<String>) {
     println(bazString)
 
     /*
-    Необроблений рядок розмежовується за допомогою потрійтих лапок (""").
+    Необроблений рядок розмежовується за допомогою потрійних лапок (""").
     Необроблені рядки можуть містити переніс рядка (не спеціальний символ \n) та 
     будь-які інші символи.
     */
@@ -102,7 +102,7 @@ fun helloWorld(val name : String) {
     println(hello()) // => Hello, world!
 
     /*
-    Параменти функції можуть бути помічені ключовим словом vararg. Це дозволяє 
+    Аргументи функції можуть бути помічені ключовим словом vararg. Це дозволяє 
     приймати довільну кількість аргументів функції зазначеного типу.
     */
     fun varargExample(vararg names: Int) {
@@ -113,7 +113,7 @@ fun helloWorld(val name : String) {
     varargExample(1, 2, 3) // => Argument has 3 elements
 
     /*
-    Коли фукнція складається з одного виразу, фігурні дужки не є обов'язковими. 
+    Коли функція складається з одного виразу, фігурні дужки не є обов'язковими. 
     Тіло функції вказується після оператора "=".
     */
     fun odd(x: Int): Boolean = x % 2 == 1
@@ -303,7 +303,7 @@ fun helloWorld(val name : String) {
         else -> println("none of the above")
     }
 
-    // "when" також може використовуватись як функція, що повератє значення.
+    // "when" також може використовуватись як функція, що повертає значення.
     var result = when (i) {
         0, 21 -> "0 or 21"
         in 1..20 -> "in the range 1 to 20"
@@ -313,7 +313,7 @@ fun helloWorld(val name : String) {
 
     /*
     Тип об'єкта можна перевірити використавши оператор is. Якщо перевірка проходить 
-    успішно, тоді можна використовувати об'єкт як данний тип не приводячи до ного 
+    успішно, тоді можна використовувати об'єкт як данний тип не приводячи до нього 
     додатково.
     */
     fun smartCastExample(x: Any) : Boolean {
@@ -345,7 +345,7 @@ fun helloWorld(val name : String) {
     }
 
     /*
-    Розширення - це ще один спобів розширити функціонал класу.
+    Розширення - це ще один спосіб розширити функціонал класу.
     Подібні методи розширення реалізовані у С#.
     */
     fun String.remove(c: Char): String {
@@ -375,7 +375,7 @@ fun printName() = println(EnumExample.A.name) // => A
 fun printPosition() = println(EnumExample.A.ordinal) // => 0
 
 /*
-Ключове слово object можна виокристати для створення об'єкту сінглтону. Об'єкт не 
+Ключове слово object можна використати для створення об'єкту сінглтону. Об'єкт не 
 можна інстанціювати, проте на його унікальний екземпляр можна посилатись за іменем.
 Подібна можливість є в сінглтон об'єктах у Scala. 
 */
@@ -399,7 +399,7 @@ fun useSingletonObject() {
 
 
 /* 
-Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає ексепшн, якщо значення рівне null.
+Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає виняток, якщо значення рівне null.
 */
 var b: String? = "abc"
 val l = b!!.length
-- 
cgit v1.2.3


From 6a68f03b5801caf8041c45515a9cc1fa70a7b566 Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Thu, 31 Oct 2019 22:16:50 +0200
Subject: Update word misspelling indicated in the review

---
 uk-ua/cypher-ua.html.markdown | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/cypher-ua.html.markdown b/uk-ua/cypher-ua.html.markdown
index 9cfa35ca..e1eef5a2 100644
--- a/uk-ua/cypher-ua.html.markdown
+++ b/uk-ua/cypher-ua.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: uk-ua
 ---
 
-Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтакс SQL та перемішує його з таким собі ascii стилем для відображення стуктури графа.
+Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтаксис SQL та перемішує його з таким собі ascii стилем для відображення структури графа.
 Цей навчальний матеріал передбачає, що ви вже знайомі із концепцією графів, зобрема що таке вершини та зв'язки між ними.
 
 [Деталі тут](https://neo4j.com/developer/cypher-query-language/)
@@ -23,18 +23,18 @@ Cypher - це мова запитів Neo4j для спрощення робот
 Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
 
 `(n)`
-Це вершина яка має назву **n**, можна повторно користуватись нею у запиті. Звернення до вершини **n** починається з нижнього підкреслення та викоритовує camelCase (верблюжий регіст).
+Це вершина, яка має назву **n**, до неї можна повторно звертатись у запиті. Звернення до вершини **n** починається з нижнього підкреслення та використовує camelCase (верблюжий регіст).
 
 `(p:Person)`
-Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та викоритовує верблюжу нотацію.
+Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та використовує верблюжу нотацію.
 
 `(p:Person:Manager)`
 Вершина може мати кілька *ярликів*.
 
 `(p:Person {name : 'Théo Gauchoux', age : 22})`
-Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починаєтися з великої літери та використовувати верблюжу нотацію.
+Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починатися з великої літери та використовувати верблюжу нотацію.
 
-Наступні типи дозволяється викоритовувати у властивостях:
+Наступні типи дозволяється використовувати у властивостях:
 
  - Чиселиний
  - Булевий
@@ -56,13 +56,13 @@ Cypher - це мова запитів Neo4j для спрощення робот
 Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
 
 `[k:KNOWS]`
-Те же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково. 
+Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково. 
 
 `[k:KNOWS {since:2017}]`
-Те й же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивіть - це  **since**.
+Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це  **since**.
 
 `[k:KNOWS*..4]`
-Це стуктурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
+Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
 
 
 Шляхи
@@ -82,7 +82,7 @@ Cypher - це мова запитів Neo4j для спрощення робот
 `(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
 Ланцюг, аналогічно, також може бути направленим. Шлях описує, що **a** -  бос **b** і супер бос для **c**.
 
-Шаблони, які часто викоритовуються (з документації Neo4j):
+Шаблони, які часто використовуються (з документації Neo4j):
 
 ```
 // Друг-мого-друга 
@@ -131,25 +131,25 @@ MATCH (a:Person)
 RETURN a
 ```
 
-Знайти вершини за ярликом та властивостю:
+Знайти вершини за ярликом та властивістю:
 ```
 MATCH (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
 
-Знайти вершини відовідно до зв'язків (ненаправлених):
+Знайти вершини відповідно до зв'язків (ненаправлених):
 ```
 MATCH (a)-[:KNOWS]-(b)
 RETURN a,b
 ```
 
-Знайти вершини відовідно до зв'язків (направлених):
+Знайти вершини відповідно до зв'язків (направлених):
 ```
 MATCH (a)-[:MANAGES]->(b)
 RETURN a,b
 ```
 
-Знайти вершини зо допомогою `WHERE`:
+Знайти вершини за допомогою `WHERE`:
 ```
 MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
 WHERE s.since = 2015
@@ -181,7 +181,7 @@ WHERE p.name = "Théo Gauchoux"
 SET p = {name: "Michel", age: 23}
 ```
 
-Додати нову властивіть до вершини:
+Додати нову властивіcть до вершини:
 ```
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
@@ -199,7 +199,7 @@ SET p:Internship
 Запити на видалення
 ---
 
-Зидалити окрему вершину (пов'язані ребра повинні бути видалені перед цим): 
+Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим):
 ```
 MATCH (p:Person)-[relationship]-()
 WHERE p.name = "Théo Gauchoux"
@@ -250,5 +250,5 @@ DELETE n, r
 
 - У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
 - Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
-- Використовуйте команднйи рядок Neo4j для написання запитів Cypher, це легко і швидко.
+- Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко.
 - Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як  **OpenCypher**).
-- 
cgit v1.2.3


From 368870f4cd82afebb6637ca27dfd4eeb5fd89d7e Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Thu, 31 Oct 2019 22:09:34 +0200
Subject: remove mistakes in words according to the review

---
 uk-ua/kotlin-ua.html.markdown | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown
index 01c507eb..5e79cc48 100644
--- a/uk-ua/kotlin-ua.html.markdown
+++ b/uk-ua/kotlin-ua.html.markdown
@@ -1,14 +1,15 @@
 ---
 language: kotlin
+filename: LearnKotlin-uk.kt
+lang: uk-ua
 contributors:
     - ["S Webber", "https://github.com/s-webber"]
 translators:
-	- ["AstiaSun", "https://github.com/AstiaSun"]
-filename: LearnKotlin-uk.kt
-lang: uk-ua
+    - ["AstiaSun", "https://github.com/AstiaSun"]
 ---
 
-Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера. Вона має 100% сумісність із Java.
+Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера. 
+Вона має 100% сумісність із Java.
 
 [Детальніше](https://kotlinlang.org/)
 
@@ -120,7 +121,7 @@ fun helloWorld(val name : String) {
     println(odd(6)) // => false
     println(odd(7)) // => true
 
-    // Якщо значення, що повертається функцією, може бути однозначно визначено, 
+    // Якщо тип значення, що повертається функцією, може бути однозначно визначено, 
     // його непотрібно вказувати.
     fun even(x: Int) = x % 2 == 0
     println(even(6)) // => true
@@ -156,7 +157,7 @@ fun helloWorld(val name : String) {
         }
     }
     /*
-    Щоб створити новий об'єкт, потрібно викликали конструктор класу.
+    Щоб створити новий об'єкт, потрібно викликати конструктор класу.
     Зазначте, що в Kotlin немає ключового слова new.
     */
     val fooExampleClass = ExampleClass(7)
@@ -180,17 +181,17 @@ fun helloWorld(val name : String) {
     val fooCopy = fooData.copy(y = 100)
     println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
 
-    // Об'єкти можуть бути знищенні кількома способами. 
+    // Об'єкти можуть бути деструктурувані кількома способами. 
     val (a, b, c) = fooCopy
     println("$a $b $c") // => 1 100 4
 
-    // знищення у циклі for
+    // деструктурування у циклі for
     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 також знищується
+    // Map.Entry також деструктурувуються
     for ((key, value) in mapData) {
         println("$key -> $value")
     }
@@ -206,14 +207,14 @@ fun helloWorld(val name : String) {
     println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
 
     /*
-    Стисок можна створити використовуючи функцію listOf.
+    Список можна створити використовуючи функцію listOf.
     Список буде незмінним, тобто елементи не можна буде додавати або видаляти.
     */
     val fooList = listOf("a", "b", "c")
     println(fooList.size) // => 3
     println(fooList.first()) // => a
     println(fooList.last()) // => c
-    // доступ до елементів злійснюється через їх порядковий номер.
+    // доступ до елементів здійснюється через їхні порядковий номер.
     println(fooList[1]) // => b
 
     // Змінні списки можна створити використовуючи функцію mutableListOf.
@@ -229,18 +230,18 @@ fun helloWorld(val name : String) {
 
     // mapOf створює асоціативний масив.
     val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
-    // Доступ до значень в асоціативних масивах здійснюється через їх ключі.
+    // Доступ до значень в асоціативних масивах здійснюється через їхні ключі.
     println(fooMap["a"]) // => 8
 
     /*
-    Послідовності представленні як колекції лінивих обчислень. Функція generateSequence
+    Послідовності представлені як колекції лінивих обчислень. Функція generateSequence
     створює послідовність.
     */
     val fooSequence = generateSequence(1, { it + 1 })
     val x = fooSequence.take(10).toList()
     println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
-    // Приклад використання послідовностей, генерація чисел Фібоначі:
+    // Приклад використання послідовностей, генерація чисел Фібоначчі:
     fun fibonacciSequence(): Sequence<Long> {
         var a = 0L
         var b = 1L
@@ -288,7 +289,7 @@ fun helloWorld(val name : String) {
     val message = if (num % 2 == 0) "even" else "odd"
     println("$num is $message") // => 5 is odd
 
-    // "when" використовується як альтернатива в ланцюзі "if-else if".
+    // "when" використовується як альтернатива ланцюгам "if-else if".
     val i = 10
     when {
         i < 7 -> println("first block")
-- 
cgit v1.2.3


From 210e9b50ee146eecd9bf9235790c7e8e1dfe6637 Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Fri, 1 Nov 2019 11:20:56 +0200
Subject: Fix discovered misspelling

---
 uk-ua/mips-ua.html.markdown | 122 ++++++++++++++++++++++----------------------
 1 file changed, 61 insertions(+), 61 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
index 20fa7638..8d4517fe 100644
--- a/uk-ua/mips-ua.html.markdown
+++ b/uk-ua/mips-ua.html.markdown
@@ -8,9 +8,9 @@ translators:
 lang: uk-ua
 ---
 
-Мова асемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропорцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
+Мова ассемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропроцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
 
-[Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
+[Детальніше](https://en.wikipedia.org/wiki/MIPS_architecture)
 
 ```asm
 # Коментарі позначені як'#'
@@ -22,7 +22,7 @@ lang: uk-ua
 .data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
 	   # в мовах програмування вищого рівня
 
-  # Змінна оголошується наступним чином: [назва]: .[тип] [значенння] 
+  # Змінна оголошується наступним чином: [назва]: .[тип] [значення] 
   # Наприклад:
   hello_world: .asciiz "Hello World\n"      # Оголосити текстову змінну
   num1: .word 42                            # word - це чисельний тип 32-бітного розряду
@@ -39,7 +39,7 @@ lang: uk-ua
   _float: .float 3.14                       # 4 байти
   _double: .double 7.0                      # 8 байтів
 
-  .align 2                                  # Вирівнення пам'яті даних, де число
+  .align 2                                  # Вирівнювання пам'яті даних, де число
                                             # показує кількість байтів, вирівнених 
                                             # у степені 2. (.align 2 означає 
                                             # чисельне (word) вирівнювання оскільки 
@@ -63,15 +63,15 @@ lang: uk-ua
     syscall                                 # Виконує зазначену системну команду
                                             # з обраним аргументом ($a0)
 
-    # Регісти (використовуються, щоб тримати дані протягом виконання програми)
+    # Регістри (використовуються, щоб тримати дані протягом виконання програми)
     # $t0 - $t9                             # Тимчасові регістри використовуються
                                             # для проміжних обчислень всередині
                                             # підпрограм (не зберігаються між 
                                             # викликами функцій)
 
-    # $s0 - $s7                             # Збережені регісти, у яких значення 
-                                            # збегіраються між викликами підпрограм.
-                                            # Зазвичай збегрігаються у стеку.
+    # $s0 - $s7                             # Збережені регістри, у яких значення 
+                                            # зберігаються між викликами підпрограм.
+                                            # Зазвичай зберігаються у стеку.
 
     # $a0 - $a3                             # Регістри для передачі аргументів для 
                                             # підпрограм
@@ -82,28 +82,28 @@ lang: uk-ua
     la $t0, label                           # Скопіювати адресу в пам'яті, де 
                                             # зберігається значення змінної label 
                                             # в регістр $t0
-    lw $t0, label                           # Скопівати чисельне значення з пам'яті
-    lw $t1, 4($s0)                          # Скопівати чисельне значення з адреси
-                                            # пам'яті ресгіста зі зміщенням в 
+    lw $t0, label                           # Скопіювати чисельне значення з пам'яті
+    lw $t1, 4($s0)                          # Скопіювати чисельне значення з адреси
+                                            # пам'яті регістра зі зміщенням в 
                                             # 4 байти (адреса + 4)
     lb $t2, label                           # Скопіювати буквений символ в частину
                                             # нижчого порядку регістра $t2
     lb $t2, 0($s0)                          # Скопіювати буквений символ з адреси
                                             # в $s0 із зсувом 0
-    # Подіне використання і 'lh' для halfwords
+    # Подібне використання і 'lh' для halfwords
 
-    sw $t0, label                           # Збегігти чисельне значення в адресу в 
+    sw $t0, label                           # Зберегти чисельне значення в адресу в 
                                             # пам'яті, що відповідає змінній label
-    sw $t0, 8($s0)                          # Збегігти чисельне значення в адресу, 
-                                            # зазначеній у $s0, та зі зсувом у 8 байтів
+    sw $t0, 8($s0)                          # Зберегти чисельне значення в адресу, 
+                                            # що зазначена у $s0, та зі зсувом у 8 байтів
     # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords. 
     # 'sa' не існує
     
     
 ### Математичні операції ###
   _math:
-    # Пам'ятаємо, що попередньо потрібно завантажити данні в пам'ять
-    lw $t0, num                             # Із розділа з данними
+    # Пам'ятаємо, що попередньо потрібно завантажити дані в пам'ять
+    lw $t0, num                             # Із розділа з даними
     li $t0, 5                               # Або безпосередньо з константи
     li $t1, 6
     add $t2, $t0, $t1                       # $t2 = $t0 + $t1
@@ -114,39 +114,39 @@ lang: uk-ua
     div $t0, $t1                            # Виконує $t0 / $t1. Отримати частку можна
                                             # за допомогою команди 'mflo', остаток - 'mfhi'
 
-    # Bitwise Shifting
-    sll $t0, $t0, 2                         # Побітовий здвиг вліво з безпосереднім
-                                            # значенням (константою) 2
-    sllv $t0, $t1, $t2                      # Здвиг вліво зі змінною кількістю у
+    # Бітовий зсув
+    sll $t0, $t0, 2                         # Побітовий зсув вліво на 2. Біти вищого порядку
+                                            # не зберігаються, нищого - заповнюються 0
+    sllv $t0, $t1, $t2                      # Зсув вліво зі змінною кількістю у
                                             # регістрі
-    srl $t0, $t0, 5                         # Побітовий здвиг вправо (не збегігає 
-                                            # знак, знак розширюється 0)
-    srlv $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у
-                                            # регістрі
-    sra $t0, $t0, 7                         # Побітовий арифметичний збвиг вправо 
-                                            # (зберігає знак)
-    srav $t0, $t1, $t2                      # Здвиг вправо зі змінною кількістю у 
+    srl $t0, $t0, 5                         # Побітовий зсув вправо на 5 (не зберігає 
+                                            # біти, біти зліва заповнюються 0)
+    srlv $t0, $t1, $t2                      # Зсув вправо зі змінною кількістю у
                                             # регістрі
+    sra $t0, $t0, 7                         # Побітовий арифметичний зсув вправо 
+                                            # (зберігає біти)
+    srav $t0, $t1, $t2                      # Зсув вправо зі змінною кількістю у 
+                                            # регістрі зі збереження значеннь бітів
 
-    # Bitwise operators
+    # Побітові операції
     and $t0, $t1, $t2                       # Побітове І (AND)
-    andi $t0, $t1, 0xFFF                    # Побітове І з беспосереднім значенням
-    or $t0, $t1, $t2                        # Побітове АЛЕ (OR)
-    ori $t0, $t1, 0xFFF                     # Побітове АЛЕ з беспосереднім значенням
+    andi $t0, $t1, 0xFFF                    # Побітове І з безпосереднім значенням
+    or $t0, $t1, $t2                        # Побітове АБО (OR)
+    ori $t0, $t1, 0xFFF                     # Побітове АБО з безпосереднім значенням
     xor $t0, $t1, $t2                       # Побітова виключна диз'юнкція (XOR)
-    xori $t0, $t1, 0xFFF                    # Побітове XOR з беспосереднім значенням
+    xori $t0, $t1, 0xFFF                    # Побітове XOR з безпосереднім значенням
     nor $t0, $t1, $t2                       # Побітова стрілка Пірса (NOR)
 
 ## Розгалуження ##
   _branching:
-    # В овсновному інструкції розгалуження мають наступну форму:
+    # В основному інструкції розгалуження мають наступну форму:
     # <instr> <reg1> <reg2> <label>
     # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
     # правдиве
 
     beq $t0, $t1, reg_eq                    # Перейдемо у розгалуження reg_eq
                                             # якщо $t0 == $t1, інакше -
-                                            # винонати наступну строку
+                                            # виконати наступний рядок
     bne $t0, $t1, reg_neq                   # Розгалужується, якщо $t0 != $t1
     b branch_target                         # Розгалуження без умови завжди виконується
     beqz $t0, req_eq_zero                   # Розгалужується, якщо $t0 == 0
@@ -173,7 +173,7 @@ lang: uk-ua
     L1:
       sub $s0, $s0, $s3 # f = f - i
     
-    # Нижще наведений приклад знаходження максимального значееня з 3 чисел
+    # Нижче наведений приклад знаходження максимального значення з 3 чисел
     # Пряма трансляція в Java з логіки MIPS:
     # if (a > b)
     #   if (a > c)
@@ -185,13 +185,13 @@ lang: uk-ua
     #   else
     #     max = c;
 
-    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регіст
+    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регістр
     ble $s0, $s1, a_LTE_b                   # якщо (a <= b) розгалуження(a_LTE_b)
     ble $s0, $s2, max_C                     # якщо (a > b && a <=c) розгалуження(max_C)
     move $v0, $s1                           # інакше [a > b && a > c] max = a
     j done                                  # Перейти в кінець програми
 
-    a_LTE_b:                                # Мітка розгаруження, коли a <= b
+    a_LTE_b:                                # Мітка розгалуження, коли a <= b
       ble $s1, $s2, max_C                   # якщо (a <= b && b <= c) розгалуження(max_C)
       move $v0, $s1                         # якщо (a <= b && b > c) max = b
       j done                                # Перейти в кінець програми
@@ -203,16 +203,16 @@ lang: uk-ua
 
 ## Цикли ##
   _loops:
-    # Цикл складається з умови виходу та з інстукції переходу після його завершення
+    # Цикл складається з умови виходу та з інструкції переходу після його завершення
     li $t0, 0
     while:
-      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати інтерації
+      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати ітерації
       addi $t0, $t0, 1                      # Збільшити значення
       j while                               # Перейти на початок циклу
     end_while:
 
     # Транспонування 2D матриці
-    # Припустмо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
+    # Припустимо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
     li $t0, 0                               # Лічильник для i
     li $t1, 0                               # Лічильник для j
     matrix_row:
@@ -233,10 +233,10 @@ lang: uk-ua
 
 ## Функції ##
   _functions:
-    # Фукнції - це процедури, що викликаються, приймають аргументи та повертають значення
+    # Функції - це процедури, що викликаються, приймають аргументи та повертають значення
 
     main:                                 # Програма починається з головної функції
-      jal return_1                        # jal збереже поточний PC в $ra,
+      jal return_1                        # jal збереже поточний ПЦ (програмний центр) в $ra,
                                           # а потім перейде до return_1
 
       # Як передати аргументи?
@@ -246,36 +246,36 @@ lang: uk-ua
       jal sum                             # Тепер ми можемо викликати функцію
 
       # Як щодо рекурсії?
-      # Тут потрібно дещо більше роботи оскільки ми маємо впевнетись, що ми збережемо
-      # та зчитаємо попередній PC в $ra, оскільки jal автоматично перепише її при виклику
+      # Тут потрібно дещо більше роботи оскільки ми маємо впевнитись, що ми збережемо
+      # та зчитаємо попередній ПЦ в $ra, оскільки jal автоматично перепише її при виклику
       li $a0, 3
       jal fact
 
       li $v0, 10
       syscall
     
-    # Ця функйія повертає 1
+    # Ця функція повертає 1
     return_1:
       li $v0, 1                           # Завантажити val в регіст $v0
-      jr $ra                              # Повернутись до попереднього PC і продовжити виконання 
+      jr $ra                              # Повернутись до попереднього ПЦ і продовжити виконання 
 
 
-    # Function with 2 args
+    # Функція з двома аргументами
     sum:
       add $v0, $a0, $a1
       jr $ra                              # Повернутись
 
-    # Фекурсивна функція, яка знаходить факторіал
+    # Рекурсивна функція, яка знаходить факторіал
     fact:
       addi $sp, $sp, -8                   # Виділити місце в стеку
       sw $s0, ($sp)                       # Зберегти регістр, що містить поточне число
-      sw $ra, 4($sp)                      # Зберегти попереднє PC
+      sw $ra, 4($sp)                      # Зберегти попередній ПЦ
 
-      li $v0, 1                           # Проініціліазувати значення, що повертатиметься
+      li $v0, 1                           # Проініціалізувати значення, що повертатиметься
       beq $a0, 0, fact_done               # Закінчити, якщо параметр 0
 
       # Інакше, продовжити рекурсію
-      move $s0, $a0                       # Скоріювати $a0 в $s0
+      move $s0, $a0                       # Скопіювати $a0 в $s0
       sub $a0, $a0, 1
       jal fact
 
@@ -283,7 +283,7 @@ lang: uk-ua
 
       fact_done:
         lw $s0, ($sp)
-        lw $ra, ($sp)                     # Відновити PC
+        lw $ra, ($sp)                     # Відновити ПЦ
         addi $sp, $sp, 8
 
         jr $ra
@@ -295,9 +295,9 @@ lang: uk-ua
     # Це не заміна функцій.
     # Вони мають бути оголошені перед використанням
 
-    # Макрос для виведення нових строк (оскільки операція лосить часто виконується)
+    # Макрос для виведення нових рядків (оскільки операція досить часто виконується)
     .macro println()
-      la $a0, newline                     # Значення нової строки зберігатиметься тут
+      la $a0, newline                     # Значення нового рядка зберігатиметься тут
       li $v0, 4
       syscall
     .end_macro
@@ -316,7 +316,7 @@ lang: uk-ua
     li $t0, 1
     print_int($t0)
     
-    # Ми таком можемо передавати безпосередньо значення в макроси
+    # Значення також можна передавати безпосередньо в макроси
     .macro immediates(%a, %b)
       add $t0, %a, %b
     .end_macro
@@ -336,13 +336,13 @@ lang: uk-ua
 .data
   list: .word 3, 0, 1, 2, 6                 # Це масив чисел
   char_arr: .asciiz "hello"                 # Це текстовий масив
-  buffer: .space 128                        # Видтляє блок пам'яті, що
+  buffer: .space 128                        # Виділяє блок пам'яті, що
                                             # автоматично не очищується
-                                            # Ці блоки пам'яті вирівнюють
-                                            # оддин одного
+                                            # Ці блоки пам'яті вирівнені
+                                            # вирівнені поруч один з одним
 
 .text
-  la $s0, list                              # Завантажити адрегу у список
+  la $s0, list                              # Завантажити адресу списку
   li $t0, 0                                 # Лічильник
   li $t1, 5                                 # Довжина списку
 
@@ -359,7 +359,7 @@ lang: uk-ua
   end_loop:
 
 ## Включення ##
-# Це потрібно для імпорту стороннії файлівв програму (але насправді, код з цього файлу 
+# Потрібно для імпорту сторонніх файлів у програму (насправді, код з цього файлу 
 # копіюється та вставляється в місце, де оголошений імпорт)
 .include "somefile.asm"
 
-- 
cgit v1.2.3


From 69ef8d3f3a7df9d116b9df937569fb6d00db96e8 Mon Sep 17 00:00:00 2001
From: AstiaSun <anastasiia.bondarenko@ring.com>
Date: Fri, 1 Nov 2019 11:39:36 +0200
Subject: Fix discovered misspelling

---
 uk-ua/go-ua.html.markdown | 99 +++++++++++++++++++++++------------------------
 1 file changed, 49 insertions(+), 50 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
index 8c9e9de7..933b34f9 100644
--- a/uk-ua/go-ua.html.markdown
+++ b/uk-ua/go-ua.html.markdown
@@ -21,7 +21,7 @@ Go був створений для того, щоб виконати задач
 
 Він увібрав принципи з імперативних мов зі статичною типізацією.
 Go швидко компілюється та виконується, а його багатопоточність легка для
-вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 міліонів в Google, Inc.)
+вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 мільйонів в Google, Inc.)
 
 Go має чудову стандартну бібліотеку та чимале ком'юніті.
 
@@ -30,11 +30,11 @@ Go має чудову стандартну бібліотеку та чимал
 /* Багато-
  рядковий коментар */
 
-// Кожен файл вихідного коду має почитанитсь із ключового слова package.
+// Кожен файл вихідного коду має починатись із ключового слова package.
 // main - це спеціальна назва, що оголошує виконуваний код, а не бібліотеку.
 package main
 
-// import оголошує бібліотеки, що використовуються в данному файлі.
+// import оголошує бібліотеки, що використовуються в даному файлі.
 import (
 	"fmt"       // Пакет стандартної бібліотеки Go.
 	"io/ioutil" // Цей пакет реалізує деякі I/O функції утиліт.
@@ -56,8 +56,8 @@ func main() {
 	beyondHello()
 }
 
-// Аргумети функцій описуються у круглих дужках.
-// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обовязкові.
+// Аргументи функцій описуються у круглих дужках.
+// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обов`язкові.
 func beyondHello() {
 	var x int // Оголошення змінної. Перед використанням змінні обов'язково мають бути оголошені.
 	x = 3     // Присвоєння значення.
@@ -70,7 +70,7 @@ func beyondHello() {
 
 /* <- багаторядковий коментар
 Функції можуть мати параметри та повертати довільну кількість значень.
-В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертається.
+В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертаються.
 Зверніть увагу, що `x` та `sum` мають тип `int`.
 */
 func learnMultiple(x, y int) (sum, prod int) {
@@ -83,19 +83,19 @@ func learnTypes() {
 	str := "Вчи Go!" // рядок (string).
 
 	s2 := `"Необроблений" текст
-може містити переноси рядків.` // Те й же рядок.
+може містити переноси рядків.` // Також має тип рядок.
 
 	// Не ASCII символи. Go використовує UTF-8.
 	g := 'Σ' // руничний тип, псевдонім для int32, містить позицію юнікод кода.
 
-	f := 3.14195 // float64, IEEE-754 64-бітне число з плавуючою крапкою.
-	c := 3 + 4i  // complex128, комплекстні числа, що уявляють собою два float64.
+	f := 3.14195 // float64, IEEE-754 64-бітне число з плаваючою крапкою.
+	c := 3 + 4i  // complex128, комплексні числа, що являють собою два float64.
 
-	// Синтакс ініціалізації з var.
+	// Синтаксис ініціалізації з var.
 	var u uint = 7 // Беззнаковий цілочисельний тип, проте розмір залежить від імплементації, так само як і int.
 	var pi float32 = 22. / 7
 
-	// Синтакс перетворення типів з коротним оголошенням.
+	// Синтаксис перетворення типів з коротким оголошенням.
 	n := byte('\n') // Байт - це переіменований uint8.
 
 	// Розмір масива фіксований протягом часу виконання.
@@ -104,7 +104,7 @@ func learnTypes() {
 	// п'ять елементів, що мають значення 3, 1, 5, 10, та 100.
 
 	// Зрізи мають динамічний розмір. Переваги є і у масивів, й у зрізів, проте
-	// останні викоритовуються частіше.
+	// останні використовуються частіше.
 	s3 := []int{4, 5, 9}    // Порівняйте з a5. Тут немає трьокрапки.
 	s4 := make([]int, 4)    // Виділяє пам'ять для зрізу з 4 чисел, проініціалізованих 0.
 	var d2 [][]float64      // Декларація, нічого не виділяється.
@@ -113,27 +113,27 @@ func learnTypes() {
 	// Оскільки зрізи динамічні, до них можна додавати елементи за необхідністю.
 	// Для цієї операції використовується вбудована функція append().
 	// Перший аргумент - це зріз, до якого додається елемент. Зазвичай 
-	// змінна масиву оновлюється на місці, як у прикладі нище.
+	// змінна масиву оновлюється на місці, як у прикладі нижче.
 	s := []int{1, 2, 3}		// В результаті отримуємо зріз із 3 чисел.
 	s = append(s, 4, 5, 6)	// додаємо 3 елементи. Зріз тепер довжини 6.
 	fmt.Println(s) // Оновлений зріз тепер має значення [1 2 3 4 5 6]
 
 	// Щоб об'єднати два зрізи, замість того, щоб проходитись по всім елементам,
-	// можна передати посилання на зріз із трьокрамкою, як у прикладі нище. Таким чином,
+	// можна передати посилання на зріз із трьокрапкою, як у прикладі нижче. Таким чином,
 	// зріз розпакується і його елементи додадуться до зріза s.
 	s = append(s, []int{7, 8, 9}...)
 	fmt.Println(s)	// Оновлений зріз тепер дорівнює [1 2 3 4 5 6 7 8 9]
 
 	p, q := learnMemory() // Оголошує змінні p, q, що є вказівниками на числа.
-	fmt.Println(*p, *q)   // * іде попереду вказівника. Таким чином, видодяться числа.
+	fmt.Println(*p, *q)   // * іде попереду вказівника. Таким чином, виводяться числа.
 
-	// Асоціативний масив (map) - це динамічно розширюваний тип данних, як хеш
+	// Асоціативний масив (map) - це динамічно розширюваний тип даних, як хеш
 	// або словник в інших мовах програмування
 	m := map[string]int{"three": 3, "four": 4}
 	m["one"] = 1
 
 	// В Go  змінні, які не використовуються, вважаються помилкою.
-	// Нижнє підкреслювання дозволяє "використати" змінну, але проігноруванти значення.
+	// Нижнє підкреслення дозволяє "використати" змінну, але проігнорувати значення.
 	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs
 	// Зазвичай це використовується, щоб проігнорувати значення, що повертає функція.
 	// Наприклад, в скрипті нашвидкоруч можна проігнорувати помилку, яку повертає
@@ -148,21 +148,21 @@ func learnTypes() {
 	learnFlowControl() // Рухаємось далі.
 }
 
-// Навідмінну від більшості інших мов програмування, функції в Go підтримують 
+// Навідміну від більшості інших мов програмування, функції в Go підтримують 
 // іменоване значення, що повертається. 
 // Змінні, значення яких повертається функцією, вказуються із зазначенням типу при
-// оголошенні функції. Таким чином, можна з легкістю повернути їх значення в різних
+// оголошенні функції. Таким чином, можна з легкістю повернути їхні значення в різних
 // точках коду, не перелічуючи їх після ключового слова return.
 func learnNamedReturns(x, y int) (z int) {
 	z = x * y
 	return // z не потрібно вказувати, при оголошенні описано змінну для повернення.
 }
 
-// Go використовує сміттєзбірник. В ньому використовуються вказіники, проте немає 
+// Go використовує сміттєзбірник. В ньому використовуються вказівники, проте немає 
 // операцій з вказівниками. Можлива помилка при використовуванні вказівника nil, але не 
 // при збільшенні значення вказівника (перехід по адресам пам'яті). 
 func learnMemory() (p, q *int) {
-	// Іменованні змінні, що повертаються, p та q, мають тип вказівника на чисельне значення.
+	// Іменовані змінні, що повертаються, p та q, мають тип вказівника на чисельне значення.
 	p = new(int) // Вбудована функція виділяє нову пам'ять.
 	// Виділена адреса пам'яті чисельного типу int ініціалізовується 0, p більше не nil.
 	s := make([]int, 20) // Виділити пам'ять для 20 чисел у вигляді суцільного блоку в пам'яті.
@@ -186,7 +186,7 @@ func learnFlowControl() {
 	} else {
 		// Gloat.
 	}
-	// Використання перемикача (switch) замість ланцюга if-стверджень.
+	// Використання перемикача (switch) замість ланцюга if-тверджень.
 	x := 42.0
 	switch x {
 	case 0:
@@ -206,7 +206,7 @@ func learnFlowControl() {
 	}
 	// Тут x == 42.
 
-	// For - це єдиний в Go, але він бає кілька різних форм.
+	// For - це єдиний цикл в Go, проте він має кілька різних форм.
 	for { // Ініціалізація циклу.
 		break    // Упс, помилково зайшли.
 		continue // Недоступне твердження.
@@ -224,14 +224,13 @@ func learnFlowControl() {
 		fmt.Printf("Hello, %s\n", name)
 	}
 
-	// так само, як і з циклом for, оператор := в розгалудженні if одначає оголосити 
-	// локальну змінну y в області видимості if та присвоїти їх значення. Далі
+	// так само, як і з циклом for, оператор := в розгалуженні означає оголосити 
+	// локальну змінну в області видимості if та присвоїти значення. Далі
 	// значення змінної проходить перевірку y > x.
 	if y := expensiveComputation(); y > x {
 		x = y
 	}
-	// Літерали функцій та замикання
-	// Function literals are closures.
+	// Літерали функцій - це замикання
 	xBig := func() bool {
 		return x > 10000 // Посилання на x, що був оголошений раніше, перед switch.
 	}
@@ -241,8 +240,8 @@ func learnFlowControl() {
 	fmt.Println("xBig:", xBig()) // false тепер.
 
 	// Функція може бути оголошена та викликана в одному рядку, поводячи себе 
-	// як аргумент функції, алк за наступних умов:
-	// 1) літерал функціх негайно викликається за допомогою ()
+	// як аргумент функції, але за наступних умов:
+	// 1) літерал функції негайно викликається за допомогою ()
 	// 2) тип значення, що повертається, точно відповідає очікуваному типу аргументу
 	fmt.Println("Add + double two numbers: ",
 		func(a, b int) int {
@@ -269,8 +268,8 @@ func learnFunctionFactory() {
 	fmt.Println(d("A lazy", "afternoon!"))
 }
 
-// Декоратори звична річ для багатьох мов прогрмування. В Go їх можна реалізувати
-// за допомогою літералів функцій, що прикмають агрументи.
+// Декоратори звична річ для багатьох мов програмування. В Go їх можна реалізувати
+// за допомогою літералів функцій, що приймають аргументи.
 func sentenceFactory(mystring string) func(before, after string) string {
 	return func(before, after string) string {
 		return fmt.Sprintf("%s %s %s", before, mystring, after) // новий рядок
@@ -278,13 +277,13 @@ func sentenceFactory(mystring string) func(before, after string) string {
 }
 
 func learnDefer() (ok bool) {
-	// Відкладете тверодження змушує функцію посилатись по список. Список 
+	// твердження defer змушує функцію посилатись на список. Список 
 	// збережених викликів виконується ПІСЛЯ того, як оточуюча функція закінчує
 	// виконання.
 	defer fmt.Println("відкладені твердження виконуються у зворотньому порядку (LIFO).")
 	defer fmt.Println("\nЦей рядок надрукується першим, тому що")
 	// Відкладення зазвичай використовується для того, щоб закрити файл. Таким чином,
-	// функція, що закриває файл, залишається близькою до функції, що вікриває файл.
+	// функція, що закриває файл, залишається близькою до функції, що відкриває файл.
 	return true
 }
 
@@ -301,15 +300,15 @@ type pair struct {
 // Оголошує метод для типу pair. pair тепер реалізує Stringer, оскільки pair оголосив
 // всі методи в цьому інтерфейсі.
 func (p pair) String() string { // p тепер називається "приймачем"
-	// Sprintf - ще ожна функція з пакету fmt.
+	// Sprintf - ще одна функція з пакету fmt.
 	// Крапка використовується, щоб звернутись до полів об'єкту p.
 	return fmt.Sprintf("(%d, %d)", p.x, p.y)
 }
 
 func learnInterfaces() {
-	// Синтакс з використанням фігурних дужок називається "літералом стуктури".
+	// Синтаксис з використанням фігурних дужок називається "літералом структури".
 	// Він застосовується до ініціалізованої структури. Оператор := оголошує
-	// на ініціалізовує p цією структурою.
+	// та ініціалізує p цією структурою.
 	p := pair{3, 4}
 	fmt.Println(p.String()) // Викликає метод String об'єкта p типу pair.
 	var i Stringer          // Оголошує і інтерфейсного типу Stringer.
@@ -341,7 +340,7 @@ func learnVariadicParams(myStrings ...interface{}) {
 }
 
 func learnErrorHandling() {
-	// Ідіома ", ok"використовується, щоб повідомичи чи щось спрацювало, чи ні.
+	// Ідіома ", ok"використовується, щоб перевірити виконання команди без помилок.
 	m := map[int]string{3: "three", 4: "four"}
 	if x, ok := m[1]; !ok { // ok буде мати значення false, тому що 1 не знаходиться 
 							// в асоціативному масиві.
@@ -359,21 +358,21 @@ func learnErrorHandling() {
 	learnConcurrency()
 }
 
-// Канал с - це потокозохіщений об'єкт для спілкування між потоками.
+// Канал с - це потокозохищений об'єкт для спілкування між потоками.
 func inc(i int, c chan int) {
 	c <- i + 1 // Оператор <- виконує операцію "надіслати",якщо змінна каналу 
 			   // знаходиться зліва від нього.
 }
 
-// inc виконує збільшення значення на 1. Ви використаємо його, щоб інкрементувати
+// inc виконує збільшення значення на 1. Ми використаємо його, щоб збільшувати
 // числа рівночасно.
 func learnConcurrency() {
 	// вже знайома функція make, яка раніше використовувалась для виділення пам'яті, 
 	// тут використовується для створення каналу. Make виділяє пам'ять та ініціалізує
-	// зрізи, асоціовані масиви та канали. Новостворений канал буде передавати 
+	// зрізи, асоційовані масиви та канали. Новостворений канал буде передавати 
 	// цілочисельні значення.
 	c := make(chan int)
-	// Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовіно
+	// Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовірно
 	// паралельно якщо пристрій здатний до цього та правильно сконфігурований.
 	// Всі три ґорутини надсилають значення в один канал.
 	go inc(0, c) // Твердження go запускає нову ґорутину.
@@ -388,11 +387,11 @@ func learnConcurrency() {
 	ccs := make(chan chan string) // Канал каналів рядків.
 	go func() { c <- 84 }()       // Запустимо нову ґорутину, щоб надіслати значення в канал с.
 	go func() { cs <- "wordy" }() // Надсилаємо "wordy" в канал cs.
-	// Ключове слово select має подібний до синтаксис до switch, проте кожен кейс
+	// Ключове слово select має синтаксис, подібний до switch, проте кожен кейс
 	// включає в себе операцію з каналом. Він обирає довільний кейс з наявних, які готові
 	// комунікувати (передавати дані).
 	select {
-	case i := <-c: // Отримане значення може бути присвоєне змінній,
+	case i := <-c: // Отримане значення може бути присвоєно змінній,
 		fmt.Printf("it's a %T", i)
 	case <-cs: // або значення може бути проігнороване.
 		fmt.Println("it's a string")
@@ -402,13 +401,13 @@ func learnConcurrency() {
 	// На цьому етапі, значення було прочитане або з с або з cs. Одна з двох
 	// ґорутин завершилась, але інша все ще заблокована.
 
-	learnWebProgramming() // Go вмає й веб. Так, ти хочеш зробити це.
+	learnWebProgramming() // Go вміє й у веб. Так, ти хочеш зробити це.
 }
 
 // Лиш одна функція з пакету http запускає веб сервер.
 func learnWebProgramming() {
 	
-	// перший аргумент ListenAndServe - це TCP адрес, який сервер буде слухати.
+	// перший аргумент ListenAndServe - це TCP адреса, який сервер буде слухати.
 	// Другий аргумент - це інтерфейс, а точніше http.Handler.
 	go func() {
 		err := http.ListenAndServe(":8080", pair{})
@@ -435,16 +434,16 @@ func requestServer() {
 
 ## Подальше вивчення
 
-Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно погратись та багато про що почитати.
+Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати.
 Окрім туру, у [документації](https://golang.org/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів.
 
 Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами).
 
-Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) до тестів та коду в твоєму браузері, без встановлення Go.
+Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://uk.wikipedia.org/wiki/REPL) до тестів та коду в твоєму браузері, без встановлення Go.
 
-В списку для прочитання новичкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно продукоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
-Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/pkg/) щоб перейти до її реалізації.
+В списку для прочитання новачкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно задокоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
+Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/pkg/), щоб перейти до її реалізації.
 
 Іншим прекрасним посиланням для вивчення Go є [Go by example](https://gobyexample.com/).
 
-Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go  для мобільних застосунків або написати бібіотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile).
+Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go  для мобільних застосунків або написати бібліотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile).
-- 
cgit v1.2.3


From 4d1ca15adb85f919a05e7ea672157be5ebd9f885 Mon Sep 17 00:00:00 2001
From: tomdaly <tomdaly@users.noreply.github.com>
Date: Thu, 14 Nov 2019 13:17:56 +0000
Subject: Fix en-us 'Get the code' link downloading uk-ua source code for Go

---
 uk-ua/go-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
index 933b34f9..f980f7b1 100644
--- a/uk-ua/go-ua.html.markdown
+++ b/uk-ua/go-ua.html.markdown
@@ -2,7 +2,7 @@
 name: Go
 category: language
 language: Go
-filename: learngo.go
+filename: learngo-ua.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
     - ["Christopher Bess", "https://github.com/cbess"]
-- 
cgit v1.2.3


From aac08853c7f731a4b4be0710841cddfe2081fc8b Mon Sep 17 00:00:00 2001
From: tomdaly <tomdaly@users.noreply.github.com>
Date: Thu, 14 Nov 2019 13:21:25 +0000
Subject: Fix en-us 'Get the code' link downloading uk-ua source code for
 Cypher

---
 uk-ua/cypher-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/cypher-ua.html.markdown b/uk-ua/cypher-ua.html.markdown
index e1eef5a2..0911793b 100644
--- a/uk-ua/cypher-ua.html.markdown
+++ b/uk-ua/cypher-ua.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: cypher
-filename: LearnCypher.cql
+filename: LearnCypher-ua.cql
 contributors:
     - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
 translators:
-- 
cgit v1.2.3


From 1adab9bc3f80d82123987ff34083568030735db7 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 04:49:56 +0100
Subject: Rename Python 2 markdown files into 'pythonlegacy'

```
for f in $(find . -iname "*python*" | grep -vE 'python3|git|statcomp'); do
  flegacy=$(echo "$f" | sed 's/python/pythonlegacy/')
  git mv "$f" "$flegacy"
done
```
---
 uk-ua/python-ua.html.markdown       | 818 ------------------------------------
 uk-ua/pythonlegacy-ua.html.markdown | 818 ++++++++++++++++++++++++++++++++++++
 2 files changed, 818 insertions(+), 818 deletions(-)
 delete mode 100644 uk-ua/python-ua.html.markdown
 create mode 100644 uk-ua/pythonlegacy-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/python-ua.html.markdown b/uk-ua/python-ua.html.markdown
deleted file mode 100644
index 4091e433..00000000
--- a/uk-ua/python-ua.html.markdown
+++ /dev/null
@@ -1,818 +0,0 @@
----
-language: python
-lang: uk-ua
-contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
-    - ["Amin Bandali", "https://aminb.org"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["evuez", "http://github.com/evuez"]
-    - ["asyne", "https://github.com/justblah"]
-    - ["habi", "http://github.com/habi"]
-translators:
-    - ["Oleh Hromiak", "https://github.com/ogroleg"]
-filename: learnpython-ua.py
----
-
-Мову Python створив Гвідо ван Россум на початку 90-х. Наразі це одна з 
-найбільш популярних мов. Я закохався у Python завдяки простому і зрозумілому
-синтаксису. Це майже як виконуваний псевдокод.
-
-З вдячністю чекаю ваших відгуків: [@louiedinh](http://twitter.com/louiedinh)
-або louiedinh [at] [поштовий сервіс від Google]
-
-Примітка: Ця стаття стосується Python 2.7, проте має працювати і 
-у інших версіях Python 2.x. Python 2.7 підходить до кінця свого терміну, 
-його підтримку припинять у 2020, тож наразі краще починати вивчення Python 
-з версії 3.x.
-Аби вивчити Python 3.x, звертайтесь до статті по Python 3.
-
-```python
-# Однорядкові коментарі починаються з символу решітки.
-
-""" Текст, що займає декілька рядків,
-    може бути записаний з використанням 3 знаків " і 
-    зазвичай використовується у якості
-    вбудованої документації
-"""
-
-####################################################
-## 1. Примітивні типи даних та оператори
-####################################################
-
-# У вас є числа
-3  # => 3
-
-# Математика працює досить передбачувано
-1 + 1  # => 2
-8 - 1  # => 7
-10 * 2  # => 20
-35 / 5  # => 7
-
-# А ось з діленням все трохи складніше. Воно цілочисельне і результат
-# автоматично округлюється у меншу сторону.
-5 / 2  # => 2
-
-# Аби правильно ділити, спершу варто дізнатися про числа
-# з плаваючою комою.
-2.0  # Це число з плаваючою комою
-11.0 / 4.0  # => 2.75 ох... Так набагато краще
-
-# Результат цілочисельного ділення округлюється у меншу сторону
-# як для додатніх, так і для від'ємних чисел.
-5 // 3  # => 1
-5.0 // 3.0  # => 1.0  # Працює і для чисел з плаваючою комою
--5 // 3  # => -2
--5.0 // 3.0  # => -2.0
-
-# Зверніть увагу, що ми також можемо імпортувати модуль для ділення, 
-# див. розділ Модулі
-# аби звичне ділення працювало при використанні лише '/'.
-from __future__ import division
-
-11 / 4  # => 2.75  ...звичне ділення
-11 // 4  # => 2 ...цілочисельне ділення
-
-# Залишок від ділення
-7 % 3  # => 1
-
-# Піднесення до степеня
-2 ** 4  # => 16
-
-# Приорітет операцій вказується дужками
-(1 + 3) * 2  # => 8
-
-# Логічні оператори
-# Зверніть увагу: ключові слова «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
-
-# Для заперечення використовується not
-not True  # => False
-not False  # => True
-
-# Рівність — це ==
-1 == 1  # => True
-2 == 1  # => False
-
-# Нерівність — це !=
-1 != 1  # => False
-2 != 1  # => True
-
-# Ще трохи порівнянь
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
-
-# Порівняння можуть бути записані ланцюжком!
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
-
-# Рядки позначаються символом " або '
-"Це рядок."
-'Це теж рядок.'
-
-# І рядки також можна додавати!
-"Привіт " + "світ!" # => "Привіт світ!"
-# Рядки можна додавати і без '+'
-"Привіт " "світ!"  # => "Привіт світ!"
-
-# ... або множити
-"Привіт" * 3  # => "ПривітПривітПривіт"
-
-# З рядком можна працювати як зі списком символів
-"Це рядок"[0]  # => 'Ц'
-
-# Ви можете дізнатися довжину рядка
-len("Це рядок")  # => 8
-
-# Символ % використовується для форматування рядків, наприклад:
-"%s можуть бути %s" % ("рядки", "інтерпольовані")
-
-# Новий спосіб форматування рядків — використання методу format.
-# Це бажаний спосіб.
-"{} є {}".format("Це", "заповнювач")
-"{0} можуть бути {1}".format("рядки", "форматовані")
-# Якщо ви не хочете рахувати, то можете скористатися ключовими словами.
-"{name} хоче з'істи {food}".format(name="Боб", food="лазанью")
-
-# None - це об'єкт
-None  # => None
-
-# Не використовуйте оператор рівності '=='' для порівняння 
-# об'єктів з None. Використовуйте для цього «is»
-"etc" is None  # => False
-None is None  # => True
-
-# Оператор 'is' перевіряє ідентичність об'єктів. Він не 
-# дуже корисний при роботі з примітивними типами, проте 
-# незамінний при роботі з об'єктами.
-
-# None, 0 і порожні рядки/списки рівні False.
-# Всі інші значення рівні True
-bool(0)  # => False
-bool("")  # => False
-
-
-####################################################
-## 2. Змінні та колекції
-####################################################
-
-# В Python є оператор print
-print "Я Python. Приємно познайомитись!"  # => Я Python. Приємно познайомитись!
-
-# Отримати дані з консолі просто
-input_string_var = raw_input(
-    "Введіть щось: ")  # Повертає дані у вигляді рядка
-input_var = input("Введіть щось: ")  # Працює з даними як з кодом на python
-# Застереження: будьте обережні при використанні методу input()
-
-# Оголошувати змінні перед ініціалізацією не потрібно.
-some_var = 5  # За угодою використовується нижній_регістр_з_підкресленнями
-some_var  # => 5
-
-# При спробі доступу до неініціалізованої змінної
-# виникне виняткова ситуація.
-# Див. розділ Потік управління, аби дізнатись про винятки більше.
-some_other_var  # Помилка в імені
-
-# if може використовуватися як вираз
-# Такий запис еквівалентний тернарному оператору '?:' у мові С
-"yahoo!" if 3 > 2 else 2  # => "yahoo!"
-
-# Списки зберігають послідовності
-li = []
-# Можна одразу створити заповнений список
-other_li = [4, 5, 6]
-
-# Об'єкти додаються у кінець списку за допомогою методу append
-li.append(1)  # li тепер дорівнює [1]
-li.append(2)  # li тепер дорівнює [1, 2]
-li.append(4)  # li тепер дорівнює [1, 2, 4]
-li.append(3)  # li тепер дорівнює [1, 2, 4, 3]
-# І видаляються з кінця методом pop
-li.pop()  # => повертає 3 і li стає рівним [1, 2, 4]
-# Повернемо елемент назад
-li.append(3)  # li тепер знову дорівнює [1, 2, 4, 3]
-
-# Поводьтесь зі списком як зі звичайним масивом
-li[0]  # => 1
-# Присвоюйте нові значення вже ініціалізованим індексам за допомогою =
-li[0] = 42
-li[0]  # => 42
-li[0] = 1  # Зверніть увагу: повертаємось до попереднього значення
-# Звертаємось до останнього елементу
-li[-1]  # => 3
-
-# Спроба вийти за границі масиву призводить до помилки в індексі
-li[4]  # помилка в індексі
-
-# Можна звертатися до діапазону, використовуючи так звані зрізи
-# (Для тих, хто любить математику: це називається замкнуто-відкритий інтервал).
-li[1:3]  # => [2, 4]
-# Опускаємо початок
-li[2:]  # => [4, 3]
-# Опускаємо кінець
-li[:3]  # => [1, 2, 4]
-# Вибираємо кожен другий елемент
-li[::2]  # => [1, 4]
-# Перевертаємо список
-li[::-1]  # => [3, 4, 2, 1]
-# Використовуйте суміш вищеназваного для більш складних зрізів
-# li[початок:кінець:крок]
-
-# Видаляємо довільні елементи зі списку оператором del
-del li[2]  # li тепер [1, 2, 3]
-
-# Ви можете додавати списки
-li + other_li  # => [1, 2, 3, 4, 5, 6]
-# Зверніть увагу: значення li та other_li при цьому не змінились.
-
-# Поєднувати списки можна за допомогою методу extend
-li.extend(other_li)  # Тепер li дорівнює [1, 2, 3, 4, 5, 6]
-
-# Видалити перше входження значення
-li.remove(2)  # Тепер li дорівнює [1, 3, 4, 5, 6]
-li.remove(2)  # Помилка значення, оскільки у списку li немає 2
-
-# Вставити елемент за вказаним індексом
-li.insert(1, 2)  # li знову дорівнює [1, 2, 3, 4, 5, 6]
-
-# Отримати індекс першого знайденого елементу
-li.index(2)  # => 1
-li.index(7)  # Помилка значення, оскільки у списку li немає 7
-
-# Перевірити елемент на входження у список можна оператором in
-1 in li  # => True
-
-# Довжина списку обчислюється за допомогою функції len
-len(li)  # => 6
-
-# Кортежі схожі на списки, лише незмінні
-tup = (1, 2, 3)
-tup[0]  # => 1
-tup[0] = 3  # Виникає помилка типу
-
-# Все те ж саме можна робити і з кортежами
-len(tup)  # => 3
-tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
-tup[:2]  # => (1, 2)
-2 in tup  # => True
-
-# Ви можете розпаковувати кортежі (або списки) у змінні
-a, b, c = (1, 2, 3)  # a == 1, b == 2 и c == 3
-d, e, f = 4, 5, 6  # дужки можна опустити
-# Кортежі створюються за замовчуванням, якщо дужки опущено
-g = 4, 5, 6  # => (4, 5, 6)
-# Дивіться, як легко обміняти значення двох змінних
-e, d = d, e  # тепер d дорівнює 5, а e дорівнює 4
-
-# Словники містять асоціативні масиви
-empty_dict = {}
-# Ось так описується попередньо заповнений словник
-filled_dict = {"one": 1, "two": 2, "three": 3}
-
-# Значення можна отримати так само, як і зі списку
-filled_dict["one"]  # => 1
-
-# Можна отримати всі ключі у виді списку за допомогою методу  keys
-filled_dict.keys()  # => ["three", "two", "one"]
-# Примітка: збереження порядку ключів у словників не гарантується
-# Ваші результати можуть не співпадати з цими.
-
-# Можна отримати і всі значення у вигляді списку, використовуйте метод values
-filled_dict.values()  # => [3, 2, 1]
-# Те ж зауваження щодо порядку ключів діє і тут
-
-# Отримуйте всі пари ключ-значення у вигляді списку кортежів 
-# за допомогою "items()"
-filled_dict.items()  # => [("one", 1), ("two", 2), ("three", 3)]
-
-# За допомогою оператору in можна перевіряти ключі на входження у словник
-"one" in filled_dict # => True
-1 in filled_dict  # => False
-
-# Спроба отримати значення за неіснуючим ключем викине помилку ключа
-filled_dict["four"]  # помилка ключа
-
-# Аби уникнути цього, використовуйте метод 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 не встановлює значення елементу словника)
-
-# Присвоюйте значення ключам так само, як і в списках
-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}
-
-# Додавання нових елементів у множину
-filled_set.add(5)  # filled_set тепер дорівнює {1, 2, 3, 4, 5}
-
-# Перетин множин: &
-other_set = {3, 4, 5, 6}
-filled_set & other_set  # => {3, 4, 5}
-
-# Об'єднання множин: |
-filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
-
-# Різниця множин: -
-{1,2,3,4} - {2,3,5}  # => {1, 4}
-
-# Симетрична різниця множин: ^
-{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
-
-# Перевіряємо чи множина зліва є надмножиною множини справа
-{1, 2} >= {1, 2, 3}  # => False
-
-# Перевіряємо чи множина зліва є підмножиною множини справа
-{1, 2} <= {1, 2, 3}  # => True
-
-# Перевірка на входження у множину: in
-2 in filled_set  # => True
-10 in filled_set  # => False
-
-
-####################################################
-## 3. Потік управління
-####################################################
-
-# Для початку створимо змінну
-some_var = 5
-
-# Так виглядає вираз if. Відступи у python дуже важливі!
-# результат: «some_var менше, ніж 10»
-if some_var > 10:
-    print("some_var набагато більше, ніж 10.")
-elif some_var < 10:  # Вираз elif є необов'язковим.
-    print("some_var менше, ніж 10.")
-else:  # Це теж необов'язково.
-    print("some_var дорівнює 10.")
-
-
-"""
-Цикли For проходять по спискам
-
-Результат:
-    собака — це ссавець
-    кішка — це ссавець
-    миша — це ссавець
-"""
-for animal in ["собака", "кішка", "миша"]:
-    # Можете використовувати оператор {0} для інтерполяції форматованих рядків
-    print "{0} — це ссавець".format(animal) 
-    
-"""
-"range(число)" повертає список чисел
-від нуля до заданого числа
-Друкує:
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print(i)
-"""
-"range(нижня_границя, верхня_границя)" повертає список чисел
-від нижньої границі до верхньої
-Друкує:
-    4
-    5
-    6
-    7
-"""
-for i in range(4, 8):
-    print i
-
-"""
-Цикли while продовжуються до тих пір, поки вказана умова не стане хибною.
-Друкує:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print(x)
-    x += 1  # Короткий запис для x = x + 1
-
-# Обробляйте винятки блоками try/except
-
-# Працює у Python 2.6 і вище:
-try:
-    # Аби створити виняток, використовується raise
-    raise IndexError("Помилка у індексі!")
-except IndexError as e:
-    pass  # pass — оператор, який нічого не робить. Зазвичай тут відбувається
-    # відновлення після помилки.
-except (TypeError, NameError):
-    pass  # Винятки можна обробляти групами, якщо потрібно.
-else:  # Необов'язковий вираз. Має слідувати за останнім блоком except
-    print("Все добре!")   # Виконається лише якщо не було ніяких винятків
-finally:  # Виконується у будь-якому випадку
-    print "Тут ми можемо звільнити ресурси"
-
-# Замість try/finally для звільнення ресурсів 
-# ви можете використовувати вираз with
-with open("myfile.txt") as f:
-    for line in f:
-        print line
-
-
-####################################################
-## 4. Функції
-####################################################
-
-# Використовуйте def для створення нових функцій
-def add(x, y):
-    print "x дорівнює {0}, а y дорівнює {1}".format(x, y)
-    return x + y  # Повертайте результат за допомогою ключового слова return
-
-
-# Виклик функції з аргументами
-add(5, 6)  # => друкує «x дорівнює 5, а y дорівнює 6» і повертає 11
-
-# Інший спосіб виклику функції — виклик з іменованими аргументами
-add(y=6, x=5)  # Іменовані аргументи можна вказувати у будь-якому порядку
-
-
-# Ви можете визначити функцію, яка приймає змінну кількість аргументів,
-# які будуть інтерпретовані як кортеж, за допомогою *
-def varargs(*args):
-    return args
-
-
-varargs(1, 2, 3)  # => (1,2,3)
-
-
-# А також можете визначити функцію, яка приймає змінне число
-# іменованих аргументів, котрі будуть інтерпретовані як словник, за допомогою **
-def keyword_args(**kwargs):
-    return kwargs
-
-
-# Давайте подивимось що з цього вийде
-keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
-
-# Якщо хочете, можете використовувати обидва способи одночасно
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
-
-
-"""
-all_the_args(1, 2, a=3, b=4) друкує:
-    (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
-
-
-def set_x(num):
-    # Локальна змінна x - не те ж саме, що глобальна змінна x
-    x = num  # => 43
-    print x  # => 43
-
-
-def set_global_x(num):
-    global x
-    print x  # => 5
-    x = num  # глобальна змінна x тепер дорівнює 6
-    print x  # => 6
-
-
-set_x(43)
-set_global_x(6)
-
-# В Python функції є об'єктами першого класу
-def create_adder(x):
-    def adder(y):
-        return x + y
-
-    return adder
-
-
-add_10 = create_adder(10)
-add_10(3)  # => 13
-
-# Також є і анонімні функції
-(lambda x: x > 2)(3)  # => True
-(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
-
-# Присутні вбудовані функції вищого порядку
-map(add_10, [1, 2, 3])  # => [11, 12, 13]
-map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
-
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
-
-# Для зручного відображення і фільтрації можна використовувати 
-# включення у вигляді списків
-[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]
-
-# Ви також можете скористатися включеннями множин та словників
-{x for x in 'abcddeef' if x in 'abc'}  # => {'a', 'b', 'c'}
-{x: x ** 2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
-
-
-####################################################
-## 5. Класи
-####################################################
-
-# Аби отримати клас, ми наслідуємо object.
-class Human(object):
-    # Атрибут класу. Він розділяється всіма екземплярами цього класу.
-    species = "H. sapiens"
-
-    # Звичайний конструктор, буде викликаний при ініціалізації екземпляру класу
-    # Зверніть увагу, що подвійне підкреслення на початку та наприкінці імені
-    # використовується для позначення об'єктів та атрибутів,
-    # які використовуються Python, але знаходяться у просторах імен, 
-    # якими керує користувач. Не варто вигадувати для них імена самостійно.
-    def __init__(self, name):
-        # Присвоєння значення аргумента атрибуту класу name
-        self.name = name
-
-        # Ініціалізуємо властивість
-        self.age = 0
-
-    # Метод екземпляру. Всі методи приймають self у якості першого аргументу
-    def say(self, msg):
-       return "%s: %s" % (self.name, msg)
-
-    # Методи класу розділяються між усіма екземплярами
-    # Вони викликаються з вказанням викликаючого класу 
-    # у якості першого аргументу
-    @classmethod
-    def get_species(cls):
-        return cls.species
-
-    # Статичний метод викликається без посилання на клас або екземпляр
-    @staticmethod
-    def grunt():
-        return "*grunt*"
-
-    # Властивість.
-    # Перетворює метод age() в атрибут тільки для читання
-    # з таким же ім'ям.
-    @property
-    def age(self):
-        return self._age
-
-    # Це дозволяє змінювати значення властивості
-    @age.setter
-    def age(self, age):
-        self._age = age
-
-    # Це дозволяє видаляти властивість
-    @age.deleter
-    def age(self):
-        del self._age
-
-
-# Створюємо екземпляр класу
-i = Human(name="Данило")
-print(i.say("привіт"))  # Друкує: «Данило: привіт»
-
-j = Human("Меланка")
-print(j.say("Привіт"))  # Друкує: «Меланка: привіт»
-
-# Виклик методу класу
-i.get_species()  # => "H. sapiens"
-
-# Зміна розділюваного атрибуту
-Human.species = "H. neanderthalensis"
-i.get_species()  # => "H. neanderthalensis"
-j.get_species()  # => "H. neanderthalensis"
-
-# Виклик статичного методу
-Human.grunt()  # => "*grunt*"
-
-# Оновлюємо властивість
-i.age = 42
-
-# Отримуємо значення
-i.age  # => 42
-
-# Видаляємо властивість
-del i.age
-i.age  # => виникає помилка атрибуту
-
-####################################################
-## 6. Модулі
-####################################################
-
-# Ви можете імпортувати модулі
-import math
-
-print(math.sqrt(16))  # => 4.0
-
-# Ви можете імпортувати окремі функції з модуля
-from math import ceil, floor
-
-print(ceil(3.7))  # => 4.0
-print(floor(3.7))  # => 3.0
-
-# Можете імпортувати всі функції модуля.
-# Попередження: краще так не робіть
-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-файли. Ви
-# можете писати свої модулі та імпортувати їх. Назва
-# модуля співпадає з назвою файлу.
-
-# Ви можете дізнатися, які функції та атрибути визначені
-# в модулі
-import math
-
-dir(math)
-
-
-# Якщо у вас є Python скрипт з назвою math.py у тій же папці, що
-# і ваш поточний скрипт, то файл math.py
-# може бути завантажено замість вбудованого у Python модуля.
-# Так трапляється, оскільки локальна папка має перевагу
-# над вбудованими у Python бібліотеками.
-
-####################################################
-## 7. Додатково
-####################################################
-
-# Генератори
-# Генератор "генерує" значення тоді, коли вони запитуються, замість того, 
-# щоб зберігати все одразу
-
-# Метод нижче (*НЕ* генератор) подвоює всі значення і зберігає їх 
-# в `double_arr`. При великих розмірах може знадобитися багато ресурсів!
-def double_numbers(iterable):
-    double_arr = []
-    for i in iterable:
-        double_arr.append(i + i)
-    return double_arr
-
-
-# Тут ми спочатку подвоюємо всі значення, потім повертаємо їх,
-# аби перевірити умову
-for value in double_numbers(range(1000000)):  # `test_non_generator`
-    print value
-    if value > 5:
-        break
-
-
-# Натомість ми можемо скористатися генератором, аби "згенерувати"
-# подвійне значення, як тільки воно буде запитане
-def double_numbers_generator(iterable):
-    for i in iterable:
-        yield i + i
-
-
-# Той самий код, але вже з генератором, тепер дозволяє нам пройтися по
-# значенням і подвоювати їх одне за одним якраз тоді, коли вони обробляються
-# за нашою логікою, одне за одним. А як тільки ми бачимо, що value > 5, ми
-# виходимо з циклу і більше не подвоюємо більшість значень, 
-# які отримали на вхід (НАБАГАТО ШВИДШЕ!)
-for value in double_numbers_generator(xrange(1000000)):  # `test_generator`
-    print value
-    if value > 5:
-        break
-
-# Між іншим: ви помітили використання `range` у `test_non_generator` і 
-# `xrange` у `test_generator`?
-# Як `double_numbers_generator` є версією-генератором `double_numbers`, так
-# і `xrange` є аналогом `range`, але у вигляді генератора.
-# `range` поверне нам масив з 1000000 значень
-# `xrange`, у свою чергу, згенерує 1000000 значень для нас тоді, 
-# коли ми їх запитуємо / будемо проходитись по ним.
-
-# Аналогічно включенням у вигляді списків, ви можете створювати включення
-# у вигляді генераторів.
-values = (-x for x in [1, 2, 3, 4, 5])
-for x in values:
-    print(x)  # друкує -1 -2 -3 -4 -5
-
-# Включення у вигляді генератора можна явно перетворити у список
-values = (-x for x in [1, 2, 3, 4, 5])
-gen_to_list = list(values)
-print(gen_to_list)  # => [-1, -2, -3, -4, -5]
-
-# Декоратори
-# Декоратор – це функція вищого порядку, яка приймає та повертає функцію.
-# Простий приклад використання – декоратор add_apples додає елемент 'Apple' в
-# список fruits, який повертає цільова функція get_fruits.
-def add_apples(func):
-    def get_fruits():
-        fruits = func()
-        fruits.append('Apple')
-        return fruits
-    return get_fruits
-
-@add_apples
-def get_fruits():
-    return ['Banana', 'Mango', 'Orange']
-
-# Друкуємо список разом з елементом 'Apple', який знаходиться в ньому:
-# Banana, Mango, Orange, Apple
-print ', '.join(get_fruits())
-
-# У цьому прикладі beg обертає say
-# Beg викличе say. Якщо say_please дорівнюватиме True, то повідомлення,
-# що повертається, буде змінено.
-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, "Будь ласка! Я бідний :(")
-        return msg
-
-    return wrapper
-
-
-@beg
-def say(say_please=False):
-    msg = "Ви можете купити мені пива?"
-    return msg, say_please
-
-
-print say()  # Ви можете купити мені пива?
-print say(say_please=True)  # Ви можете купити мені пива? Будь ласка! Я бідний :(
-```
-
-## Готові до більшого?
-
-### Безкоштовні онлайн-матеріали
-
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [Официальная документация](http://docs.python.org/2.6/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-
-### Платні
-
-* [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)
-
diff --git a/uk-ua/pythonlegacy-ua.html.markdown b/uk-ua/pythonlegacy-ua.html.markdown
new file mode 100644
index 00000000..4091e433
--- /dev/null
+++ b/uk-ua/pythonlegacy-ua.html.markdown
@@ -0,0 +1,818 @@
+---
+language: python
+lang: uk-ua
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Amin Bandali", "https://aminb.org"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["evuez", "http://github.com/evuez"]
+    - ["asyne", "https://github.com/justblah"]
+    - ["habi", "http://github.com/habi"]
+translators:
+    - ["Oleh Hromiak", "https://github.com/ogroleg"]
+filename: learnpython-ua.py
+---
+
+Мову Python створив Гвідо ван Россум на початку 90-х. Наразі це одна з 
+найбільш популярних мов. Я закохався у Python завдяки простому і зрозумілому
+синтаксису. Це майже як виконуваний псевдокод.
+
+З вдячністю чекаю ваших відгуків: [@louiedinh](http://twitter.com/louiedinh)
+або louiedinh [at] [поштовий сервіс від Google]
+
+Примітка: Ця стаття стосується Python 2.7, проте має працювати і 
+у інших версіях Python 2.x. Python 2.7 підходить до кінця свого терміну, 
+його підтримку припинять у 2020, тож наразі краще починати вивчення Python 
+з версії 3.x.
+Аби вивчити Python 3.x, звертайтесь до статті по Python 3.
+
+```python
+# Однорядкові коментарі починаються з символу решітки.
+
+""" Текст, що займає декілька рядків,
+    може бути записаний з використанням 3 знаків " і 
+    зазвичай використовується у якості
+    вбудованої документації
+"""
+
+####################################################
+## 1. Примітивні типи даних та оператори
+####################################################
+
+# У вас є числа
+3  # => 3
+
+# Математика працює досить передбачувано
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+35 / 5  # => 7
+
+# А ось з діленням все трохи складніше. Воно цілочисельне і результат
+# автоматично округлюється у меншу сторону.
+5 / 2  # => 2
+
+# Аби правильно ділити, спершу варто дізнатися про числа
+# з плаваючою комою.
+2.0  # Це число з плаваючою комою
+11.0 / 4.0  # => 2.75 ох... Так набагато краще
+
+# Результат цілочисельного ділення округлюється у меншу сторону
+# як для додатніх, так і для від'ємних чисел.
+5 // 3  # => 1
+5.0 // 3.0  # => 1.0  # Працює і для чисел з плаваючою комою
+-5 // 3  # => -2
+-5.0 // 3.0  # => -2.0
+
+# Зверніть увагу, що ми також можемо імпортувати модуль для ділення, 
+# див. розділ Модулі
+# аби звичне ділення працювало при використанні лише '/'.
+from __future__ import division
+
+11 / 4  # => 2.75  ...звичне ділення
+11 // 4  # => 2 ...цілочисельне ділення
+
+# Залишок від ділення
+7 % 3  # => 1
+
+# Піднесення до степеня
+2 ** 4  # => 16
+
+# Приорітет операцій вказується дужками
+(1 + 3) * 2  # => 8
+
+# Логічні оператори
+# Зверніть увагу: ключові слова «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
+
+# Для заперечення використовується not
+not True  # => False
+not False  # => True
+
+# Рівність — це ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Нерівність — це !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Ще трохи порівнянь
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Порівняння можуть бути записані ланцюжком!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# Рядки позначаються символом " або '
+"Це рядок."
+'Це теж рядок.'
+
+# І рядки також можна додавати!
+"Привіт " + "світ!" # => "Привіт світ!"
+# Рядки можна додавати і без '+'
+"Привіт " "світ!"  # => "Привіт світ!"
+
+# ... або множити
+"Привіт" * 3  # => "ПривітПривітПривіт"
+
+# З рядком можна працювати як зі списком символів
+"Це рядок"[0]  # => 'Ц'
+
+# Ви можете дізнатися довжину рядка
+len("Це рядок")  # => 8
+
+# Символ % використовується для форматування рядків, наприклад:
+"%s можуть бути %s" % ("рядки", "інтерпольовані")
+
+# Новий спосіб форматування рядків — використання методу format.
+# Це бажаний спосіб.
+"{} є {}".format("Це", "заповнювач")
+"{0} можуть бути {1}".format("рядки", "форматовані")
+# Якщо ви не хочете рахувати, то можете скористатися ключовими словами.
+"{name} хоче з'істи {food}".format(name="Боб", food="лазанью")
+
+# None - це об'єкт
+None  # => None
+
+# Не використовуйте оператор рівності '=='' для порівняння 
+# об'єктів з None. Використовуйте для цього «is»
+"etc" is None  # => False
+None is None  # => True
+
+# Оператор 'is' перевіряє ідентичність об'єктів. Він не 
+# дуже корисний при роботі з примітивними типами, проте 
+# незамінний при роботі з об'єктами.
+
+# None, 0 і порожні рядки/списки рівні False.
+# Всі інші значення рівні True
+bool(0)  # => False
+bool("")  # => False
+
+
+####################################################
+## 2. Змінні та колекції
+####################################################
+
+# В Python є оператор print
+print "Я Python. Приємно познайомитись!"  # => Я Python. Приємно познайомитись!
+
+# Отримати дані з консолі просто
+input_string_var = raw_input(
+    "Введіть щось: ")  # Повертає дані у вигляді рядка
+input_var = input("Введіть щось: ")  # Працює з даними як з кодом на python
+# Застереження: будьте обережні при використанні методу input()
+
+# Оголошувати змінні перед ініціалізацією не потрібно.
+some_var = 5  # За угодою використовується нижній_регістр_з_підкресленнями
+some_var  # => 5
+
+# При спробі доступу до неініціалізованої змінної
+# виникне виняткова ситуація.
+# Див. розділ Потік управління, аби дізнатись про винятки більше.
+some_other_var  # Помилка в імені
+
+# if може використовуватися як вираз
+# Такий запис еквівалентний тернарному оператору '?:' у мові С
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
+# Списки зберігають послідовності
+li = []
+# Можна одразу створити заповнений список
+other_li = [4, 5, 6]
+
+# Об'єкти додаються у кінець списку за допомогою методу append
+li.append(1)  # li тепер дорівнює [1]
+li.append(2)  # li тепер дорівнює [1, 2]
+li.append(4)  # li тепер дорівнює [1, 2, 4]
+li.append(3)  # li тепер дорівнює [1, 2, 4, 3]
+# І видаляються з кінця методом pop
+li.pop()  # => повертає 3 і li стає рівним [1, 2, 4]
+# Повернемо елемент назад
+li.append(3)  # li тепер знову дорівнює [1, 2, 4, 3]
+
+# Поводьтесь зі списком як зі звичайним масивом
+li[0]  # => 1
+# Присвоюйте нові значення вже ініціалізованим індексам за допомогою =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Зверніть увагу: повертаємось до попереднього значення
+# Звертаємось до останнього елементу
+li[-1]  # => 3
+
+# Спроба вийти за границі масиву призводить до помилки в індексі
+li[4]  # помилка в індексі
+
+# Можна звертатися до діапазону, використовуючи так звані зрізи
+# (Для тих, хто любить математику: це називається замкнуто-відкритий інтервал).
+li[1:3]  # => [2, 4]
+# Опускаємо початок
+li[2:]  # => [4, 3]
+# Опускаємо кінець
+li[:3]  # => [1, 2, 4]
+# Вибираємо кожен другий елемент
+li[::2]  # => [1, 4]
+# Перевертаємо список
+li[::-1]  # => [3, 4, 2, 1]
+# Використовуйте суміш вищеназваного для більш складних зрізів
+# li[початок:кінець:крок]
+
+# Видаляємо довільні елементи зі списку оператором del
+del li[2]  # li тепер [1, 2, 3]
+
+# Ви можете додавати списки
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+# Зверніть увагу: значення li та other_li при цьому не змінились.
+
+# Поєднувати списки можна за допомогою методу extend
+li.extend(other_li)  # Тепер li дорівнює [1, 2, 3, 4, 5, 6]
+
+# Видалити перше входження значення
+li.remove(2)  # Тепер li дорівнює [1, 3, 4, 5, 6]
+li.remove(2)  # Помилка значення, оскільки у списку li немає 2
+
+# Вставити елемент за вказаним індексом
+li.insert(1, 2)  # li знову дорівнює [1, 2, 3, 4, 5, 6]
+
+# Отримати індекс першого знайденого елементу
+li.index(2)  # => 1
+li.index(7)  # Помилка значення, оскільки у списку li немає 7
+
+# Перевірити елемент на входження у список можна оператором in
+1 in li  # => True
+
+# Довжина списку обчислюється за допомогою функції len
+len(li)  # => 6
+
+# Кортежі схожі на списки, лише незмінні
+tup = (1, 2, 3)
+tup[0]  # => 1
+tup[0] = 3  # Виникає помилка типу
+
+# Все те ж саме можна робити і з кортежами
+len(tup)  # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]  # => (1, 2)
+2 in tup  # => True
+
+# Ви можете розпаковувати кортежі (або списки) у змінні
+a, b, c = (1, 2, 3)  # a == 1, b == 2 и c == 3
+d, e, f = 4, 5, 6  # дужки можна опустити
+# Кортежі створюються за замовчуванням, якщо дужки опущено
+g = 4, 5, 6  # => (4, 5, 6)
+# Дивіться, як легко обміняти значення двох змінних
+e, d = d, e  # тепер d дорівнює 5, а e дорівнює 4
+
+# Словники містять асоціативні масиви
+empty_dict = {}
+# Ось так описується попередньо заповнений словник
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Значення можна отримати так само, як і зі списку
+filled_dict["one"]  # => 1
+
+# Можна отримати всі ключі у виді списку за допомогою методу  keys
+filled_dict.keys()  # => ["three", "two", "one"]
+# Примітка: збереження порядку ключів у словників не гарантується
+# Ваші результати можуть не співпадати з цими.
+
+# Можна отримати і всі значення у вигляді списку, використовуйте метод values
+filled_dict.values()  # => [3, 2, 1]
+# Те ж зауваження щодо порядку ключів діє і тут
+
+# Отримуйте всі пари ключ-значення у вигляді списку кортежів 
+# за допомогою "items()"
+filled_dict.items()  # => [("one", 1), ("two", 2), ("three", 3)]
+
+# За допомогою оператору in можна перевіряти ключі на входження у словник
+"one" in filled_dict # => True
+1 in filled_dict  # => False
+
+# Спроба отримати значення за неіснуючим ключем викине помилку ключа
+filled_dict["four"]  # помилка ключа
+
+# Аби уникнути цього, використовуйте метод 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 не встановлює значення елементу словника)
+
+# Присвоюйте значення ключам так само, як і в списках
+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}
+
+# Додавання нових елементів у множину
+filled_set.add(5)  # filled_set тепер дорівнює {1, 2, 3, 4, 5}
+
+# Перетин множин: &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
+
+# Об'єднання множин: |
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# Різниця множин: -
+{1,2,3,4} - {2,3,5}  # => {1, 4}
+
+# Симетрична різниця множин: ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Перевіряємо чи множина зліва є надмножиною множини справа
+{1, 2} >= {1, 2, 3}  # => False
+
+# Перевіряємо чи множина зліва є підмножиною множини справа
+{1, 2} <= {1, 2, 3}  # => True
+
+# Перевірка на входження у множину: in
+2 in filled_set  # => True
+10 in filled_set  # => False
+
+
+####################################################
+## 3. Потік управління
+####################################################
+
+# Для початку створимо змінну
+some_var = 5
+
+# Так виглядає вираз if. Відступи у python дуже важливі!
+# результат: «some_var менше, ніж 10»
+if some_var > 10:
+    print("some_var набагато більше, ніж 10.")
+elif some_var < 10:  # Вираз elif є необов'язковим.
+    print("some_var менше, ніж 10.")
+else:  # Це теж необов'язково.
+    print("some_var дорівнює 10.")
+
+
+"""
+Цикли For проходять по спискам
+
+Результат:
+    собака — це ссавець
+    кішка — це ссавець
+    миша — це ссавець
+"""
+for animal in ["собака", "кішка", "миша"]:
+    # Можете використовувати оператор {0} для інтерполяції форматованих рядків
+    print "{0} — це ссавець".format(animal) 
+    
+"""
+"range(число)" повертає список чисел
+від нуля до заданого числа
+Друкує:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+"""
+"range(нижня_границя, верхня_границя)" повертає список чисел
+від нижньої границі до верхньої
+Друкує:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print i
+
+"""
+Цикли while продовжуються до тих пір, поки вказана умова не стане хибною.
+Друкує:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Короткий запис для x = x + 1
+
+# Обробляйте винятки блоками try/except
+
+# Працює у Python 2.6 і вище:
+try:
+    # Аби створити виняток, використовується raise
+    raise IndexError("Помилка у індексі!")
+except IndexError as e:
+    pass  # pass — оператор, який нічого не робить. Зазвичай тут відбувається
+    # відновлення після помилки.
+except (TypeError, NameError):
+    pass  # Винятки можна обробляти групами, якщо потрібно.
+else:  # Необов'язковий вираз. Має слідувати за останнім блоком except
+    print("Все добре!")   # Виконається лише якщо не було ніяких винятків
+finally:  # Виконується у будь-якому випадку
+    print "Тут ми можемо звільнити ресурси"
+
+# Замість try/finally для звільнення ресурсів 
+# ви можете використовувати вираз with
+with open("myfile.txt") as f:
+    for line in f:
+        print line
+
+
+####################################################
+## 4. Функції
+####################################################
+
+# Використовуйте def для створення нових функцій
+def add(x, y):
+    print "x дорівнює {0}, а y дорівнює {1}".format(x, y)
+    return x + y  # Повертайте результат за допомогою ключового слова return
+
+
+# Виклик функції з аргументами
+add(5, 6)  # => друкує «x дорівнює 5, а y дорівнює 6» і повертає 11
+
+# Інший спосіб виклику функції — виклик з іменованими аргументами
+add(y=6, x=5)  # Іменовані аргументи можна вказувати у будь-якому порядку
+
+
+# Ви можете визначити функцію, яка приймає змінну кількість аргументів,
+# які будуть інтерпретовані як кортеж, за допомогою *
+def varargs(*args):
+    return args
+
+
+varargs(1, 2, 3)  # => (1,2,3)
+
+
+# А також можете визначити функцію, яка приймає змінне число
+# іменованих аргументів, котрі будуть інтерпретовані як словник, за допомогою **
+def keyword_args(**kwargs):
+    return kwargs
+
+
+# Давайте подивимось що з цього вийде
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
+
+# Якщо хочете, можете використовувати обидва способи одночасно
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+
+
+"""
+all_the_args(1, 2, a=3, b=4) друкує:
+    (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
+
+
+def set_x(num):
+    # Локальна змінна x - не те ж саме, що глобальна змінна x
+    x = num  # => 43
+    print x  # => 43
+
+
+def set_global_x(num):
+    global x
+    print x  # => 5
+    x = num  # глобальна змінна x тепер дорівнює 6
+    print x  # => 6
+
+
+set_x(43)
+set_global_x(6)
+
+# В Python функції є об'єктами першого класу
+def create_adder(x):
+    def adder(y):
+        return x + y
+
+    return adder
+
+
+add_10 = create_adder(10)
+add_10(3)  # => 13
+
+# Також є і анонімні функції
+(lambda x: x > 2)(3)  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# Присутні вбудовані функції вищого порядку
+map(add_10, [1, 2, 3])  # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
+
+# Для зручного відображення і фільтрації можна використовувати 
+# включення у вигляді списків
+[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]
+
+# Ви також можете скористатися включеннями множин та словників
+{x for x in 'abcddeef' if x in 'abc'}  # => {'a', 'b', 'c'}
+{x: x ** 2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. Класи
+####################################################
+
+# Аби отримати клас, ми наслідуємо object.
+class Human(object):
+    # Атрибут класу. Він розділяється всіма екземплярами цього класу.
+    species = "H. sapiens"
+
+    # Звичайний конструктор, буде викликаний при ініціалізації екземпляру класу
+    # Зверніть увагу, що подвійне підкреслення на початку та наприкінці імені
+    # використовується для позначення об'єктів та атрибутів,
+    # які використовуються Python, але знаходяться у просторах імен, 
+    # якими керує користувач. Не варто вигадувати для них імена самостійно.
+    def __init__(self, name):
+        # Присвоєння значення аргумента атрибуту класу name
+        self.name = name
+
+        # Ініціалізуємо властивість
+        self.age = 0
+
+    # Метод екземпляру. Всі методи приймають self у якості першого аргументу
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # Методи класу розділяються між усіма екземплярами
+    # Вони викликаються з вказанням викликаючого класу 
+    # у якості першого аргументу
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Статичний метод викликається без посилання на клас або екземпляр
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # Властивість.
+    # Перетворює метод age() в атрибут тільки для читання
+    # з таким же ім'ям.
+    @property
+    def age(self):
+        return self._age
+
+    # Це дозволяє змінювати значення властивості
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Це дозволяє видаляти властивість
+    @age.deleter
+    def age(self):
+        del self._age
+
+
+# Створюємо екземпляр класу
+i = Human(name="Данило")
+print(i.say("привіт"))  # Друкує: «Данило: привіт»
+
+j = Human("Меланка")
+print(j.say("Привіт"))  # Друкує: «Меланка: привіт»
+
+# Виклик методу класу
+i.get_species()  # => "H. sapiens"
+
+# Зміна розділюваного атрибуту
+Human.species = "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
+
+# Виклик статичного методу
+Human.grunt()  # => "*grunt*"
+
+# Оновлюємо властивість
+i.age = 42
+
+# Отримуємо значення
+i.age  # => 42
+
+# Видаляємо властивість
+del i.age
+i.age  # => виникає помилка атрибуту
+
+####################################################
+## 6. Модулі
+####################################################
+
+# Ви можете імпортувати модулі
+import math
+
+print(math.sqrt(16))  # => 4.0
+
+# Ви можете імпортувати окремі функції з модуля
+from math import ceil, floor
+
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Можете імпортувати всі функції модуля.
+# Попередження: краще так не робіть
+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-файли. Ви
+# можете писати свої модулі та імпортувати їх. Назва
+# модуля співпадає з назвою файлу.
+
+# Ви можете дізнатися, які функції та атрибути визначені
+# в модулі
+import math
+
+dir(math)
+
+
+# Якщо у вас є Python скрипт з назвою math.py у тій же папці, що
+# і ваш поточний скрипт, то файл math.py
+# може бути завантажено замість вбудованого у Python модуля.
+# Так трапляється, оскільки локальна папка має перевагу
+# над вбудованими у Python бібліотеками.
+
+####################################################
+## 7. Додатково
+####################################################
+
+# Генератори
+# Генератор "генерує" значення тоді, коли вони запитуються, замість того, 
+# щоб зберігати все одразу
+
+# Метод нижче (*НЕ* генератор) подвоює всі значення і зберігає їх 
+# в `double_arr`. При великих розмірах може знадобитися багато ресурсів!
+def double_numbers(iterable):
+    double_arr = []
+    for i in iterable:
+        double_arr.append(i + i)
+    return double_arr
+
+
+# Тут ми спочатку подвоюємо всі значення, потім повертаємо їх,
+# аби перевірити умову
+for value in double_numbers(range(1000000)):  # `test_non_generator`
+    print value
+    if value > 5:
+        break
+
+
+# Натомість ми можемо скористатися генератором, аби "згенерувати"
+# подвійне значення, як тільки воно буде запитане
+def double_numbers_generator(iterable):
+    for i in iterable:
+        yield i + i
+
+
+# Той самий код, але вже з генератором, тепер дозволяє нам пройтися по
+# значенням і подвоювати їх одне за одним якраз тоді, коли вони обробляються
+# за нашою логікою, одне за одним. А як тільки ми бачимо, що value > 5, ми
+# виходимо з циклу і більше не подвоюємо більшість значень, 
+# які отримали на вхід (НАБАГАТО ШВИДШЕ!)
+for value in double_numbers_generator(xrange(1000000)):  # `test_generator`
+    print value
+    if value > 5:
+        break
+
+# Між іншим: ви помітили використання `range` у `test_non_generator` і 
+# `xrange` у `test_generator`?
+# Як `double_numbers_generator` є версією-генератором `double_numbers`, так
+# і `xrange` є аналогом `range`, але у вигляді генератора.
+# `range` поверне нам масив з 1000000 значень
+# `xrange`, у свою чергу, згенерує 1000000 значень для нас тоді, 
+# коли ми їх запитуємо / будемо проходитись по ним.
+
+# Аналогічно включенням у вигляді списків, ви можете створювати включення
+# у вигляді генераторів.
+values = (-x for x in [1, 2, 3, 4, 5])
+for x in values:
+    print(x)  # друкує -1 -2 -3 -4 -5
+
+# Включення у вигляді генератора можна явно перетворити у список
+values = (-x for x in [1, 2, 3, 4, 5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
+# Декоратори
+# Декоратор – це функція вищого порядку, яка приймає та повертає функцію.
+# Простий приклад використання – декоратор add_apples додає елемент 'Apple' в
+# список fruits, який повертає цільова функція get_fruits.
+def add_apples(func):
+    def get_fruits():
+        fruits = func()
+        fruits.append('Apple')
+        return fruits
+    return get_fruits
+
+@add_apples
+def get_fruits():
+    return ['Banana', 'Mango', 'Orange']
+
+# Друкуємо список разом з елементом 'Apple', який знаходиться в ньому:
+# Banana, Mango, Orange, Apple
+print ', '.join(get_fruits())
+
+# У цьому прикладі beg обертає say
+# Beg викличе say. Якщо say_please дорівнюватиме True, то повідомлення,
+# що повертається, буде змінено.
+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, "Будь ласка! Я бідний :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Ви можете купити мені пива?"
+    return msg, say_please
+
+
+print say()  # Ви можете купити мені пива?
+print say(say_please=True)  # Ви можете купити мені пива? Будь ласка! Я бідний :(
+```
+
+## Готові до більшого?
+
+### Безкоштовні онлайн-матеріали
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Официальная документация](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+
+### Платні
+
+* [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 95c8b24ebf8b8e0ed02923787a9f793bdf295200 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:09:13 +0100
Subject: Python 2 'language': Python 2 (legacy)

Instead of listing 'language: python' for Python 2, use

    language: Python 2 (legacy)

```
find . -iname "*pythonlegacy*" -exec \
  sed -i 's/^language: .*/language: Python 2 (legacy)/' {} \;
```
---
 uk-ua/pythonlegacy-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/pythonlegacy-ua.html.markdown b/uk-ua/pythonlegacy-ua.html.markdown
index 4091e433..3244348c 100644
--- a/uk-ua/pythonlegacy-ua.html.markdown
+++ b/uk-ua/pythonlegacy-ua.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: python
+language: Python 2 (legacy)
 lang: uk-ua
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
-- 
cgit v1.2.3


From 887cbee8af080034177734b528819491e73a7a16 Mon Sep 17 00:00:00 2001
From: Simon Shine <shreddedglory@gmail.com>
Date: Wed, 12 Feb 2020 05:50:44 +0100
Subject: Change 'filename:' for Python 2 (legacy)

Before renaming, all Python 2 filenames were 'learnpython-*.py'.

This commit renames them to 'learnpythonlegacy-*.py'.

To verify that the filenames were named consistently across
translations prior to this commit, and to change this:

```
find . -name "pythonlegacy*.markdown" -exec ack filename: {} \;

find . -name "pythonlegacy*.markdown" -exec \
  sed -i 's/^filename: learnpython/filename: learnpythonlegacy/' {} \;
```
---
 uk-ua/pythonlegacy-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/pythonlegacy-ua.html.markdown b/uk-ua/pythonlegacy-ua.html.markdown
index 3244348c..e2a6d19e 100644
--- a/uk-ua/pythonlegacy-ua.html.markdown
+++ b/uk-ua/pythonlegacy-ua.html.markdown
@@ -10,7 +10,7 @@ contributors:
     - ["habi", "http://github.com/habi"]
 translators:
     - ["Oleh Hromiak", "https://github.com/ogroleg"]
-filename: learnpython-ua.py
+filename: learnpythonlegacy-ua.py
 ---
 
 Мову Python створив Гвідо ван Россум на початку 90-х. Наразі це одна з 
-- 
cgit v1.2.3


From 5864aba42d2cf57dfe96049568b3a9689ea6a813 Mon Sep 17 00:00:00 2001
From: Leigh Brenecki <l@leigh.net.au>
Date: Thu, 13 Feb 2020 10:38:29 +1030
Subject: Purge my deadname

---
 uk-ua/javascript-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 6a64a623..2f17f586 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: javascript
 contributors:
-    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Leigh Brenecki", "https://leigh.net.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
     - ["clearsense", "https://github.com/clearsense"]
 filename: javascript-uk.js
-- 
cgit v1.2.3