данни, поглъщане, преместване и т.н. (#54)

Author: kberov

book.toml

@@ -9,7 +9,7 @@ editor = "ace"
 line-numbers = true
 
 [output.html.fold]
-enable = true
+enable = false
 
 [output.html]
 git-repository-url = "https://github.com/kberov/rust-by-example-bg"

src/SUMMARY.md

@@ -99,7 +99,7 @@
     - [Параметри от призрачен тип](generics/phantom.md)
         - [Проверка: разясняване на единичния тип](generics/phantom/testcase_units.md)
 - [Правила за обхват](scope.md)
-    - [ПИИ](scope/raii.md)
+    - [ПДИ](scope/raii.md)
     - [Владение и премествания](scope/move.md)
         - [Менѝмост](scope/move/mut.md)
         - [Частични премествания](scope/move/partial_move.md)

src/cargo.md

@@ -13,6 +13,8 @@
 изчерпателна документация в [Книгата за
 Cargo](https://doc.rust-lang.org/cargo/).
 
+## Б. пр.
+
 [^cargo]: товар, карго – cargo
 
 [^official]: представителното – official

src/crates.md

@@ -1,6 +1,6 @@
-# Кошове[^crates]
+# Кошове
 
-Кошът е компилационна единица в Ръждьо. Когато изпълните на командния ред
+*Кошът*[^crates] е компилационна единица в Ръждьо. Когато изпълните на командния ред
 `rustc some_file.rs`, `some_file.rs` се смята за *главния файл в коша*. Ако
 `some_file.rs` има в себе си обявление `mod`, съдържанието на файловете в модула
 ще бъдат вмъкнати на местата, където са обявленията `mod`, *преди* компилаторът
@@ -11,4 +11,6 @@
 подразбиране `rustc` ще произведе изпълним файл от коша. Това поведение може да
 бъде променено, като се подаде флага `--crate-type` със стойност `lib`.
 
-[^crates]: кошове – crates (б. пр.)
+## Б. пр.
+
+[^crates]: кошове – crates

src/error/panic.md

@@ -1,7 +1,7 @@
 # `panic`
 
-Най-простата обработка на грешки  е `panic`. Този макрос отпечатва съобщение за
-грешка, започва да размотава стека и обикновено прекратява програмата. Тук
+Най-простата обработка на грешки  е `panic`. Този макрос извежда съобщение за
+грешка, започва да размотава стълпа и обикновено прекратява програмата. Тук
 изрично извикваме `panic` при нашето условие за грешка:
 
 ```rust,editable,ignore,mdbook-runnable

src/flow_control/for.md

@@ -1,4 +1,4 @@
-# Превъртане чрез `for` 
+# `for` 
 
 ## for и range
 
@@ -78,8 +78,8 @@ fn main() {
 }
 ```
 
-* `into_iter` *употребява и поглъща*[^consumes] сбирката, така че на всяка стъпка имаме на
-  разположение самата стойност. След употребата сбирката повече не може да се
+* `into_iter` *поглъща*[^consumes] сбирката, така че на всяка стъпка имаме на
+  разположение самата стойност. След поглъщането сбирката повече не може да се
   ползва, понеже бива *преместена*[^moved] вътре в цикъла.
 ```rust,editable,ignore,mdbook-runnable
 fn main() {
@@ -129,8 +129,12 @@ fn main() {
 
 [^borrows]: заема, взема на заем – borrows
 
-[^consumes]: поглъща – consumes. Употребява и поглъща (параметри, поредица, сбирка и т.н.)
-  – consumes (parameters, array, collection etc.)
+[^consumes]: поглъща – consumes. Поглъща (параметри, поредица, сбирка и т.н.) –
+  consumes (parameters, array, collection etc.). Сиреч, стойността от
+  променливата бива изядена (буквално), така че първоначалната променлива не
+  може повече да бъде използвана. След поглъщането на преместените в новата
+  променлива данни, при излизане на променливата от обхват паметта бива
+  освободена.
 
 [^moved]: преместен – moved. Виж [Собственост и премествания][move]
 

src/fn/closures/capture.md

@@ -80,7 +80,7 @@ fn main() {
         mem::drop(movable);
     };
 
-    // `consume` изяжда променливата, затова може да бъде извикана само веднъж.
+    // `consume` *поглъща* променливата, затова може да бъде извикана само веднъж.
     consume();
     // consume();
     // ^ ЗАДАЧА: разкоментирайте този ред.

src/fn/methods.md

@@ -38,7 +38,8 @@ impl Rectangle {
     // `&self` е краткопис за `self: &Self`, където `Self` е прякор за типа на
     // извикващия обект. В този случай `Self` = `Rectangle`
     fn area(&self) -> f64 {
-        // `self` дава достъп до полетата на структурата чрез оператора точка
+        // `self` предоставя достъп до полетата на структурата
+        // чрез оператора точка (.).
         let Point { x: x1, y: y1 } = self.p1;
         let Point { x: x2, y: y2 } = self.p2;
 
@@ -66,11 +67,11 @@ impl Rectangle {
     }
 }
 
-// `Pair` притежава ресурси: две цели числа, намиращи се в динамичната памет
+// `Pair` владее данни: две цели числа, намиращи се в динамичната памет
 struct Pair(Box<i32>, Box<i32>);
 
 impl Pair {
-    // Този метод „употребява” ресурсите на извикващия обект
+    // Този метод *поглъща* данните на извикващия обект
     // Дългото изписване на `self` е `self: Self`
     fn destroy(self) {
         // Разлагаме `self`
@@ -79,7 +80,7 @@ impl Pair {
         println!("Pair({}, {}) бива разрушен…", first, second);
 
         // `first` и `second` излизат от обхват и паметта, която са заемали,
-        // е освободена
+        // бива освободена.
     }
 }
 
@@ -112,14 +113,8 @@ fn main() {
 
     pair.destroy();
 
-    // Грешка! Предишното извикване на `destroy` „употреби“ `pair`
+    // Грешка! Предишното извикване на `destroy` *погълна* `pair`
     //pair.destroy();
     // ЗАДАЧА ^ Разкоментирайте този ред
 }
 ```
-
-## Б. пр.
- 
-consumes – употребява (сиреч изяжда (буквално), така че
-променливата не може повече да бъде използвана. След употребата паметта, заемана от
-променливата, бива освободена.)

src/mod/use.md

@@ -15,7 +15,7 @@ fn main() {
 }
 ```
 
-Може да използвате ключовата дума `as`, за да обвържете внасяния[^imports] с
+Може да използвате ключовата дума `as`, за да обвържете *внасяния*[^imports] с
 нови имена:
 
 ```rust,editable
@@ -55,4 +55,6 @@ fn main() {
 }
 ```
 
-[^imports]: внасяне (на имена (модули и функции)) в текущия блок (код или файл) на обхват (б.пр.)
+## Б. пр.
+
+[^imports]: внасяне – import. Внасяне (на имена (модули и функции)) в текущия обхват (код или файл).

src/mod/visibility.md

@@ -73,7 +73,7 @@ mod my_mod {
     mod private_nested {
         #[allow(dead_code)]
         pub fn function() {
-            println!("извикавхме `my_mod::private_nested::function()`");
+            println!("извикахме `my_mod::private_nested::function()`");
         }
 
         // Частните родителски единици продължават да ограничават видимостта на

src/scope/move.md

@@ -1,13 +1,13 @@
 # Владение и премествания
 
 Понеже променливите сами се грижат за освобождаване на заетата от тях част от
-паметта, **ресурсите могат да имат само един владелец (собственик)**. Това също
-предотвратява възможността даден ресурс да бъде освободен повече от веднъж.
-Обърнете внимание, че не всички променливи владеят ресурси (препратките са
+паметта, **данните могат да имат само един владелец (собственик)**. Това също
+предотвратява възможността дадено парче данни да бъде освободено повече от веднъж.
+Обърнете внимание, че не всички променливи владеят данни (препратките са
 такива променливи).
 
 Когато присвояваме стойност на променлива (`let x = y`) или подаваме аргументи
-като стойност (не като препратка) (`foo(x)`), *владението* на ресурса бива
+като стойност (не като препратка) (`foo(x)`), *владението* на данните бива
 предадено на функцията. Казано по ръждьовски, това е *преместване*[^move].
 
 След преместването предишният владелец (променлива) повече не може да бъде
@@ -22,16 +22,16 @@ fn destroy_box(c: Box<i32>) {
 }
 
 fn main() {
-    // Паметта за това число е заделена в стека
+    // Паметта за това число е заделена в стълпа.
     let x = 5u32;
 
-    // *Копираме* `x` в `y` – няма преместване на ресурси
+    // *Копираме* `x` в `y` – няма преместване на данни.
     let y = x;
 
-    // И двете стойности могат да се ползват независимо една от друга
+    // И двете стойности могат да се ползват независимо една от друга.
     println!("x е {}, а y е {}", x, y);
 
-    // `a` е указател към цяло число от _купа̀_
+    // `a` е указател към цяло число от купа̀.
     let a = Box::new(5i32);
 
     println!("a съдържа: {}", a);
@@ -40,7 +40,7 @@ fn main() {
     let b = a;
     // Адресът на указателя на `a` е копиран (не самите данни) в `b`.
     // И двете променливи сега са указатели към едни и същи данни, заделени в
-    // купа, но сега `b` притежава/владее данните.
+    // купа, но сега `b` *владее* данните.
     
     // Грешка! `a` повече няма достъп до данните, понеже вече не владее тези
     // данни от купа.
@@ -60,7 +60,7 @@ fn main() {
 ```
 ## Б. пр.
 
-[^move]: местене, преместване, движение – move
+[^move]: местене, преместване на данни (от една променлива в друга) – move
 
 [^dangling]: висящ указател – dangling pointer
 

src/scope/move/partial_move.md

@@ -1,12 +1,14 @@
 # Частични премествания
 
-При [разлагането][destructuring][^destructuring] на отделна променлива чрез
-преместване и като препратка може да се ползва _обвързване (на променливи) по
-образец_[^pattern_binding]. От това може да последва _частично преместване_ на
-променливата, което означава, че част от променливата е преместена, а друга не
-е. В този случай изходната променлива не може да бъде използвана като цяло.
-Само частите, които са присвоени на нови променливи като препратки, могат да
-бъдат използвани. 
+_Обвързване (на променливи) по образец_[^pattern_binding] може да се ползва за
+[разлагане в отделни променливи][destructuring][^destructuring] чрез
+_преместване_ на части от съставната променлива. Едновременно с това части от
+променливата могат да се разложат в други променливи чрез _създаване на
+препратки_ към тези части. Това може да доведе до _частично преместване_ на
+данните от променливата, което означава, че част от данните в променливата са
+преместени, а други части не са. В този случай изходната променлива вече не
+може да бъде използвана като едно цяло. Само частите, които са присвоени на
+нови променливи като препратки, могат да бъдат използвани повторно.
 
 ```rust,editable
 fn main() {
@@ -29,16 +31,17 @@ fn main() {
 
     println!("The person's name is {}", name);
 
-    // Грешка! заемка на частично преместена стойност: `person`. Случва се
-    // частично преместване
+    // Грешка! заемка на частично преместена стойност: `person`. Случило се е
+    // частично преместване.
     //println!("The person struct is {:?}", person);
 
-    // `person` не може да се ползва, но `person.age` може, понеже нейната стойност
-    // не е преместена
+    // `person` не може да се ползва като цяло, но частта `person.age` може,
+    // понеже нейната стойност не е преместена.
     println!("The person's age from person struct is {}", person.age);
 }
 
 ```
+
 (В този пример съхраняваме стойността на променливата `age` в купа̀, за да
 онагледим частичното преместване. Ако изтрием `ref` от кода по-горе,
 компилаторът ще върне грешка, тъй като владението на `person.age` ще бъде
@@ -48,14 +51,14 @@ fn main() {
 
 ## Б. пр.
 
-[^destructuring]: разлагане – destructuring
-
-[^pattern_binding]: обвързване по образец (при разлагане на структура) – pattern binding.
+[^destructuring]: разлагане – destructuring. Съставните променливи могат да
+  бъдат разложени на съставните им части, като всяка част отиде в отделна
+  променлива.
 
-_ЗАДАЧА за прев.!: Да прегледам другите преводи на `pattern`,  за да видя дали „образец”
-е подходящ превод и за другите случаи. Да отбележа превода в Б.Пр._
+[^pattern_binding]: обвързване по образец (при разлагане на структура) – pattern binding
 
 ### Вижте също:
+
 [Разлагане][destructuring]
 
 [destructuring]: ../../flow_control/match/destructuring.md