Объявление переменных

В этой главе рассматривается основной синтаксис объявления переменных в YaoXiang. Если у вас есть опыт работы с другими языками программирования, вы обнаружите, что система переменных в YaoXiang очень лаконична — все объявления используют единую синтаксическую модель.

Единая синтаксическая модель

Философия проектирования YaoXiang — «всё едино». Будь то объявление целого числа, определение функции или создание типа — всё использует один и тот же синтаксис:

name: type = value

Это ключевая идея дизайна YaoXiang. Несколько примеров передают эту последовательность:

// Объявление переменной
x: Int = 42
name: String = "YaoXiang"

// Определение функции
add: (a: Int, b: Int) -> Int = a + b

// Определение типа
Point: Type = { x: Float, y: Float }

Формальное определение объявления переменной в спецификации синтаксиса:

('mut')? Identifier (':' TypeExpr)? '=' Expr

Простыми словами: может быть необязательное ключевое слово mut, затем имя переменной, затем необязательное : тип, и наконец = значение. Эта структура пронизывает весь язык — достаточно выучить её один раз.

Неизменяемые переменные (поведение по умолчанию)

В YaoXiang все переменные по умолчанию неизменяемы. После присвоения значение изменить нельзя. Это решение для обеспечения безопасности языка.

x = 10
// x = 20   // Ошибка компиляции! x является неизменяемой

Для переменных, объявленных с помощью =, компилятор будет искать переменную с тем же именем по цепочке областей видимости наружу. Если найдёт — попытается присвоить значение; если не найдёт — создаст новую неизменяемую переменную в текущей области видимости.

x = 1       // Во внешней области нет x, поэтому объявляется новая переменная
x = 2       // Найден внешний x, попытка присвоения → Ошибка компиляции! x неизменяема

Это может показаться контринтуитивным — если вы изучали другие языки, можете подумать: «Раз нашёл, почему нельзя присвоить?». Это потому, что YaoXiang ставит безопасность на первое место: неизменяемость по умолчанию означает, что вам не нужно беспокоиться о случайном изменении переменной где-нибудь в коде.

mut — изменяемые переменные

Когда вам действительно нужно изменить переменную, явно объявите её с помощью ключевого слова mut:

mut counter = 0
counter = counter + 1   // Можно изменить
counter = 100           // Тоже можно

У mut есть несколько важных правил:

Правило первое: mut — это явное новое объявление, компилятор не ищет переменную с тем же именем во внешней области видимости.

mut x = 10      // В текущей области видимости создаётся новая изменяемая переменная x
mut x = 20      // Ошибка компиляции! В той же области видимости x уже объявлена

Правило второе: переменная, объявленная через mut, не может иметь то же имя, что и переменная во внешней области видимости (запрет на затенение).

x = 10
{
    mut x = 20   // Ошибка компиляции! x уже объявлена во внешней области, затенение запрещено
}

Правило третье: в одной области видимости каждое имя может быть объявлено только один раз — независимо от того, используется = или mut.

x = 10
mut x = 20   // Ошибка компиляции! x уже объявлена

Эти правила гарантируют уникальность каждого имени переменной в текущей области видимости, и вам никогда не придётся гадать, на какую именно одноимённую переменную указывает ссылка.

Вывод типов vs явные аннотации типов

YaoXiang использует алгоритм вывода типов Хиндли-Милнера (HM). Компилятор может автоматически вывести тип из записанного вами значения, и в большинстве случаев указывать тип вручную не требуется.

x = 42              // Компилятор выводит Int
name = "YaoXiang"   // Выводится String
pi = 3.14159        // Выводится Float
is_valid = true     // Выводится Bool

Когда вы хотите явно указать тип (например, для повышения читаемости кода или когда компилятор не может вывести тип), используйте синтаксис : Type:

count: Int = 100
greeting: String = "Hello"
ratio: Float = 0.618

Обе записи полностью эквивалентны. Можно начать писать код без указания типов и добавлять аннотации при необходимости. Это делает быстрое прототипирование очень удобным, не жертвуя типобезопасностью итогового кода.

Обзор базовых типов

YaoXiang имеет несколько встроенных базовых типов, покрывающих подавляющее большинство повседневных задач программирования.

Int (целое число)

a = 42              // Десятичное
b = 0o52            // Восьмеричное (префикс 0o)
c = 0x2A            // Шестнадцатеричное (префикс 0x)
d = 0b101010        // Двоичное (префикс 0b)
e = 1_000_000       // Можно разделять цифры подчёркиванием для удобства чтения

Float (число с плавающей точкой)

pi = 3.14159
speed = 2.998e8         // Научная нотация: 2.998 × 10^8
tiny = 1.6e-19

String (строка)

name = "YaoXiang"
empty = ""              // Пустая строка
escape = "Hello\nWorld" // Поддержка экранирования: \n перевод строки, \t табуляция, \\ обратный слэш, \" двойная кавычка
unicode = "\u{4F60}\u{597D}"  // Unicode-экранирование

Bool (логический тип)

is_ready = true
is_done = false

Логические значения обычно используются в условных конструкциях:

if is_ready {
    print("Начинаем обработку")
}

Область видимости переменных

Область видимости определяет диапазон доступности переменной. Правила областей видимости в YaoXiang очень просты: каждый блок {} создаёт новую область видимости.

Основные правила

{
    x = 10
    print(x)   // Доступно: x находится в текущей области видимости
}
// print(x)    // Ошибка: x не виден за пределами области видимости

Внутренняя область имеет доступ к переменным внешней:

outer = "Я снаружи"
{
    print(outer)   // Доступ к внешней переменной outer
    inner = "Я внутри"
}
// print(inner)    // Ошибка: inner не виден за пределами области видимости

Область видимости параметров функции

greet: (name: String) -> Void = {
    print("Привет, " + name)
    // name виден внутри тела этой функции
}
// name не виден за пределами функции

Блочные выражения

Блок {} в YaoXiang также является выражением и может возвращать значение:

result = {
    x = 10
    y = 20
    return x + y   // Возвращает 30 во внешнюю область
}
// Значение result равно 30
// x и y не видны за пределами блока

Подробное описание возврата значений из блоков приведено в последующей главе о функциях. Здесь нужно запомнить только одно: фигурные скобки создают область видимости, внутренняя видит внешнюю, внешняя не видит внутреннюю.

Резюме

Вы освоили основные концепции системы переменных YaoXiang:

Концепция	Ключевые моменты
Единая синтаксическая модель	name: type = value — используется для переменных, функций и типов
Неизменяемость по умолчанию	После x = 10 значение x нельзя изменить
Изменяемые переменные	Явно объявляются через mut: mut x = 10
Запрет затенения	В одной области видимости имя может быть объявлено только один раз
Вывод типов	Алгоритм HM выводит автоматически, также можно указать : Type явно
Область видимости	Каждый {} создаёт область видимости: внутренняя видит внешнюю, внешняя не видит внутреннюю

Далее вы можете продолжить изучение подробностей о базовых типах или сразу перейти к главе об управлении потоком выполнения.