On branch main, some spell checking with aspell

modified:   src/ch01.md
modified:   src/ch02.md
modified:   src/ch03.md
modified:   src/ch04.md

src/ch01.md

@@ -395,7 +395,7 @@ const b = a[1..end];
 Изучение Zig приучает к мысли, что типы весьма содержательны. Это не просто целое,
 логическое или даже массив целых. Типы также содержат другую важную информацию.
 Мы уже говорили о том, что длина массива является составляющей частью типа.
-Многие примеры показывают, что неизменямость (constness) также является составляющей типа.
+Многие примеры показывают, что неизменяемость (constness) также является составляющей типа.
 Например, в нашем последнем примере тип `b` это `[]const i32`. Вы можете сами
 это наглядно увидеть при помощи вот такой программы:
 
@@ -565,7 +565,7 @@ Zig делает приведение типов (coercion) автоматиче
 
 Конечно, в "настоящих" программах большинство строк/массивов неизвестны
 во время компиляции - данные могут поступать от пользователя, из сети и т.п.
-К этому вопросу мы ещё вернёмся, когда будем рассматривать работу
+К этому вопросу мы ещё вернёмся когда будем рассматривать работу
 с оперативной памятью. А сейчас мы пока скажем следующее - для
 такого рода данных, которые возникают лишь в процессе работы программы,
 память выделяется динамически. При этом наши переменные всё равно будут

src/ch02.md

@@ -10,7 +10,7 @@
 
 Операторы управления потоком исполнения в Zig, безусловно, покажутся Вам знакомыми,
 однако, имеется ряд моментов, касающихся их взаимодействия с некоторыми
-другими аспектами языка, которые нам пока лишь предстоить изучить.
+другими аспектами языка, которые нам пока лишь предстоит изучить.
 Мы начнём с краткого обзора и будем возвращаться по мере того,
 как нам будут встречаться особенности в поведении инструкций управления. 
 
@@ -181,7 +181,7 @@ fn indexOf(haystack: []const u32, needle: u32) ?usize {
 Подробнее про такие типы см. ниже, в соответствующем разделе этой главы.
 
 Также обратите внимание на то, что правый конец интервала не написан,
-он будет автоматически определён исходя из фактической длины аргументв `haystack`.
+он будет автоматически определён исходя из фактической длины аргумента `haystack`.
 Впрочем, ничто не мешает написать явно, то есть `0..hastack.len`.
 
 Циклы `for` не поддерживают более общую идиому вида `(init; compare; next)`.
@@ -253,7 +253,7 @@ const personality_analysis = blk: {
 Блоки подобного рода нужно оканчивать точкой с запятой.
 
 Позже, когда мы будем изучать маркированные объединения,
-объединения-ошибки и типы с необязательным значением,
+объединения с ошибками и типы с необязательным значением,
 мы узнаем, какие ещё возможности предоставляют управляющие структуры.
 
 ## Перечисления (enums)
@@ -293,7 +293,7 @@ const Stage = enum {
 
 Вспомним, что при использовании записи вида `.{...}` типы структур
 выводятся исходя из типа переменной, которой присваивается анонимная
-структурв или из типа возвращаемого значения функции. В примере
+структура или из типа возвращаемого значения функции. В примере
 выше мы видим, что при сравнениях тип перечисления тоже выводится,
 исходя из типа параметра (`Stage`). Можно написать явно, то есть
 `return self == Stage.confirmed or self == Stage.err;`, но, как правило,
@@ -311,7 +311,7 @@ const Stage = enum {
 
 Объединение задаёт набор типов, которые может иметь переменная.
 Например, экземпляры следующего объединения могут быть или
-целыми числами, или числами с плавабщей точкой, или быть "не-числом" (Nan):
+целыми числами, или числами с плавающей точкой, или быть "не-числом" (NaN):
 
 ```zig
 const std = @import("std");
@@ -565,7 +565,7 @@ pub fn main() !void {
 На самом деле оба подхода (с явным указанием всего и без такового) не вполне
 эквивалентны. Например, ссылки на функции с неявным набором ошибок требуют
 специального типа, `anyerror`. Разработчики библиотек, возможно, предпочитают
-быть более явными, так код становиится самодокументирующимся. Так или иначе,
+быть более явными, так код становится самодокументирующимся. Так или иначе,
 оба подхода имеют право на существование и Вы можете использовать оба
 по своему усмотрению.
 
@@ -590,7 +590,7 @@ action(req, res) catch |err| {
 };
 ```
 
-Более идиоматичной явлется версия с оператором `switch`:
+Более идиоматичным является вариант с оператором `switch`:
 
 ```zig
 action(req, res) catch |err| switch (err) {

src/ch03.md

@@ -92,7 +92,7 @@ fn read(stream: std.net.Stream) ![]const u8 {
 вольны использовать такие соглашения об именах, какие Вам больше
 нравятся. Однако, совершенно не вредно понимать собственные
 соглашения Zig, поскольку стандартная библиотека, которой Вы,
-безуловно, будете пользоваться, придерживается этих соглашений.
+безусловно, будете пользоваться, придерживается этих соглашений.
 
 Отступы в Zig - это 4 пробела. Как правило, текстовые редакторы
 можно настроить так, чтобы клавиша `Tab` вставляла именно 4 пробела,

src/ch04.md

@@ -13,11 +13,11 @@
 выделением/освобождением памяти, понимаете, что такое
 "висячий" указатель (dangling pointer), тогда Вы можете
 пропустить пару глав и перейти к главе 6, там есть
-некотрые особенности, специфичные для Zig.
+некоторые особенности, специфичные для Zig.
 
-В следующем примере создаётся пользователь с идентифиактором 1
+В следующем примере создаётся пользователь с идентификатором 1
 и "силой" 100, а затем вызывается функция, которая увеличивает
-силу пользователя на единицу. Можете угадать, что выведет этв программа?
+силу пользователя на единицу. Можете угадать, что выведет эта программа?
 
 ```zig
 const std = @import("std");
@@ -97,10 +97,10 @@ user -> ------------ (id)
 осмысленным образом.
 
 По умолчанию Zig не гарантирует какое-то конкретное расположение полей
-структуры в памтяти - он может расположить их в алфавитном порядке,
+структуры в памяти - он может расположить их в алфавитном порядке,
 в порядке увеличения размера, при этом, возможно, с пустыми промежутками.
 Он может делать всё что угодно, при условии, что он сгенерирует правильный
-машинный код. Такая свободв позволяет осуществлять некоторые оптимизации.
+машинный код. Такая свобода позволяет осуществлять некоторые оптимизации.
 Мы можем получить строгие гарантии расположения только если объявим
 так называемую упакованную структуру (`packed struct`). Тем не менее,
 наша визуализация переменной `user` вполне разумна и полезна.
@@ -266,7 +266,7 @@ $ /opt/zig-0.11/zig run src/ex-ch04-06.zig
 
 До этого мы всё время оформляли нашу `levelUp` как "саму по себе".
 Но более чем вероятно, что в реальном коде эта функция будет
-оформлена как метод струутуры, то есть;
+оформлена как метод структуры, то есть;
 
 ```zig
 pub const User = struct {