summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CONTRIBUTING.markdown8
-rw-r--r--nix.html.markdown32
-rw-r--r--uk-ua/rust-ua.html.markdown331
3 files changed, 363 insertions, 8 deletions
diff --git a/CONTRIBUTING.markdown b/CONTRIBUTING.markdown
index 18a5a5d7..79d6838a 100644
--- a/CONTRIBUTING.markdown
+++ b/CONTRIBUTING.markdown
@@ -103,3 +103,11 @@ You can buid the site locally to test your changes. Follow the steps below.
these commands at `learnxinyminutes-site/`).
* Build - `bundle exec middleman build`
* Dev server - `bundle exec middleman --force-polling --verbose`
+
+## Building the site locally, for Nix users
+
+You can buid the site locally to test your changes too:
+
+* Clone or zip download the [learnxinyminutes-site](https://github.com/adambard/learnxinyminutes-site) repo.
+* Get the source in place following the instructions above
+* Install all site dependencies and start a dev server by running `nix-shell` at the `learnxinyminutes-site/` root directory.
diff --git a/nix.html.markdown b/nix.html.markdown
index d078395a..5941f0e6 100644
--- a/nix.html.markdown
+++ b/nix.html.markdown
@@ -4,6 +4,7 @@ filename: learn.nix
contributors:
- ["Chris Martin", "http://chris-martin.org/"]
- ["Rommel Martinez", "https://ebzzry.io"]
+ - ["Javier Candeira", "https://candeira.com/"]
---
Nix is a simple functional language developed for the
@@ -12,7 +13,7 @@ Nix is a simple functional language developed for the
You can evaluate Nix expressions using
[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
-or [`nix-repl`](https://github.com/edolstra/nix-repl).
+or [`nix repl`](https://nixos.org/nix/manual/#ssec-relnotes-2.0).
```
with builtins; [
@@ -39,18 +40,26 @@ with builtins; [
#=> "a"
- # Integers
+ # Integers and Floats
#=========================================
- # Integers are the only numeric type.
+ # There are two numeric types: integers and floats
1 0 42 (-3) # Some integers
+ 123.43 .27e13 # A couple of floats
+
+ # Operations will preserve numeric type
+
(4 + 6 + 12 - 2) # Addition
#=> 20
+ (4 - 2.5)
+ #=> 1.5
(7 / 2) # Division
#=> 3
+ (7 / 2.0)
+ #=> 3.5
# Strings
@@ -238,13 +247,20 @@ with builtins; [
}.a.c
#=> { d = 2; e = 3; }
- # An attribute's descendants cannot be assigned in this
- # way if the attribute itself has been directly assigned.
+ # Sets are immutable, so you can't redefine an attribute:
+ {
+ a = { b = 1; };
+ a.b = 2;
+ }
+ #=> attribute 'a.b' at (string):3:5 already defined at (string):2:11
+
+ # However, an attribute's set members can also be defined piecewise
+ # way even if the attribute itself has been directly assigned.
{
a = { b = 1; };
a.c = 2;
}
- #=> error: attribute ‘a’ already defined
+ #=> { a = { b = 1; c = 2; }; }
# With
@@ -321,8 +337,8 @@ with builtins; [
#=========================================
# Because repeatability of builds is critical to the Nix package
- # manager, in which, functional purity is emphasized in the Nix
- # language. But there are a few impurities.
+ # manager, functional purity is emphasized in the Nix language
+ # used to describe Nix packages. But there are a few impurities.
# You can refer to environment variables.
(getEnv "HOME")
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).