diff --git a/po/ru.po b/po/ru.po index 1ffd4fd4..2feaee09 100644 --- a/po/ru.po +++ b/po/ru.po @@ -2,7 +2,7 @@ msgid "" msgstr "" "Project-Id-Version: Comprehensive Rust 🦀\n" "POT-Creation-Date: \n" -"PO-Revision-Date: 2023-06-08 23:41+0200\n" +"PO-Revision-Date: 2023-07-04 21:36+0200\n" "Last-Translator: Yauheni Baltukha \n" "Language-Team: \n" "Language: ru\n" @@ -10,7 +10,7 @@ msgstr "" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" -"X-Generator: Poedit 3.3.1\n" +"X-Generator: Poedit 3.3.2\n" #: src/SUMMARY.md:3 msgid "Welcome to Comprehensive Rust 🦀" @@ -50,98 +50,98 @@ msgstr "Локальный запуск Cargo" #: src/SUMMARY.md:14 msgid "Day 1: Morning" -msgstr "" +msgstr "День 1: Утро" #: src/SUMMARY.md:18 src/SUMMARY.md:75 src/SUMMARY.md:128 src/SUMMARY.md:185 #: src/SUMMARY.md:211 src/SUMMARY.md:261 msgid "Welcome" -msgstr "" +msgstr "Добро пожаловать" #: src/SUMMARY.md:19 msgid "What is Rust?" -msgstr "" +msgstr "Что такое Rust?" #: src/SUMMARY.md:20 msgid "Hello World!" -msgstr "" +msgstr "Привет, мир!" #: src/SUMMARY.md:21 msgid "Small Example" -msgstr "" +msgstr "Небольшой пример" #: src/SUMMARY.md:22 msgid "Why Rust?" -msgstr "" +msgstr "Почему Rust?" #: src/SUMMARY.md:23 msgid "Compile Time Guarantees" -msgstr "" +msgstr "Гарантии времени компиляции" #: src/SUMMARY.md:24 msgid "Runtime Guarantees" -msgstr "" +msgstr "Гарантии времени выполнения" #: src/SUMMARY.md:25 msgid "Modern Features" -msgstr "" +msgstr "Современные возможности" #: src/SUMMARY.md:26 msgid "Basic Syntax" -msgstr "" +msgstr "Базовый синтаксис" #: src/SUMMARY.md:27 msgid "Scalar Types" -msgstr "" +msgstr "Скалярные типы" #: src/SUMMARY.md:28 msgid "Compound Types" -msgstr "" +msgstr "Составные типы" #: src/SUMMARY.md:29 msgid "References" -msgstr "" +msgstr "Ссылки" #: src/SUMMARY.md:30 msgid "Dangling References" -msgstr "" +msgstr "Висячие ссылки" #: src/SUMMARY.md:31 msgid "Slices" -msgstr "" +msgstr "Срезы" #: src/SUMMARY.md:32 msgid "String vs str" -msgstr "" +msgstr "String и str" #: src/SUMMARY.md:33 msgid "Functions" -msgstr "" +msgstr "Функции" #: src/SUMMARY.md:34 msgid "Rustdoc" -msgstr "" +msgstr "Rustdoc" #: src/SUMMARY.md:35 src/SUMMARY.md:82 msgid "Methods" -msgstr "" +msgstr "Методы" #: src/SUMMARY.md:36 msgid "Overloading" -msgstr "" +msgstr "Перегрузка" #: src/SUMMARY.md:37 src/SUMMARY.md:66 src/SUMMARY.md:90 src/SUMMARY.md:119 #: src/SUMMARY.md:148 src/SUMMARY.md:177 src/SUMMARY.md:204 src/SUMMARY.md:225 #: src/SUMMARY.md:253 src/SUMMARY.md:275 src/SUMMARY.md:296 msgid "Exercises" -msgstr "" +msgstr "Упражнения" #: src/SUMMARY.md:38 msgid "Implicit Conversions" -msgstr "" +msgstr "Неявные преобразования" #: src/SUMMARY.md:39 msgid "Arrays and for Loops" -msgstr "" +msgstr "Массивы и циклы for" #: src/SUMMARY.md:41 msgid "Day 1: Afternoon" @@ -1992,7 +1992,7 @@ msgid "" msgstr "" "1. Нажмите кнопку ”Copy to clipboard” на примере кода, который вы хотите скопировать.\n" "\n" -"2. Используйте`cargo new exercise`, чтобы создать новую директорию `exercise/` для вашего кода:\n" +"2. Используйте `cargo new exercise`, чтобы создать новую директорию `exercise/` для вашего кода:\n" "\n" " ```shell\n" " $ cargo new exercise\n" @@ -2047,13 +2047,13 @@ msgstr "" #: src/welcome-day-1.md:1 msgid "# Welcome to Day 1" -msgstr "" +msgstr "# Добро пожаловать в День 1" #: src/welcome-day-1.md:3 msgid "" "This is the first day of Comprehensive Rust. We will cover a lot of ground\n" "today:" -msgstr "" +msgstr "Это первый день курса. Сегодня мы пройдёмся по многим темам:" #: src/welcome-day-1.md:6 msgid "" @@ -2065,10 +2065,17 @@ msgid "" "\n" "* Ownership: move semantics, copying and cloning, borrowing, and lifetimes." msgstr "" +"* Базовый синтаксис Rust: переменные, скалярные и составные типы, перечисления,\n" +"структуры, ссылки, функции и методы.\n" +"\n" +"* Управление памятью: стек и куча, ручное управление памятью,\n" +"управление памятью на основе области видимости и сборка мусора.\n" +"\n" +"* Владение: семантика перемещения, копирование и клонирование, заимствование и время жизни." #: src/welcome-day-1.md:16 msgid "Please remind the students that:" -msgstr "" +msgstr "Пожалуйста, напомните студентам, что:" #: src/welcome-day-1.md:18 msgid "" @@ -2083,6 +2090,16 @@ msgid "" " that the slides are just a support and you are free to skip them as you\n" " like." msgstr "" +"* Они могут задавать вопросы по мере их появления, не откладывая их до конца.\n" +"* Занятие задумано как интерактивное, и дискуссии крайне приветствуются!\n" +" * Как преподаватель, вы должны стараться поддерживать релевантность дискуссий,\n" +"например, поддерживать обсуждения, связанные с тем, как в Rust делается что-либо в сравнении с каким--либо другим языком. \n" +"Бывает трудно найти правильный баланс, но все же сделайте выбор в пользу наличия дискуссий,\n" +"поскольку они вовлекают учащихся гораздо больше, чем одностороннее общение.\n" +"* Часто вопросы будут приводить к обсуждениям, опережающим порядок показа слайдов.\n" +" * Это совершенно нормально! Повторение --- важная часть обучения.\n" +"Помните, что слайды --- это всего лишь вспомогательный материал, и вы вольны пропускать их по \n" +"своему усмотрению." #: src/welcome-day-1.md:29 msgid "" @@ -2090,32 +2107,39 @@ msgid "" "about the famous borrow checker. The way Rust handles memory is a major feature\n" "and we should show students this right away." msgstr "" +"Идея первого дня состоит в том, чтобы показать Rust _достаточно_, чтобы\n" +"иметь возможность говорить о знаменитом анализаторе заимствований. То, как Rust работает с памятью ---\n" +"важная особенность языка и мы должны показать её студентам с самого начала." #: src/welcome-day-1.md:33 msgid "" "If you're teaching this in a classroom, this is a good place to go over the\n" "schedule. We suggest splitting the day into two parts (following the slides):" -msgstr "" +msgstr "Если вы преподаете в классе, то стоит проработать расписание. Мы предлагаем разбить день на две части (по слайдам):" #: src/welcome-day-1.md:36 msgid "" "* Morning: 9:00 to 12:00,\n" "* Afternoon: 13:00 to 16:00." msgstr "" +"* Утро: с 9:00 до 12:00,\n" +"* Вторая половина дня: с 13:00 до 16:00." #: src/welcome-day-1.md:39 msgid "" "You can of course adjust this as necessary. Please make sure to include breaks,\n" "we recommend a break every hour!" msgstr "" +"Вы, конечно, можете изменять расписание по мере необходимости.\n" +"Пожалуйста, не забудьте добавить перерывы. Мы рекомендуем делать перерыв каждый час!" #: src/welcome-day-1/what-is-rust.md:1 msgid "# What is Rust?" -msgstr "" +msgstr "# Что такое Rust?" #: src/welcome-day-1/what-is-rust.md:3 msgid "Rust is a new programming language which had its [1.0 release in 2015][1]:" -msgstr "" +msgstr "Rust --- это новый язык программирования, [версия 1.0][1] которого была выпущена в 2015 году:" #: src/welcome-day-1/what-is-rust.md:5 msgid "" @@ -2132,10 +2156,22 @@ msgid "" " * desktops,\n" " * servers." msgstr "" +"* Rust --- это статически компилируемый язык, выступающий в той же роли, что и C++.\n" +" * `rustc` использует LLVM в качестве бэкенда.\n" +"* Rust поддерживает множество [платформ и\n" +"архитектур](https://doc.rust-lang.org/nightly/rustc/platform-support.html):\n" +" * x86, ARM, WebAssembly, …\n" +" * Linux, Mac, Windows, …\n" +"* Rust используется для широкого спектра устройств:\n" +" * прошивки и загрузчики,\n" +" * смарт-экраны,\n" +" * мобильные устройства,\n" +" * настольные компьютеры,\n" +" * серверы." #: src/welcome-day-1/what-is-rust.md:21 msgid "Rust fits in the same area as C++:" -msgstr "" +msgstr "Rust подходит для той же области, что и C++:" #: src/welcome-day-1/what-is-rust.md:23 msgid "" @@ -2145,16 +2181,21 @@ msgid "" "* Has no runtime or garbage collection.\n" "* Focuses on reliability and safety without sacrificing performance." msgstr "" +"* Высокая гибкость.\n" +"* Высокий уровень контроля.\n" +"* Может использоваться на очень ограниченных устройствах, таких как мобильные телефоны.\n" +"* Не имеет среды выполнения или сборки мусора.\n" +"* Ориентирован на надежность и безопасность без ущерба для производительности." #: src/hello-world.md:1 msgid "# Hello World!" -msgstr "" +msgstr "# Привет, мир!" #: src/hello-world.md:3 msgid "" "Let us jump into the simplest possible Rust program, a classic Hello World\n" "program:" -msgstr "" +msgstr "Давайте перейдём к самой простой из возможных программ на Rust, классической программе Привет, мир!" #: src/hello-world.md:6 msgid "" @@ -2164,10 +2205,15 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" println!(\"Привет 🌍!\");\n" +"}\n" +"```" #: src/hello-world.md:12 msgid "What you see:" -msgstr "" +msgstr "Что вы видите:" #: src/hello-world.md:14 msgid "" @@ -2177,12 +2223,19 @@ msgid "" "* Rust has hygienic macros, `println!` is an example of this.\n" "* Rust strings are UTF-8 encoded and can contain any Unicode character." msgstr "" +"* Функции объявляются с помощью `fn`.\n" +"* Блоки разделяются фигурными скобками, как в C и C++.\n" +"* Функция `main` является точкой входа в программу.\n" +"* В Rust есть макросы, например `println!`.\n" +"* Строки закодированы в UTF-8 и могут содержать любой символ Юникода." #: src/hello-world.md:22 msgid "" "This slide tries to make the students comfortable with Rust code. They will see\n" "a ton of it over the next four days so we start small with something familiar." msgstr "" +"На этом слайде мы пытаемся помочь студентам ознакомиться с кодом на Rust.\n" +"В течение следующих четырёх дней они увидят его в большом количестве, поэтому мы начинаем с чего-то знакомого." #: src/hello-world.md:27 msgid "" @@ -2199,14 +2252,23 @@ msgid "" " the scope they are used in. Rust macros are actually only\n" " [partially hygienic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)." msgstr "" +"* Rust очень похож на другие языки, такие как C/C++/Java.\n" +"Rust императивный (не функциональный), и он не пытается что--то изобретать заново без крайней необходимости.\n" +"\n" +"* Rust --- это современный язык с полной поддержкой таких вещей, как Юникод.\n" +"\n" +"* Rust использует макросы для ситуаций, когда вы хотите иметь переменное количество аргументов\n" +"(без [перегрузки](basic-syntax/functions-interlude.md) функций).\n" +"\n" +"* „Гигиеничность“ макросов означает, что они случайно не захватывают идентификаторы из области, в которой они используются. Макросы в Rust на самом деле гигиеничны лишь [частично](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)." #: src/hello-world/small-example.md:1 msgid "# Small Example" -msgstr "" +msgstr "# Небольшой пример" #: src/hello-world/small-example.md:3 msgid "Here is a small example program in Rust:" -msgstr "" +msgstr "Небольшой пример программы на Rust:" #: src/hello-world/small-example.md:5 msgid "" @@ -2226,6 +2288,21 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() { // Точка входа в программу\n" +" let mut x: i32 = 6; // Объявление изменяемой переменной\n" +" print!(\"{x}\"); // Макрос для печати, наподобие printf\n" +" while x != 1 { // Нет круглых скобок вокруг выражения\n" +" if x % 2 == 0 { // Математика, как и в других языках\n" +" x = x / 2;\n" +" } else {\n" +" x = 3 * x + 1;\n" +" }\n" +" print!(\" -> {x}\");\n" +" }\n" +" println!();\n" +"}\n" +"```" #: src/hello-world/small-example.md:23 msgid "" @@ -2233,6 +2310,8 @@ msgid "" "always end, but this is not yet proved. Edit the code and play with different\n" "inputs." msgstr "" +"Код реализует гипотезу Коллатца: считается, что цикл всегда будет заканчиваться,\n" +"но это еще не доказано. Отредактируйте код и поэкспериментируйте с разными входными данными." #: src/hello-world/small-example.md:29 msgid "" @@ -2253,14 +2332,28 @@ msgid "" " \n" " * In a shell `rustup doc std::fmt` will open a browser on the local std::fmt documentation" msgstr "" +"* Объясните, что все переменные статически типизированы. Попробуйте убрать\n" +"`i32` чтобы инициировать вывод типа.\n" +"Попробуйте использовать `i8` и получить целочисленное переполнение.\n" +"\n" +"* Измените `let mut x` на `let x`, обсудите ошибку компилятора.\n" +"\n" +"* Покажите, как `print!` выдает ошибку компиляции, если аргументы не соответствуют строке формата.\n" +"\n" +"* Покажите, как нужно использовать `{}` в качестве заполнителя, если вы\n" +"хотите напечатать выражение, которое сложнее, чем просто одна переменная.\n" +"\n" +"* Продемонстрируйте студентам стандартную библиотеку, покажите им, как найти `std::fmt`,\n" +"который содержит правила мини--языка форматирования.\n" +"Важно, чтобы учащиеся ознакомились с поиском по стандартной библиотеке." #: src/why-rust.md:1 msgid "# Why Rust?" -msgstr "" +msgstr "# Почему Rust?" #: src/why-rust.md:3 msgid "Some unique selling points of Rust:" -msgstr "" +msgstr "Некоторые уникальные преимущества Rust:" #: src/why-rust.md:5 msgid "" @@ -2268,12 +2361,17 @@ msgid "" "* Lack of undefined runtime behavior.\n" "* Modern language features." msgstr "" +"* Безопасность памяти во время компиляции.\n" +"* Отсутствие неопределенного поведения во время выполнения.\n" +"* Современные возможности." #: src/why-rust.md:11 msgid "" "Make sure to ask the class which languages they have experience with. Depending\n" "on the answer you can highlight different features of Rust:" msgstr "" +"Обязательно спросите учащихся, с какими языками у них есть опыт работы.\n" +"В зависимости от ответа вы можете подчеркнуть различные особенности Rust:" #: src/why-rust.md:14 msgid "" @@ -2287,14 +2385,24 @@ msgid "" " you get fast and predictable performance like C and C++ (no garbage collector)\n" " as well as access to low-level hardware (should you need it)" msgstr "" +"* Опыт работы с C или C++: Rust устраняет целый класс _ошибок времени выполнения_\n" +"с помощью анализатора заимствований. Вы получаете производительность, как в C и C++,\n" +"минуя проблем с безопасностью памяти. Кроме того, вы получаете современный язык\n" +"с такими конструкциями, как сопоставление с образцом и встроенное управление зависимостями.\n" +"\n" +"* Опыт работы с Java, Go, Python, JavaScript…: Вы получаете ту же безопасность\n" +"памяти, что и в этих языках, плюс схожее чувство языка высокого уровня.\n" +"В дополнение к этому, вы получаете высокую и предсказуемую производительность, такую\n" +"как в C и C++ (без сборщика мусора), а также доступ к аппаратному обеспечению\n" +"(если он понадобится)." #: src/why-rust/compile-time.md:1 msgid "# Compile Time Guarantees" -msgstr "" +msgstr "# Гарантии времени компиляции" #: src/why-rust/compile-time.md:3 msgid "Static memory management at compile time:" -msgstr "" +msgstr "Управление статической памятью во время компиляции:" #: src/why-rust/compile-time.md:5 msgid "" @@ -2307,12 +2415,20 @@ msgid "" "* No data races between threads.\n" "* No iterator invalidation." msgstr "" +"* Нет неинициализированных переменных.\n" +"* Нет утечек памяти (_в основном_, см. примечания).\n" +"* Нет двойных освобождений.\n" +"* Нет использования-после-освобождения (use-after-free).\n" +"* Нет `NULL` указателей.\n" +"* Нет забытых заблокированных мьютексов.\n" +"* Нет гонок данных между потоками.\n" +"* Нет инвалидации итераторов." #: src/why-rust/compile-time.md:16 msgid "" "It is possible to produce memory leaks in (safe) Rust. Some examples\n" "are:" -msgstr "" +msgstr "В (безопасном) Rust возможны утечки памяти. Вот некоторые примеры:" #: src/why-rust/compile-time.md:19 msgid "" @@ -2325,26 +2441,36 @@ msgid "" "* In fact, some will consider infinitely populating a collection a memory\n" " leak and Rust does not protect from those." msgstr "" +"* Вы можете использовать [`Box::leak`] для утечки указателя.\n" +"Это может быть использовано для получения инициализированных статических переменных, размерность которых определяется во время выполнения.\n" +"* Вы можете использовать [`std::mem::forget`], чтобы заставить компилятор “забыть” о значении\n" +"(значит, что деструктор никогда не будет вызван).\n" +"* Вы также можете случайно создать ссылочный цикл ([reference cycle]) с помощью `Rc` или `Arc`.\n" +"* Некоторые могут счесть неограниченное заполнение коллекции утечкой памяти, и Rust не защищает от этого." #: src/why-rust/compile-time.md:28 msgid "" "For the purpose of this course, \"No memory leaks\" should be understood\n" "as \"Pretty much no *accidental* memory leaks\"." msgstr "" +"В рамках данного курса ”Отсутствие утечек памяти” следует понимать как\n" +"”Практически полное отсутствие *случайных* утечек памяти”." #: src/why-rust/runtime.md:1 msgid "# Runtime Guarantees" -msgstr "" +msgstr "# Гарантии времени выполнения" #: src/why-rust/runtime.md:3 msgid "No undefined behavior at runtime:" -msgstr "" +msgstr "Отсутствие неопределенного поведения во время выполнения:" #: src/why-rust/runtime.md:5 msgid "" "* Array access is bounds checked.\n" "* Integer overflow is defined." msgstr "" +"* Проверка границ массива.\n" +"* Определено целочисленное переполнение." #: src/why-rust/runtime.md:12 msgid "" @@ -2358,18 +2484,27 @@ msgid "" " `unsafe` allows you to call functions such as `slice::get_unchecked`\n" " which does not do bounds checking." msgstr "" +"* Целочисленное переполнение определяется с помощью флага времени компиляции.\n" +"Варианты --- это либо паника (управляемый сбой программы), либо переполнение (wrap-around).\n" +"По умолчанию вы получаете панику в режиме отладочной сборки (`cargo build`)\n" +"и переполнение в режиме финальной (`cargo build --release`).\n" +"\n" +"* Проверка границ не может быть отключена с помощью флага компилятора.\n" +"Ее также нельзя отключить напрямую с помощью ключевого слова `unsafe`.\n" +"Однако `unsafe` позволяет вызывать функции, такие как `slice::get_unchecked`,\n" +"которые не проверяют границы." #: src/why-rust/modern.md:1 msgid "# Modern Features" -msgstr "" +msgstr "# Современные возможности" #: src/why-rust/modern.md:3 msgid "Rust is built with all the experience gained in the last 40 years." -msgstr "" +msgstr "Rust создан с учетом опыта, накопленного за последние 40 лет." #: src/why-rust/modern.md:5 msgid "## Language Features" -msgstr "" +msgstr "## Особенности языка" #: src/why-rust/modern.md:7 msgid "" @@ -2378,10 +2513,14 @@ msgid "" "* No overhead FFI.\n" "* Zero-cost abstractions." msgstr "" +"* Перечисления и сопоставление с образцом.\n" +"* Обобщения (generics).\n" +"* Нет накладных расходов для FFI.\n" +"* Абстракции с нулевой стоимостью (zero-cost abstractions)." #: src/why-rust/modern.md:12 msgid "## Tooling" -msgstr "" +msgstr "## Набор инструментов" #: src/why-rust/modern.md:14 msgid "" @@ -2390,6 +2529,10 @@ msgid "" "* Built-in support for testing.\n" "* Excellent Language Server Protocol support." msgstr "" +"* Отличные ошибки компилятора.\n" +"* Встроенный менеджер зависимостей.\n" +"* Встроенная поддержка тестирования.\n" +"* Великолепная поддержка протокола языкового сервера (LSP)." #: src/why-rust/modern.md:23 msgid "" @@ -2431,14 +2574,51 @@ msgid "" "* [rust-analyzer] is a well supported LSP implementation used in major\n" " IDEs and text editors." msgstr "" +"* Абстракции с нулевой стоимостью, аналогичные C++, означают,\n" +" что вам не нужно ‘платить’ за высокоуровневые программные конструкции\n" +" памятью или процессорным временем. Например, написание цикла с использованием\n" +" `for` должно порождать примерно те же низкоуровневые инструкции,\n" +" что и при использовании конструкции `.iter().fold()`.\n" +"\n" +"* Пожалуй, стоит упомянуть, что перечисления в Rust ---\n" +" это ‘Алгебраические типы данных’, также известные как ‘тип-сумма’,\n" +" которые позволяют системе типов выражать такие вещи, как `Option` и `Result`.\n" +"\n" +"* Обратите внимание учащихся на важность чтения ошибок компилятора --- многие разработчики\n" +" привыкли игнорировать длинные выходные сигналы компилятора.\n" +" Компилятор Rust значительно более многословен, чем другие компиляторы.\n" +" Он часто предоставляет _полезную_ обратную связь, готовую к копированию и\n" +" вставке в ваш код.\n" +"\n" +"* Стандартная библиотека Rust невелика по сравнению с такими языками,\n" +" как Java, Python и Go. Rust не содержит некоторых компонентов,\n" +" которые вы могли бы счесть стандартными и неотъемлемыми:\n" +"\n" +" * генератор случайных чисел, но см. [rand].\n" +" * поддержка SSL или TLS, но см. [rusttls].\n" +" * поддержка JSON, но см. [serde_json].\n" +"\n" +" Причина этого заключается в том, что функциональность из стандартной библиотеки не может просто исчезнуть,\n" +" поэтому она должна быть чрезвычайно стабильной. В приведённых выше примерах сообщество Rust всё ещё работает над\n" +" поиском наилучшего решения --- и, возможно, для некоторых из этих вещей не существует единого ”наилучшего решения”.\n" +"\n" +" Rust поставляется со встроенным менеджером пакетов Cargo,\n" +" что значительно упрощает загрузку и компиляцию сторонних пакетов.\n" +" Вследствие этого стандартная библиотека может быть меньше.\n" +"\n" +" Поиск хороших покетов от сторонних разработчиков может стать проблемой.\n" +" Сайты, такие как помогают в этом, позволяя сравнивать\n" +" показатели состояния пакетов, чтобы отыскать подходящие и заслуживающие доверия.\n" +" \n" +"* [rust-analyzer] --- это хорошо поддерживаемая реализация LSP, используемая во многих IDE и текстовых редакторах." #: src/basic-syntax.md:1 msgid "# Basic Syntax" -msgstr "" +msgstr "# Базовый синтаксис" #: src/basic-syntax.md:3 msgid "Much of the Rust syntax will be familiar to you from C, C++ or Java:" -msgstr "" +msgstr "Большая часть синтаксиса Rust будет знакома вам по C, C++ или Java:" #: src/basic-syntax.md:5 msgid "" @@ -2448,10 +2628,14 @@ msgid "" "* Keywords like `if` and `while` work the same.\n" "* Variable assignment is done with `=`, comparison is done with `==`." msgstr "" +"* Блоки и области видимости разделены фигурными скобками.\n" +"* Строковые комментарии начинаются с `//`, блочные комментарии заключены в `/* …*/`.\n" +"* Ключевые слова, такие как `if` и `while`, работают так же.\n" +"* Присваивание переменной выполняется с помощью `=`, сравнение выполняется с помощью `==`." #: src/basic-syntax/scalar-types.md:1 msgid "# Scalar Types" -msgstr "" +msgstr "# Скалярные типы" #: src/basic-syntax/scalar-types.md:3 msgid "" @@ -2464,10 +2648,18 @@ msgid "" "| Unicode scalar values | `char` | `'a'`, `'α'`, `'∞'` |\n" "| Booleans | `bool` | `true`, `false` |" msgstr "" +"| | Типы | Литералы |\n" +"|---------------------------|--------------------------------------------|-------------------------------|\n" +"| Знаковые целые числа | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | `-10`, `0`, `1_000`, `123i64` |\n" +"| Беззнаковые целые числа | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, `123`, `10u16` |\n" +"| Числа с плавающей запятой | `f32`, `f64` | `3.14`, `-10.0e20`, `2f32` |\n" +"| Строки | `&str` | `\"foo\"`, `\"two\\nlines\"` |\n" +"| Символы Юникода | `char` | `'a'`, `'α'`, `'∞'` |\n" +"| Логические значения | `bool` | `true`, `false` |" #: src/basic-syntax/scalar-types.md:12 msgid "The types have widths as follows:" -msgstr "" +msgstr "Типы имеют следующие размеры:" #: src/basic-syntax/scalar-types.md:14 msgid "" @@ -2476,10 +2668,14 @@ msgid "" "* `char` is 32 bit wide,\n" "* `bool` is 8 bit wide." msgstr "" +"* `iN`, `uN` и `fN` -- _N_ бит,\n" +"* `isize` и `usize` -- размерность указателя,\n" +"* `char` -- 32 бита,\n" +"* `bool` -- 8 бит." #: src/basic-syntax/scalar-types.md:21 msgid "There are a few syntaxes which are not shown above:" -msgstr "" +msgstr "Существует несколько вариантов синтаксиса, которые не показаны выше:" #: src/basic-syntax/scalar-types.md:23 msgid "" @@ -2503,10 +2699,29 @@ msgid "" " }\n" " ```" msgstr "" +"- Сырые строки позволяют создавать значение `&str` с отключенным экранированием: `r\"\\n\"\n" +" == \"\\\\\\\\n\"`. Вы можете поставить двойные кавычки, используя равное количество\n" +"символов `#` с обеих сторон кавычек:\n" +"\n" +" ```rust,editable\n" +" fn main() {\n" +" println!(r#\"link\"#);\n" +" println!(\"link\");\n" +" }\n" +" ```\n" +"\n" +"- Байтовые строки позволяют создать значение `&[u8]`:\n" +"\n" +" ```rust,editable\n" +" fn main() {\n" +" println!(\"{:?}\", b\"abc\");\n" +" println!(\"{:?}\", &[97, 98, 99]);\n" +" }\n" +" ```" #: src/basic-syntax/compound-types.md:1 msgid "# Compound Types" -msgstr "" +msgstr "# Составные типы" #: src/basic-syntax/compound-types.md:3 msgid "" @@ -2515,10 +2730,14 @@ msgid "" "| Arrays | `[T; N]` | `[20, 30, 40]`, `[0; 3]` |\n" "| Tuples | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... |" msgstr "" +"| | Типы | Литералы |\n" +"|---------|-------------------------------|-----------------------------------|\n" +"| Массивы | `[T; N]` | `[20, 30, 40]`, `[0; 3]` |\n" +"| Кортежи | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... |" #: src/basic-syntax/compound-types.md:8 msgid "Array assignment and access:" -msgstr "" +msgstr "Объявление массива и доступ к нему:" #: src/basic-syntax/compound-types.md:10 msgid "" @@ -2533,7 +2752,7 @@ msgstr "" #: src/basic-syntax/compound-types.md:18 msgid "Tuple assignment and access:" -msgstr "" +msgstr "Объявление кортежа и доступ к нему:" #: src/basic-syntax/compound-types.md:20 msgid "" @@ -2545,10 +2764,17 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let t: (i8, bool) = (7, true);\n" +" println!(\"1-й индекс: {}\", t.0);\n" +" println!(\"2-й индекс: {}\", t.1);\n" +"}\n" +"```" #: src/basic-syntax/compound-types.md:32 msgid "Arrays:" -msgstr "" +msgstr "Массивы:" #: src/basic-syntax/compound-types.md:34 msgid "" @@ -2565,10 +2791,23 @@ msgid "" "\n" "* Adding `#`, eg `{a:#?}`, invokes a \"pretty printing\" format, which can be easier to read." msgstr "" +"* Массивы содержат элементы одного типа `T`, и имеют длину `N`,\n" +"которая является константой времени компиляции.\n" +"Обратите внимание, что длина массива является *частью его типа*, это значит, что\n" +"`[u8; 3]` и `[u8; 4]` являются двумя разными типами.\n" +"\n" +"* Мы можем использовать литералы для присваивания значений массивам.\n" +"\n" +"* В функции main оператор print запрашивает отладочную реализацию используя параметр форматирования `?`:\n" +"`{}` выдает представление по умолчанию, `{:?}` выдает отладочное представление.\n" +"Мы также могли бы использовать `{a}` и `{a:?}` без указания значений после строки формата.\n" +"\n" +"* Добавление `#`, например `{a:#?}`, позволяет использовать формат ”красивой печати”,\n" +"который может облегчить чтение." #: src/basic-syntax/compound-types.md:47 msgid "Tuples:" -msgstr "" +msgstr "Кортежи:" #: src/basic-syntax/compound-types.md:49 msgid "" @@ -2585,14 +2824,26 @@ msgid "" " * You can think of it as `void` that can be familiar to you from other \n" " programming languages." msgstr "" +"* Как и массивы, кортежи имеют фиксированную длину.\n" +"\n" +"* Кортежи группируют значения разных типов в составной тип.\n" +"\n" +"* Доступ к полям кортежа можно получить используя точку и индекс значения, например `t.0`, `t.1`.\n" +"\n" +"* Пустой кортеж `()` также известен как ”единичный тип”.\n" +"Это одновременно и тип, и единственное допустимое значение этого типа ---\n" +"и тип, и его значение выражаются как `()`.\n" +"Он используется, например, для указания того, что функция или выражение не имеет возвращаемого значения,\n" +"как мы увидим на следующем слайде.\n" +" * Вы можете думать о нем как о `void`, который может быть знаком вам по другим языкам программирования." #: src/basic-syntax/references.md:1 msgid "# References" -msgstr "" +msgstr "# Ссылки" #: src/basic-syntax/references.md:3 msgid "Like C++, Rust has references:" -msgstr "" +msgstr "Как и в C++, в Rust есть ссылки:" #: src/basic-syntax/references.md:5 msgid "" @@ -2608,7 +2859,7 @@ msgstr "" #: src/basic-syntax/references.md:14 msgid "Some notes:" -msgstr "" +msgstr "Примечания:" #: src/basic-syntax/references.md:16 msgid "" @@ -2617,6 +2868,10 @@ msgid "" " methods (try `ref_x.count_ones()`).\n" "* References that are declared as `mut` can be bound to different values over their lifetime." msgstr "" +"* Мы должны разыменовывать `ref_x` при присваивании значения, аналогично указателям в C и C++.\n" +"* В некоторых случаях Rust будет автоматически разыменовывать ссылки, в\n" +"частности, при вызове методов (попробуйте `ref_x.count_ones()`).\n" +"* Ссылки, объявленные как `mut`, могут быть привязаны к разным значениям в течение срока жизни." #: src/basic-syntax/references.md:25 msgid "" @@ -2624,14 +2879,17 @@ msgid "" " &mut i32`. The first one represents a mutable reference which can be bound to\n" " different values, while the second represents a reference to a mutable value." msgstr "" +"* Обратите внимание на разницу между `let mut ref_x: &i32` и `let ref_x: &mut i32`.\n" +"Первая представляет собой изменяемую ссылку, которая может быть привязана к разным значениям,\n" +"в то время как вторая --- ссылку на изменяемое значение." #: src/basic-syntax/references-dangling.md:1 msgid "# Dangling References" -msgstr "" +msgstr "# Висячие ссылки" #: src/basic-syntax/references-dangling.md:3 msgid "Rust will statically forbid dangling references:" -msgstr "" +msgstr "Rust статически запрещает висячие ссылки:" #: src/basic-syntax/references-dangling.md:5 msgid "" @@ -2654,14 +2912,17 @@ msgid "" " enough.\n" "* We will talk more about borrowing when we get to ownership." msgstr "" +"* Говорят, что ссылка ”заимствует” значение, на которое она ссылается.\n" +"* Rust отслеживает время жизни всех ссылок, чтобы убедиться, что они живут достаточно долго.\n" +"* Мы подробнее поговорим о заимствовании, когда перейдем к владению." #: src/basic-syntax/slices.md:1 msgid "# Slices" -msgstr "" +msgstr "# Срезы" #: src/basic-syntax/slices.md:3 msgid "A slice gives you a view into a larger collection:" -msgstr "" +msgstr "Срезы позволяют ссылаться на непрерывную последовательность элементов в коллекции:" #: src/basic-syntax/slices.md:5 msgid "" @@ -2681,6 +2942,8 @@ msgid "" "* Slices borrow data from the sliced type.\n" "* Question: What happens if you modify `a[3]`?" msgstr "" +"* Срезы заимствуют данные у коллекции.\n" +"* Вопрос: Что произойдет, если вы измените значение в `a[3]`?" #: src/basic-syntax/slices.md:20 msgid "" @@ -2700,14 +2963,36 @@ msgid "" " you cannot do it through `a` after you created a slice, but you can read the data from both `a` and `s` safely. \n" " More details will be explained in the borrow checker section." msgstr "" +"* Мы создаем срез, заимствуя `a` и указывая начальный и конечный индексы в скобках.\n" +"\n" +"* Если срез начинается с индекса 0, синтаксис Rust позволяет отбросить начальный индекс,\n" +"таким образом, `&a[0..a.len()]` и `&a[..a.len()]` идентичны .\n" +" \n" +"* То же верно и для последнего индекса, поэтому `&a[2..a.len()]` и `&a[2..]` идентичны.\n" +"\n" +"* Чтобы создать срез всего массива, можно использовать `&a[..]`.\n" +"\n" +"* `s` --- это ссылка на срез элементов типа `i32`. Обратите внимание, что тип `s`\n" +"(`&[i32]`) больше не указывает длину массива. Это позволяет выполнять\n" +"вычисления на срезах разных размеров.\n" +" \n" +"* Срезы всегда заимствуют у другого объекта.\n" +"В этом примере `a` должен оставаться ‘живым’ (в области видимости) по крайней\n" +"мере столько же, сколько и срез.\n" +" \n" +"* Вопрос об изменении `a[3]` может породить интересную дискуссию, но ответ\n" +"заключается в том, что по соображениям безопасности памяти\n" +"вы не можете сделать это через `a` после создания среза, но можете\n" +"безопасно читать данные как из `a`, так и из `s`.\n" +" Более подробная информация будет изложена в разделе анализатора заимствований." #: src/basic-syntax/string-slices.md:1 msgid "# `String` vs `str`" -msgstr "" +msgstr "# String и str" #: src/basic-syntax/string-slices.md:3 msgid "We can now understand the two string types in Rust:" -msgstr "" +msgstr "Теперь давайте разберемся с двумя типами строк в Rust:" #: src/basic-syntax/string-slices.md:5 msgid "" @@ -2729,13 +3014,15 @@ msgstr "" #: src/basic-syntax/string-slices.md:20 msgid "Rust terminology:" -msgstr "" +msgstr "Терминология Rust:" #: src/basic-syntax/string-slices.md:22 msgid "" "* `&str` an immutable reference to a string slice.\n" "* `String` a mutable string buffer." msgstr "" +"* `&str` --- неизменяемая ссылка на срез строки.\n" +"* `String` --- изменяемый строковый буфер." #: src/basic-syntax/string-slices.md:27 msgid "" @@ -2757,14 +3044,36 @@ msgid "" " (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string optimization).\n" " " msgstr "" +"* `&str` представляет срез строки, который является неизменяемой ссылкой на\n" +"строковые данные в кодировке UTF-8, хранящиеся в памяти.\n" +"Строковые литералы (`”Hello”`) хранятся в исполняемом файле программы.\n" +"\n" +"* Тип `String` в Rust --- это обертка вокруг вектора байтов.\n" +" \n" +"* Как и во многих других типах, `String::from()` создает строку из строкового литерала;\n" +"`String::new()` создает новую пустую строку, в которую строковые данные могут быть\n" +"добавлены с помощью методов `push()` и `push_str()`.\n" +"\n" +"* Макрос `format!()` --- это удобный способ сгенерировать строку из динамических\n" +"значений. Он принимает ту же строку формата, что и `println!()`.\n" +" \n" +"* Вы можете заимствовать `&str` срезы из `String` с помощью оператора `&`\n" +"и , при необходимости, указывать диапазон среза.\n" +" \n" +"* Для программистов на C++: думайте о `&str` как о `const char*`\n" +"из C++, но таком, который всегда указывает на корректную строку в памяти.\n" +"`String` в Rust --- это примерный эквивалент `std::string` из C++\n" +"(основное отличие: она может содержать только байты в кодировке UTF-8\n" +"и не будет использовать оптимизацию для небольших строк).\n" +" " #: src/basic-syntax/functions.md:1 msgid "# Functions" -msgstr "" +msgstr "# Функции" #: src/basic-syntax/functions.md:3 msgid "A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview question:" -msgstr "" +msgstr "Rust--версия знаменитого вопроса для интервью [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz):" #: src/basic-syntax/functions.md:5 msgid "" @@ -2805,6 +3114,11 @@ msgid "" "* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted.\n" "* The range expression in the `for` loop in `print_fizzbuzz_to()` contains `=n`, which causes it to include the upper bound." msgstr "" +"* В `main` мы ссылаемся на функцию, которая определена ниже. При этом ни предварительные объявления, ни заголовки не требуются.\n" +"* В объявлении функции за каждым параметром следует его тип (противоположно некоторым языкам программирования), затем тип возвращаемого значения.\n" +"* Последнее выражение в теле функции (или любом блоке) становится возвращаемым значением. Просто отбросьте символ `;` в конце выражения.\n" +"* Некоторые функции не имеют возвращаемого значения и возвращают ‘тип unit’, `()`. Компилятор определит это, если возвращаемый тип `-> ()` не указан.\n" +"* Выражение диапазона в цикле `for` в `fizzbuzz_to()` содержит `=n`, что ведет к включению верхней границы диапазона." #: src/basic-syntax/rustdoc.md:1 msgid "# Rustdoc" @@ -2812,7 +3126,7 @@ msgstr "" #: src/basic-syntax/rustdoc.md:3 msgid "All language items in Rust can be documented using special `///` syntax." -msgstr "" +msgstr "Все языковые элементы в Rust могут быть задокументированы с использованием особого синтаксиса `///`." #: src/basic-syntax/rustdoc.md:5 msgid "" @@ -2828,6 +3142,17 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"/// Определяет, делится ли первый аргумент на второй.\n" +"///\n" +"/// Если второй аргумент равен нулю, то результат равен false.\n" +"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n" +" if rhs == 0 {\n" +" return false; // Особый случай, досрочное возвращение\n" +" }\n" +" lhs % rhs == 0 // Последнее выражение в блоке - это возвращаемое значение\n" +"}\n" +"```" #: src/basic-syntax/rustdoc.md:17 msgid "" @@ -2836,6 +3161,10 @@ msgid "" "[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is\n" "idiomatic to document all public items in an API using this pattern." msgstr "" +"Содержимое интерпретируется как Markdown. Все опубликованные крейты\n" +"библиотек Rust автоматически документируются на [`docs.rs`](https://docs.rs)\n" +"с помощью инструмента [rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html).\n" +"Документирование всех общедоступных элементов API используя этот подход является идиоматичным." #: src/basic-syntax/rustdoc.md:24 msgid "" @@ -2848,16 +3177,23 @@ msgid "" "* Inner doc comments are discussed later (in the page on modules) and need not\n" " be addressed here." msgstr "" +"* Покажите стедентам сгенерированную документацию для крейта `rand` в [`docs.rs/rand`](https://docs.rs/rand) .\n" +"\n" +"* Этот курс не включает rustdoc на слайдах, просто для экономии места, но в реальном коде они должны присутствовать.\n" +"\n" +"* Inner doc комментарии будут рассмотрены позже (на странице о модулях)." #: src/basic-syntax/methods.md:1 src/methods.md:1 msgid "# Methods" -msgstr "" +msgstr "# Методы" #: src/basic-syntax/methods.md:3 msgid "" "Methods are functions associated with a type. The `self` argument of a method is\n" "an instance of the type it is associated with:" msgstr "" +"Методы это функции, связанные с типом.\n" +"Аргумент `self` в методе --- это экземпляр типа, с которым он связан:" #: src/basic-syntax/methods.md:6 msgid "" @@ -2885,10 +3221,33 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"struct Rectangle {\n" +" width: u32,\n" +" height: u32,\n" +"}\n" +"\n" +"impl Rectangle {\n" +" fn area(&self) -> u32 {\n" +" self.width * self.height\n" +" }\n" +"\n" +" fn inc_width(&mut self, delta: u32) {\n" +" self.width += delta;\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" let mut rect = Rectangle { width: 10, height: 5 };\n" +" println!(\"старая площадь: {}\", rect.area());\n" +" rect.inc_width(5);\n" +" println!(\"новая площадь: {}\", rect.area());\n" +"}\n" +"```" #: src/basic-syntax/methods.md:30 msgid "* We will look much more at methods in today's exercise and in tomorrow's class." -msgstr "" +msgstr "* Мы подробнее рассмотрим методы в сегодняшнем упражнении и на завтрашнем занятии." #: src/basic-syntax/methods.md:34 msgid "" @@ -2903,14 +3262,24 @@ msgid "" "- Add a `Rectangle::new_square(width: u32)` constructor to illustrate that\n" " constructors can take arbitrary parameters." msgstr "" +"- Добавьте конструктор `Rectangle::new` и вызовите его из `main`:\n" +"\n" +" ```rust,editable,compile_fail\n" +" fn new(width: u32, height: u32) -> Rectangle {\n" +" Rectangle { width, height }\n" +" }\n" +" ```\n" +"\n" +"- Добавьте конструктор `Rectangle::new_square(width: u32)`,\n" +"чтобы показать, что конструкторы могут принимать произвольные параметры." #: src/basic-syntax/functions-interlude.md:1 msgid "# Function Overloading" -msgstr "" +msgstr "# Перегрузка функций" #: src/basic-syntax/functions-interlude.md:3 msgid "Overloading is not supported:" -msgstr "" +msgstr "Перегрузка не поддерживается:" #: src/basic-syntax/functions-interlude.md:5 msgid "" @@ -2921,10 +3290,16 @@ msgid "" " * All call sites have the same number of arguments.\n" " * Macros are sometimes used as an alternative." msgstr "" +"* Каждая функция имеет единственную реализацию:\n" +" * Всегда принимает фиксированное количество параметров.\n" +" * Всегда принимает один набор типов параметров.\n" +"* Значения по умолчанию не поддерживаются:\n" +" * Все вызовы имеют одинаковое количество аргументов.\n" +" * В качестве альтернативы иногда используются макросы." #: src/basic-syntax/functions-interlude.md:12 msgid "However, function parameters can be generic:" -msgstr "" +msgstr "Однако параметры функции могут быть обобщенными:" #: src/basic-syntax/functions-interlude.md:14 msgid "" @@ -2939,20 +3314,33 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn pick_one(a: T, b: T) -> T {\n" +" if std::process::id() % 2 == 0 { a } else { b }\n" +"}\n" +"\n" +"fn main() {\n" +" println!(\"подбрасывание монеты: {}\", pick_one(\"орел\", \"решка\"));\n" +" println!(\"денежный приз: {}\", pick_one(500, 1000));\n" +"}\n" +"```" #: src/basic-syntax/functions-interlude.md:27 msgid "" "* When using generics, the standard library's `Into` can provide a kind of limited\n" " polymorphism on argument types. We will see more details in a later section." msgstr "" +"* При использовании обобщений тип `Into` из стандартной библиотеки может\n" +"обеспечить своего рода ограниченный полиморфизм в отношении типов аргументов.\n" +"Мы увидим более подробную информацию в следующих разделах." #: src/exercises/day-1/morning.md:1 msgid "# Day 1: Morning Exercises" -msgstr "" +msgstr "# День 1: Утренние упражнения" #: src/exercises/day-1/morning.md:3 msgid "In these exercises, we will explore two parts of Rust:" -msgstr "" +msgstr "В этих упражнениях мы рассмотрим две составляющие Rust:" #: src/exercises/day-1/morning.md:5 msgid "" @@ -2960,10 +3348,13 @@ msgid "" "\n" "* Arrays and `for` loops." msgstr "" +"* Неявные преобразования между типами.\n" +"\n" +"* Массивы и циклы `for`." #: src/exercises/day-1/morning.md:11 msgid "A few things to consider while solving the exercises:" -msgstr "" +msgstr "Несколько вещей, которые следует учитывать при выполнении упражнений:" #: src/exercises/day-1/morning.md:13 msgid "" @@ -2973,12 +3364,19 @@ msgid "" "\n" "* Alternatively, use the Rust Playground." msgstr "" +"* Используйте локальную установку Rust, если это возможно. Таким образом вы\n" +"можете получить автодополнение в вашем редакторе. Смотрите страницу\n" +"[Using Cargo] для получения подробной информации об установке Rust.\n" +"\n" +"* В качестве альтернативы используйте Rust Playground." #: src/exercises/day-1/morning.md:19 msgid "" "The code snippets are not editable on purpose: the inline code snippets lose\n" "their state if you navigate away from the page." msgstr "" +"Фрагменты кода намеренно недоступны для редактирования:\n" +"встроенные фрагменты кода теряют свое состояние, если вы уходите со страницы." #: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11 #: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7 @@ -2987,17 +3385,19 @@ msgstr "" #: src/exercises/concurrency/morning.md:12 #: src/exercises/concurrency/afternoon.md:13 msgid "After looking at the exercises, you can look at the [solutions] provided." -msgstr "" +msgstr "Ознакомившись с упражнениями, вы можете изучить предоставленные [solutions]." #: src/exercises/day-1/implicit-conversions.md:1 msgid "# Implicit Conversions" -msgstr "" +msgstr "# Неявные преобразования" #: src/exercises/day-1/implicit-conversions.md:3 msgid "" "Rust will not automatically apply _implicit conversions_ between types ([unlike\n" "C++][3]). You can see this in a program like this:" msgstr "" +"Rust не применяет автоматически _неявные преобразования_ между типами ([в отличие от C++][3]).\n" +"Это можно увидеть в следующей программе:" #: src/exercises/day-1/implicit-conversions.md:6 msgid "" @@ -3023,6 +3423,10 @@ msgid "" "Implementing these traits is how a type expresses that it can be converted into\n" "another type." msgstr "" +"Все целочисленные типы в Rust реализуют типажи [`From`][1] и [`Into`][2],\n" +"что позволяет выполнять преобразования между ними. Типаж `From` имеет\n" +"единственный метод `from()` и аналогично, типаж `Into` имеет единственный метод `into()`.\n" +"Реализация этих типажей --- это то, как тип выражает, что он может быть преобразован в другой тип." #: src/exercises/day-1/implicit-conversions.md:25 msgid "" @@ -3031,12 +3435,19 @@ msgid "" "`i16::from(x)`. Or, simpler, with `x.into()`, because `From for i16`\n" "implementation automatically create an implementation of `Into for i8`." msgstr "" +"В стандартной библиотеке есть реализация `From для i16`, что значит,\n" +"что мы можем преобразовать переменную `x` типа `i8` в `i16`, вызвав\n" +"`i16::from(x)`. Или, проще, с помощью `x.into()`, потому что реализация `From для i16`\n" +"автоматически создает реализацию `Into для i8`." #: src/exercises/day-1/implicit-conversions.md:30 msgid "" "The same applies for your own `From` implementations for your own types, so it is\n" "sufficient to only implement `From` to get a respective `Into` implementation automatically." msgstr "" +"То же самое относится к реализациям `From` для ваших\n" +"собственных типов, поэтому достаточно реализовать только `From`,\n" +"чтобы автоматически получить соответствующую реализацию `Into`." #: src/exercises/day-1/implicit-conversions.md:33 msgid "" @@ -3050,14 +3461,23 @@ msgid "" " [standard library documentation][1] to see if `From` is implemented for\n" " the pairs you check." msgstr "" +"1. Запустите приведенную выше программу и посмотрите на ошибку компилятора.\n" +"\n" +"2. Измените приведенный выше код, чтобы использовать `into()` для выполнения преобразования.\n" +"\n" +"3. Измените типы `x` и `y` на другие (такие как `f32`, `bool`, `i128`),\n" +"чтобы увидеть, из каких и в какие типы можно выполнить преобразование.\n" +"Попробуйте преобразовать малые типы в большие и наоборот.\n" +"Ознакомьтесь c [документацией стандартной библиотеки][1], чтобы узнать, реализован ли\n" +"`From` для проверяемых пар." #: src/exercises/day-1/for-loops.md:1 msgid "# Arrays and `for` Loops" -msgstr "" +msgstr "# Массивы и циклы `for`" #: src/exercises/day-1/for-loops.md:3 msgid "We saw that an array can be declared like this:" -msgstr "" +msgstr "Мы видели, что массив может быть объявлен следующим образом:" #: src/exercises/day-1/for-loops.md:5 msgid "" @@ -3068,7 +3488,7 @@ msgstr "" #: src/exercises/day-1/for-loops.md:9 msgid "You can print such an array by asking for its debug representation with `{:?}`:" -msgstr "" +msgstr "Вы можете распечатать массив, запросив его отладочное представление используя `{:?}`:" #: src/exercises/day-1/for-loops.md:11 msgid "" @@ -3079,12 +3499,18 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let array = [10, 20, 30];\n" +" println!(\"массив: {array:?}\");\n" +"}\n" +"```" #: src/exercises/day-1/for-loops.md:18 msgid "" "Rust lets you iterate over things like arrays and ranges using the `for`\n" "keyword:" -msgstr "" +msgstr "Rust позволяет итерироваться по массивам и диапазонам используя ключевое слово `for`:" #: src/exercises/day-1/for-loops.md:21 msgid "" @@ -3105,12 +3531,31 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let array = [10, 20, 30];\n" +" print!(\"Итерация по массиву:\");\n" +" for n in array {\n" +" print!(\" {n}\");\n" +" }\n" +" println!();\n" +"\n" +" print!(\"Итерация по диапазону:\");\n" +" for i in 0..3 {\n" +" print!(\" {}\", array[i]);\n" +" }\n" +" println!();\n" +"}\n" +"```" #: src/exercises/day-1/for-loops.md:38 msgid "" "Use the above to write a function `pretty_print` which pretty-print a matrix and\n" "a function `transpose` which will transpose a matrix (turn rows into columns):" msgstr "" +"Используя приведенное выше, напишите функцию `pretty_print`, которая\n" +"красиво печатает матрицу и функцию `transpose`, которая транспонирует матрицу\n" +"(превращает строки в столбцы):" #: src/exercises/day-1/for-loops.md:41 msgid "" @@ -3123,13 +3568,13 @@ msgstr "" #: src/exercises/day-1/for-loops.md:47 msgid "Hard-code both functions to operate on 3 × 3 matrices." -msgstr "" +msgstr "Запрограммируйте обе функции так, чтобы они работали с матрицами размером 3 × 3." #: src/exercises/day-1/for-loops.md:49 msgid "" "Copy the code below to and implement the\n" "functions:" -msgstr "" +msgstr "Скопируйте приведенный ниже код в и реализуйте функции:" #: src/exercises/day-1/for-loops.md:52 msgid "" @@ -3161,10 +3606,37 @@ msgid "" "}\n" "```" msgstr "" +"```rust,should_panic\n" +"// TODO: удалите это, когда закончите со своей реализацией.\n" +"#![allow(unused_variables, dead_code)]\n" +"\n" +"fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n" +" unimplemented!()\n" +"}\n" +"\n" +"fn pretty_print(matrix: &[[i32; 3]; 3]) {\n" +" unimplemented!()\n" +"}\n" +"\n" +"fn main() {\n" +" let matrix = [\n" +" [101, 102, 103], // <-- комментарий заставляет rustfmt добавить переход на новую строку\n" +" [201, 202, 203],\n" +" [301, 302, 303],\n" +" ];\n" +"\n" +" println!(\"матрица:\");\n" +" pretty_print(&matrix);\n" +"\n" +" let transposed = transpose(matrix);\n" +" println!(\"транспонированная матрица:\");\n" +" pretty_print(&transposed);\n" +"}\n" +"```" #: src/exercises/day-1/for-loops.md:80 msgid "## Bonus Question" -msgstr "" +msgstr "## Бонусный вопрос" #: src/exercises/day-1/for-loops.md:82 msgid "" @@ -3172,18 +3644,23 @@ msgid "" "argument and return types? Something like `&[&[i32]]` for a two-dimensional\n" "slice-of-slices. Why or why not?" msgstr "" +"Могли бы вы использовать срезы `&[i32]`, вместо жестко закодированных\n" +"матриц 3 × 3, как тип аргументов и возвращаемых значений?\n" +"Что-то вроде `&[&[i32]]` для двумерного среза срезов. Почему или почему нет?" #: src/exercises/day-1/for-loops.md:87 msgid "" "See the [`ndarray` crate](https://docs.rs/ndarray/) for a production quality\n" "implementation." -msgstr "" +msgstr "Смотрите [пакет `ndarray`](https://docs.rs/ndarray/), чтобы узнать больше о реализации многомерных контейнеров." #: src/exercises/day-1/for-loops.md:92 msgid "" "The solution and the answer to the bonus section are available in the \n" "[Solution](solutions-morning.md#arrays-and-for-loops) section." msgstr "" +"Решение и ответ на бонусный вопрос доступны в разделе\n" +"[Решение](solutions-morning.md#arrays-and-for-loops)." #: src/basic-syntax/variables.md:1 msgid "# Variables"