Типы данных Топаз

// Целое число
let возраст: int = 25
let большойСчётчик: int = 9999999999

// Число с плавающей точкой
let цена: float = 19.99
let пи: float = 3.141592653589793

// Вывод типов
let счёт = 95        // выводится как int
let среднее = 87.5   // выводится как float

let активен = true
let естьПраваАдмина = false

// Использование в условиях
if активен {
    print("Сервис активен")
}

// Строка (один символ или более длинный текст)
let оценка: string = "A"
let эмодзи: string = "😀"
let имя = "Иван Топаз"
let длинноеПредложение = "Добро пожаловать в Топаз — один способ сказать!"

// Интерполяция строк
let приветствие = "Привет, {имя}! Хорошая сегодня погода."
print(приветствие)  // "Привет, Иван Топаз! Хорошая сегодня погода."

// Объявление и инициализация массива
let mut числа: Array<int> = [1, 2, 3, 4, 5]
let имена = ["Алиса", "Боб", "Чарли"]  // выводится как Array<string>

// Манипуляции с массивом
let первый = числа[0]           // 1 — прямая индексация даёт фолт вне границ
let безопасно = числа.get(0)    // Some(1) — чтение без фолта, возвращает Option<int>
числа.push(6)                   // [1, 2, 3, 4, 5, 6]
let длина = числа.length        // 6

// Операции в функциональном стиле
let квадраты = map(числа, x => x * x)
let чётные = filter(числа, x => x % 2 == 0)

// Определение записи
let пользователь = {
    имя: "Иван Топаз",
    возраст: 28,
    почта: "ivan@example.com",
    активен: true
}

// Доступ к свойствам
print(пользователь.имя)               // "Иван Топаз"

// Неизменяемое обновление через record literal
let калькулятор = { значение: 0 }
let послеСложения = калькулятор{ значение: калькулятор.значение + 10 }
let послеУмножения = послеСложения{ значение: послеСложения.значение * 2 }

print("{послеУмножения.значение}")        // 20
print("{калькулятор.значение}")           // 0 (исходное значение не меняется)

// Переиспользуемое поведение можно оформить обычными функциями
function добавитьККалькулятору(состояние: { значение: int }, x: int) -> { значение: int } {
    состояние{ значение: состояние.значение + x }
}

function умножитьКалькулятор(состояние: { значение: int }, x: int) -> { значение: int } {
    состояние{ значение: состояние.значение * x }
}

// Тип Option для безопасности от null
let результатПоиска: Option<string> = None
let имяПользователя: Option<string> = Some("admin")

// Безопасная обработка с сопоставлением образцов
match имяПользователя {
    case Some(имя) => print("Добро пожаловать, {имя}!")
    case None => print("Требуется авторизация")
}

// Безопасная обработка с ?. и ?? (строки не предоставляют .length;
// число скаляров считается через s.scalars())
let длинаИмени = имяПользователя?.scalars()?.length ?? 0
let отображение = имяПользователя ?? "guest"

// Тип Result для обработки ошибок
function прочитатьФайл(путь: string) -> Result<string, string> {
    if файлСуществует(путь) {
        Ok(прочитатьСодержимоеФайла(путь))
    } else {
        Err("Файл не найден")
    }
}

// Безопасная обработка ошибок
match прочитатьФайл("data.txt") {
    case Ok(содержимое) => print("Содержимое файла: {содержимое}")
    case Err(сообщениеОшибки) => print("Произошла ошибка: {сообщениеОшибки}")
}

// Тип, который может быть одним из нескольких типов
type ID = int | string
type Статус = "ожидание" | "обработка" | "завершено" | "ошибка"

let идПользователя: ID = 12345
let статусЗадачи: Статус = "обработка"

// Обработка для конкретного типа с сопоставлением образцов
function показатьID(id: ID) -> string {
    match id {
        case числовой: int => "Числовой ID: {числовой}"
        case текстовый: string => "Строковый ID: {текстовый}"
    }
}

let числа: Array<int> = [1, 2, 3]
let имяОпционально: Option<string> = Some("Alice")
let результатПарсинга: Result<Пользователь, string> = разобратьПользователя(rawJson)
let кеш: Map<string, int> = Map.new()

function первыйЭлемент<T>(xs: Array<T>) -> Option<T> {
    match xs {
        case [] => None
        case [первый, ..] => Some(первый)
    }
}

let первый: Option<int> = первыйЭлемент([1, 2, 3])

type Пара<T> = { первый: T, второй: T }
let границы: Пара<int> = { первый: 0, второй: 100 }

// Даём простые имена сложным типам
type ИнфоПользователя = {
    имя: string,
    возраст: int,
    почта: string,
    разрешения: Array<string>
}

type ФункцияОбратногоВызова = (string) -> ()

// Пример использования
let администратор: ИнфоПользователя = {
    имя: "Админ Пользователь",
    возраст: 35,
    почта: "admin@topaz.ooo",
    разрешения: ["чтение", "запись", "удаление"]
}

let строковоеЧисло = "123"

// toInt возвращает Option<int> — обрабатывайте случай None явно
let разобрано = match toInt(строковоеЧисло) {
    case Some(значение) => значение
    case None => 0
}

// Деструктурирование массива
let [первый, второй, ..остальные] = [1, 2, 3, 4, 5]
print("{первый}")       // 1
print("{остальные}")    // [3, 4, 5]

// Деструктурирование объекта
let { имя, возраст } = пользователь
print("Имя: {имя}, Возраст: {возраст}")

// Деструктурирование внутри тела функции
function поприветствовать(пользователь: { имя: string, возраст: int }) {
    let { имя, возраст } = пользователь
    print("Привет, {имя}! Вам {возраст} лет.")
}

// Практические определения типов для реальных проектов
type Пользователь = {
    id: int,
    имя: string,
    почта: string,
    датаСоздания: string
}

type ОтветПользователя = {
    успех: bool,
    данные: Option<Пользователь>,
    ошибка: Option<string>,
    кодСостояния: int
}

// API получения пользователя
function получитьПользователя(id: int) -> ОтветПользователя {
    let ответ = fetch("/api/users/{id}")
    
    if ответ.ok {
        let данныеПользователя = ответ.json()
        return {
            успех: true,
            данные: Some(данныеПользователя),
            ошибка: None,
            кодСостояния: ответ.status
        }
    } else {
        return {
            успех: false,
            данные: None,
            ошибка: Some("Пользователь не найден"),
            кодСостояния: ответ.status
        }
    }
}