diff options
| -rw-r--r-- | c++.html.markdown | 46 | ||||
| -rw-r--r-- | nix.html.markdown | 32 | ||||
| -rw-r--r-- | uk-ua/rust-ua.html.markdown | 331 |
3 files changed, 378 insertions, 31 deletions
diff --git a/c++.html.markdown b/c++.html.markdown index 176ea1a8..f3dc8e20 100644 --- a/c++.html.markdown +++ b/c++.html.markdown @@ -818,51 +818,51 @@ void doSomethingWithAFile(const std::string& filename) // Smart Pointer ///////////////////// -// Generally a smart pointer is a class, which wraps a "raw pointer" (usage of "new" +// Generally a smart pointer is a class which wraps a "raw pointer" (usage of "new" // respectively malloc/calloc in C). The goal is to be able to -// manage the lifetime of the object being point to without explicitly deleting +// manage the lifetime of the object being pointed to without ever needing to explicitly delete // the object. The term itself simply describes a set of pointers with the // mentioned abstraction. -// Basically smart pointers should preferred over raw pointers, to prevent -// risky memory leaks, which happens if you forget to delete the object. +// Smart pointers should preferred over raw pointers, to prevent +// risky memory leaks, which happen if you forget to delete an object. // Usage of a raw pointer: Dog* ptr = new Dog(); ptr->bark(); delete ptr; -// With the usage of smart pointers you dont have to worry about the deletion -// of a object anymore. -// A smart pointer describes a policy, to count the references on the -// pointer. As matter of fact the objects gets destroyed when the last -// reference on the object gets destroyed. +// By using a smart pointer, you don't have to worry about the deletion +// of the object anymore. +// A smart pointer describes a policy, to count the references to the +// pointer. The object gets destroyed when the last +// reference to the object gets destroyed. // Usage of "std::shared_ptr": void foo() { -// Its not longer necessary to delete the Dog. +// It's no longer necessary to delete the Dog. std::shared_ptr<Dog> doggo(new Dog()); doggo->bark(); } // Beware of possible circular references!!! // There will be always a reference, so it will be never destroyed! -std::shared_ptr<Dog> doggo_one (new Dog()); -std::shared_ptr<Dog> doggo_two (new Dog()); +std::shared_ptr<Dog> doggo_one(new Dog()); +std::shared_ptr<Dog> doggo_two(new Dog()); doggo_one = doggo_two; // p1 references p2 doggo_two = doggo_one; // p2 references p1 -// As mentioned before there is a set of smart pointers. The way you have to -// use it, is always the same. -// This leads us to question, when to use which one? -// std::unique_ptr - use it when you just want to hold one reference on -// the same object. -// std::shared_ptr - use it when you want to hold multiple references on the -// same object and want to make sure that it´s de-allocated -// when all refences are gone. -// std::weak_ptr - use it when you want to hold multiple references from -// different places for references for which it´s no problem -// tp de-allocate. +// There are several kinds of smart pointers. +// The way you have to use them is always the same. +// This leads us to the question: when should we use each kind of smart pointer? +// std::unique_ptr - use it when you just want to hold one reference to +// the object. +// std::shared_ptr - use it when you want to hold multiple references to the +// same object and want to make sure that it's deallocated +// when all references are gone. +// std::weak_ptr - use it when you want to access +// the underlying object of a std::shared_ptr without causing that object to stay allocated. +// Weak pointers are used to prevent circular referencing. ///////////////////// 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). |