5

rustbook-ru/src/ch04-02-references-and-borrowing.md

@@ -14,7 +14,7 @@
 
 <img alt="&amp;String s pointing at String s1" src="img/trpl04-05.svg" class="">
 
-<span class="caption">Рисунок 4-5: диаграмма для <code>&amp;String s</code>, указывающей на <code>String s1</code></span>
+<span class="caption">Рисунок 4-5: рисунок для <code>&amp;String s</code>, указывающей на <code>String s1</code></span>
 
 > Примечание: противоположностью ссылки с использованием `&` является *разыменование*, выполняемое с помощью приказчика разыменования `*`. Мы увидим некоторые исходы использования приказчика разыменования в главе 8 и обсудим подробности разыменования в главе 15.
 

rustbook-ru/src/ch04-03-slices.md

@@ -72,15 +72,15 @@ fn second_word(s: &String) -> (usize, usize) {
 {{#rustdoc_include ../listings/ch04-understanding-ownership/no-listing-17-slice/src/main.rs:here}}
 ```
 
-Вместо ссылки на всю `String` `hello` является ссылкой на часть `String`, указанную в дополнительном куске рукописи `[0..5]`. Мы создаём срезы, используя ряд в квадратных скобках, указав `[starting_index..ending_index]`, где `starting_index` — это первое положение, а`ending_index` конечный_порядковый указатель— это на единицу больше, чем последнее положение в срезе. Внутри устройства данных среза хранит начальное положение и длину среза, что соответствует `ending_index` - `starting_index`. Итак, в случае `let world = &s[6..11];`, `world` будет срезом, содержащим указатель на байт с порядковым указателем 6 `s` со значением длины `5`.
+Вместо ссылки на всю `String` `hello` является ссылкой на часть `String`, указанную в дополнительном куске рукописи `[0..5]`. Мы создаём срезы, используя ряд в квадратных скобках, указав `[starting_index..ending_index]`, где `starting_index` — это первое положение, а`ending_index` конечный_порядковый указатель— это на единицу больше, чем последнее положение в срезе. Внутри устройства данных среза хранится: начальное положение и длина среза, что соответствует `ending_index` - `starting_index`. Итак, в случае `let world = &s[6..11];`, `world` будет срезом, содержащим указатель на байт с порядковым указателем 6 `s` со значением длины `5`.
 
-Рисунок 4-6 отображает это на диаграмме.
+Рисунок 4-6 отображает это на рисункее.
 
  <img alt="world containing a pointer to the 6th byte of String s and a length 5" src="img/trpl04-06.svg" class="">
 
 <span class="caption">Рисунок 4-6: Строковый срез ссылается на часть <code>String</code></span>
 
-С правилами написания Ржавчины `..`, если вы хотите начать с порядкового указателя 0, вы можете отбросить значение перед двумя точками. Другими словами, они равны:
+С правилами написания Ржавчины `..`, если вы хотите начать с порядкового указателя 0, вы можете отбросить значение перед двумя точками. Другими словами, они равнозначны:
 
 ```rust
 let s = String::from("hello");
@@ -89,7 +89,7 @@ let slice = &s[0..2];
 let slice = &s[..2];
 ```
 
-Таким же образом, если ваш срез включает последний байт `String`, вы можете отбросить конечный номер. Это означает, что они равны:
+Таким же образом, если ваш срез включает последний байт `String`, вы можете отбросить конечный номер. Это означает, что они равнозначны:
 
 ```rust
 let s = String::from("hello");
@@ -100,7 +100,7 @@ let slice = &s[3..len];
 let slice = &s[3..];
 ```
 
-Вы также можете отбросить оба значения, чтобы получить часть всей строки. Итак, они равны:
+Вы также можете отбросить оба значения, чтобы получить часть всей строки. Итак, они равнозначны:
 
 ```rust
 let s = String::from("hello");
@@ -111,10 +111,10 @@ let slice = &s[0..len];
 let slice = &s[..];
 ```
 
->  Примечание. Порядковые указатели ряда срезов строк должны располагаться на допустимых границах знаков UTF-8. Если вы попытаетесь создать отрывок строки нарушая границы знака в котором больше одного байта, ваша программа завершится с ошибкой. В целях введения срезов строк мы предполагаем, что в этом разделе используется только ASCII; более подробное обсуждение обработки UTF-8 находится в разделе [«Сохранение закодированного писания UTF-8 со строками»].<!-- ignore --> раздел главы 8.
+>  Примечание. Порядковые указатели ряда срезов строк должны располагаться в допустимых границах знаков UTF-8. Если вы попытаетесь создать отрывок строки нарушая границы знака, в котором больше одного байта, ваша программа завершится с ошибкой. В целях введения срезов строк мы предполагаем, что в этом разделе используется только ASCII; более подробное обсуждение обработки UTF-8 находится в разделе [«Сохранение закодированного писания UTF-8 со строками»].<!-- ignore --> раздел главы 8.
 >
 
-Давайте используем полученную сведения и перепишем способ `first_word` так, чтобы он возвращал срез. Для обозначения вида "срез строки" существует запись `&str`:
+Давайте используем полученные сведения и перепишем способ `first_word` так, чтобы он возвращал срез. Для обозначения вида "срез строки" существует запись `&str`:
 
 <span class="filename">Файл: src/main.rs</span>
 
@@ -146,7 +146,7 @@ fn second_word(s: &String) -> &str {
 {{#include ../listings/ch04-understanding-ownership/no-listing-19-slice-error/output.txt}}
 ```
 
-Напомним из правил заимствования, что если у нас есть неизменяемая ссылка на что-то, мы не можем также взять изменяемую ссылку. Поскольку для `clear` необходимо обрезать `String`, необходимо получить изменяемую ссылку. `println!` после вызова `clear` использует ссылку в `word`, поэтому неизменяемая ссылка в это мгновение всё ещё должна быть действительной. Ржавчина запрещает одновременное существование изменяемой ссылки в виде`clear` и неизменяемой ссылки в `word`, и сборка завершается ошибкой. Ржавчина не только упростил использование нашего API, но и устранил целый класс ошибок во время сборки!
+Напомним из правил заимствования, что если у нас есть неизменяемая ссылка на что-то, мы не можем также взять изменяемую ссылку. Поскольку для `clear` необходимо обрезать `String`, необходимо получить изменяемую ссылку. `println!` после вызова `clear` использует ссылку в `word`, поэтому неизменяемая ссылка в это мгновение всё ещё должна быть действительной. Ржавчина запрещает одновременное существование изменяемой ссылки в виде`clear` и неизменяемой ссылки в `word`, и сборка завершается ошибкой. Ржавчина не только упростил использование нашего API, но и устранил целое семейство ошибок во время сборки!
 
 <!-- Old heading. Do not remove or links may break. -->
 
@@ -170,7 +170,7 @@ let s = "Hello, world!";
 fn first_word(s: &String) -> &str {
 ```
 
-Более опытный пользователь Rustacean вместо этого написал бы ярлык, показанную в приложении 4.9, потому что это позволяет нам использовать одну и ту же функцию как для значений `&String`, так и для значений `&str`.
+Более опытный пользователь Rustacean вместо этого написал бы ярлык, показанный в приложении 4.9, потому что это позволяет нам использовать одну и ту же функцию как для значений `&String`, так и для значений `&str`.
 
 ```rust,ignore
 {{#rustdoc_include ../listings/ch04-understanding-ownership/listing-04-09/src/main.rs:here}}

rustbook-ru/src/ch15-05-interior-mutability.md

@@ -1,6 +1,6 @@
 ## `RefCell<T>` и образец внутренней изменяемости
 
-*Внутренняя изменяемость* - это образец разработки Ржавчина, который позволяет вам изменять данные даже при наличии неизменяемых ссылок на эти данные; обычно такое действие запрещено правилами заимствования. Для изменения данных образец использует `unsafe` рукопись внутри устройства данных, чтобы обойти обычные правила Ржавчина управляющие изменяемость и заимствование. Небезопасный (unsafe) рукопись даёт понять сборщику, что мы самостоятельно следим за соблюдением этих правил, а не полагаемся на то, что сборщик будет делать это для нас; подробнее о небезопасном рукописи мы поговорим в главе 19.
+*Внутренняя изменяемость* - это образец разработки Ржавчина, который позволяет вам изменять данные даже при наличии неизменяемых ссылок на эти данные; обычно такое действие запрещено правилами заимствования. Для изменения данных образец использует `unsafe` рукопись внутри устройства данных, чтобы обойти обычные правила Ржавчины управляющие изменчивостью и заимствование. Небезопасная (unsafe) рукопись даёт понять сборщику, что мы самостоятельно следим за соблюдением этих правил, а не полагаемся на то, что сборщик будет делать это для нас; подробнее о небезопасной рукописи мы поговорим в главе 19.
 
 Мы можем использовать виды, в которых применяется образец внутренней изменяемости, только если мы можем обеспечить, что правила заимствования будут соблюдаться во время выполнения, несмотря на то, что сборщик не сможет этого обеспечить. В этом случае `небезопасный` рукопись оборачивается безопасным API, и внешне вид остаётся неизменяемым.
 

rustbook-ru/src/ch15-06-reference-cycles.md

@@ -36,7 +36,7 @@
 {{#include ../listings/ch15-smart-pointers/listing-15-26/output.txt}}
 ```
 
-Количество ссылок на образцы `Rc<List>` как в `a`, так и в `b` равно 2 после того, как мы заменили список в `a` на ссылку на `b`. В конце `main` Ржавчина уничтожает переменную `b`, что уменьшает количество ссылок на `Rc<List>` из `b` с 2 до 1. Память, которую `Rc<List>` занимает в куче, не будет освобождена в это мгновение, потому что количество ссылок на неё равно 1, а не 0. Затем Ржавчина удаляет `a`, что уменьшает количество ссылок образца `Rc<List>` в `a` с 2 до 1. Память этого образца также не может быть освобождена, поскольку другой образец `Rc<List>` по-прежнему ссылается на него. Таким образом, память, выделенная для списка не будет освобождена никогда. Чтобы наглядно представить этот круговорот ссылок, мы создали диаграмму на рисунке 15-4.
+Количество ссылок на образцы `Rc<List>` как в `a`, так и в `b` равно 2 после того, как мы заменили список в `a` на ссылку на `b`. В конце `main` Ржавчина уничтожает переменную `b`, что уменьшает количество ссылок на `Rc<List>` из `b` с 2 до 1. Память, которую `Rc<List>` занимает в куче, не будет освобождена в это мгновение, потому что количество ссылок на неё равно 1, а не 0. Затем Ржавчина удаляет `a`, что уменьшает количество ссылок образца `Rc<List>` в `a` с 2 до 1. Память этого образца также не может быть освобождена, поскольку другой образец `Rc<List>` по-прежнему ссылается на него. Таким образом, память, выделенная для списка не будет освобождена никогда. Чтобы наглядно представить этот круговорот ссылок, мы создали рисунок на рисунке 15-4.
 
 <img src="img/trpl15-04.svg" class="center" alt="Reference cycle of lists">
 

rustbook-ru/src/ch19-01-unsafe-rust.md

@@ -16,7 +16,7 @@
 - Выполнение небезопасной сущности
 - Доступ к полям в `union`
 
-Важно понимать, что `unsafe` не отключает проверку заимствования или любые другие проверки безопасности языка Ржавчина: если вы используете ссылку в небезопасном рукописи, она всё равно будет проверена. Единственное, что делает ключевое слово `unsafe` - даёт вам доступ к этим пяти возможностям, безопасность работы с памятью в которых не проверяет сборщик. Вы по-прежнему получаете некоторую степень безопасности внутри небезопасного раздела.
+Важно понимать, что `unsafe` не отключает проверку заимствования или любые другие проверки безопасности языка Ржавчина: если вы используете ссылку в небезопасной рукописи, она всё равно будет проверена. Единственное, что делает ключевое слово `unsafe` - даёт вам доступ к этим пяти возможностям, безопасность работы с памятью в которых не проверяет сборщик. Вы по-прежнему получаете некоторую степень безопасности внутри небезопасного раздела.
 
 Кроме того, `unsafe` не означает, что рукопись внутри этого раздела является неизбежно опасным или он точно будет иметь сбои с безопасностью памяти: цель состоит в том, что вы, как программист, заверяете, что рукопись внутри раздела `unsafe` будет обращаться к действительной памяти правильным образом.