YaoXiang（爻象）设计宣言

版本：v2.0.0 状态：正式发布作者：晨煦 + YaoXiang 社区日期：2026-05-31

«Дао порождает одно, одно порождает два, два порождает три, три порождает все сущее.» — «Дао Дэ Цзин»
Типы подобны Дао, всё сущее рождается из них.

一、为何 создан YaoXiang？

1.1 Заполняемый пробел в языках

В долгой истории языков программирования мы стали свидетелями рождения и эволюции множества прекрасных языков: C принёс революцию эффективности системного программирования, Python создал доступный всем опыт обучения программированию, Rust доказал, что безопасность памяти и производительность совместимы, TypeScript сделал масштабные фронтенд-проекты поддерживаемыми. Однако, оглядываясь на современный языковой ландшафт, мы обнаруживаем явный разрыв — ни один язык не способен одновременно удовлетворить следующим трём ключевым потребностям:

Потребность	Проблемы существующих решений
Типовая безопасность	Rust слишком строг, крутая кривая обучения; TypeScript с опциональными типами, не обеспечивает гарантий компиляции
Естественный синтаксис	Rust со сложным непонятным синтаксисом; Haskell слишком высокий порог входа в функциональное программирование; традиционные статические языки многословны
Дружественность к ИИ	Существующие языки имеют синтаксические неоднозначности, сложные AST, непредсказуемое скрытое поведение — точность генерации и модификации кода ИИ ограничена

Создание YaoXiang призвано заполнить этот пробел. Мы верим: язык программирования должен быть одновременно мощным и доступным, безопасным и эффективным, строгим и элегантным.

1.2 Решаемые практические проблемы

Проблема первая: фрагментация системы типов

Современные языки программирования демонстрируют серьёзную фрагментацию в системах типов. Статически типизированные языки стремятся к абсолютной корректности времени компиляции, но часто за счёт снижения эффективности разработки; динамически типизированные языки обеспечивают гибкость, однако в крупных проектах обнаруживают непреодолимые недостатки в поддержке. YaoXiang предлагает единую абстракцию «всё есть тип», делая тип центральной сквозной концепцией языка, а не запоздалым дополнением.

Проблема вторая: выбор между безопасностью памяти и производительностью

Долгое время разработчикам приходилось делать сложный выбор между безопасностью памяти и производительностью выполнения. Сборщик мусора (GC) освобождает разработчика, но приносит задержки и накладные расходы памяти; ручное управление памятью эффективно, но подобно хождению по канату. YaoXiang использует модель владения в стиле Rust, устраняя гонки данных и утечки памяти на этапе компиляции, сохраняя零成本抽象 без необходимости в GC для высокой производительности.

Проблема третья: когнитивная нагрузка асинхронного программирования

Современные приложения неотделимы от сетевых технологий и параллелизма, а асинхронное программирование始终 является кошмаром для программистов. Вложенные коллбэки, цепочки Promise, синтаксис async/await — каждый подход увеличивает сложность кода. YaoXiang заново проектирует асинхронную модель:只需在函数签名后添加 spawn 标记, компилятор автоматически обрабатывает все асинхронные детали, делая параллельное программирование таким же естественным, как синхронный код.

Проблема четвёртая: узкое место AI-assisted программирования

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

1.3 Философские корни языка

Имя YaoXiang происходит от «яо» и «сян» в «Ицзин». «Яо» — основные символы, составляющие гексаграммы, символизирующие изменения инь и ян, движение и покой; «сян» — внешнее проявление сущности вещей, представляющее все явления и всё сущее.

Эта философия отражена в каждой детали дизайна языка:

Единство: подобно тому, как простые символы яо образуют сложные гексаграммы, YaoXiang использует несколько ключевых концепций (типы, функции, конструкторы) для построения полноценной编程模型
Иерархичность: подобно разделению сян на врождённое и приобретённое, система типов YaoXiang имеет чёткую иерархическую структуру, от примитивных типов до обобщённых, от значений до метатипов
Изменчивость: подобно течению инь и ян и бесконечным изменениям, YaoXiang поддерживает зависимые типы, позволяя типам развиваться вместе со значениями
Распознаваемость: подобно тому, как гексаграммы поддаются расшифровке, YaoXiang обеспечивает полную рефлексию типов, информация о типах времени выполнения полностью доступна
Доказуемость: подобно тому, как гексаграммы раскрывают закономерности вещей, система типов YaoXiang следует изоморфизму Карри-Говарда (типы — это утверждения, программы — это доказательства), процесс проверки типов является верификацией логического доказательства

二、Основные философия и принципы

Следующие принципы проектирования составляют фундамент YaoXiang, не подлежат компромиссам и нарушениям. Каждое предложение特性必须经过这些原则的检验。

2.1 Принцип первый: всё есть тип

В мировоззрении YaoXiang тип является высочайшим абстрактным элементом, сквозной核心概念。

Конкретные проявления:

Значения являются экземплярами типа: 42 — экземпляр типа Int, "hello" — экземпляр типа String
Типы сами являются типами: Type — единственный ключевой слово метатипа в языке, тип Int — это Type
Функции являются типами отображений: add: (a: Int, b: Int) -> Int описывает отображение типа Int × Int в Int
Модули являются комбинациями типов: модуль — это комбинация именованного пространства имён, содержащая функции и типы

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

2.2 Принцип второй: строгая структурированность

Синтаксический дизайн YaoXiang追求«без неоднозначностей, предсказуемость, лёгкость解析».

Конкретные правила:

Обязательные 4 пробела отступа: использование символов Tab запрещено, границы блоков кода一目了然
Скобки нельзя опускать: параметры функций必须用括号, элементы списков必须用逗号
Блоки кода должны быть в фигурных скобках: управляющие конструкции if, while, for и другие должны быть обёрнуты в { }
Минимальное количество ключевых слов: только 17 основных ключевых слов, никакого размножения синтаксического сахара

Непреклонная причина: строгая структурированность обеспечивает три ключевых преимущества — (1) более точная подсветка синтаксиса и сворачивание кода в IDE; (2) значительное повышение точности генерации и модификации кода ИИ; (3) новички могут быстро понять структуру кода.

2.3 Принцип третий:零成本抽象

Высокоуровневые абстракции не должны создавать накладных расходов времени выполнения.

Конкретные гарантии:

Специализация: обобщённые функции展开为 конкретные версии во время компиляции, без накладных расходов виртуальной таблицы
Встраивание: простые функции автоматически встраиваются, устраняя накладные расходы вызовов
Приоритет分配 на стеке: small objects default to stack allocation, heap allocation only when necessary
Без GC: модель владения обеспечивает безопасность памяти без накладных расходов runtime сборщика мусора

Непреклонная причина: производительность — это линия выживания языка программирования. Любой дизайн, жертвующий производительностью ради удобства, является предательством программистов.

2.4 Принцип четвёртый: по умолчанию неизменяемость

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

Конкретные правила:

Переменные по умолчанию неизменяемы, после присваивания修改不可
При необходимости изменчивости необходимо явно объявить mut
Ссылки по умолчанию неизменяемы, изменяемые ссылки требуют маркера mut
Передача владения означает, что原绑定失效

Непреклонная причина: неизменяемость — основа безопасности параллелизма, гарантия читаемости кода, воплощение мудрости функционального программирования.

2.5 Принцип пятый: типы как данные

Информация о типах不应仅存在于编译期, а должна быть полностью доступна во время выполнения.

Конкретные возможности:

Запрос типов времени выполнения: любое значение может получить свою тип信息
Рефлексия типов: можно создавать и манипулировать самими типами
Деконструкция через сопоставление с образцом: конструкторы типов можно непосредственно использовать для сопоставления с образцом
Специализация обобщённых типов: во время выполнения можно получить конкретизированные типы обобщённых параметров

Непреклонная причина: полная рефлексия типов — основа метапрограммирования, фундамент высокопроизводительных фреймворков и инструментов.

三、Ключевые инновации и特性

Поглощая优秀特性 существующих языков, YaoXiang同时提出以下 инновационные проектирования。

3.1 Инновация первая: унифицированный тип syntax

Традиционные языки часто require multiple keywords for type definitions:

rust

// Rust
struct Point { x: f64, y: f64 }
enum Result<T, E> { Ok(T), Err(E) }
enum Color { Red, Green, Blue }
trait Drawable { fn draw(&self, s: &Surface); }

Единый синтаксис YaoXiang: всё есть name: type = value, Type — единственный ключевой слово метатипа.

yaoxiang

# === Записи ===

Point: Type = {
    x: Float,
    y: Float,
}

# С полями по умолчанию
Point3D: Type = {
    x: Float = 0,
    y: Float = 0,
    z: Float = 0,
}

# === Обобщённые типы ===

Option: (T: Type) -> Type = {
    some: (T) -> Self,
    none: () -> Self,
}

Result: (T: Type, E: Type) -> Type = {
    ok: (T) -> Self,
    err: (E) -> Self,
}

# === Интерфейсы (записи, все поля которых являются функциональными типами) ===

Drawable: Type = {
    draw: (Surface) -> Void,
    bounding_box: () -> Rect,
}

Serializable: Type = {
    serialize: () -> String,
}

# === Реализация интерфейсов (имя интерфейса записывается в теле типа) ===

Point: Type = {
    x: Float,
    y: Float,
    Drawable,
    Serializable,
}

# === Методы (синтаксис Type.method) ===

Point.draw: (self: &Point, surface: Surface) -> Void = {
    surface.plot(self.x, self.y)
}

Инновационная ценность: без фрагментации ключевых слов fn, struct, enum, trait, impl — единый синтаксис охватывает все объявления.

3.2 Инновация вторая: конструкторы как типы

Конструирование значений完全相同 вызовам функций:

yaoxiang

# Определение типа
Point: Type = { x: Float, y: Float }
Option: (T: Type) -> Type = {
    some: (T) -> Self,
    none: () -> Self,
}

# Конструирование значений: идентично вызовам функций
p: Point = Point(3.0, 4.0)
opt: Option(Int) = Option.some(42)
none: Option(Int) = Option.none()

# Сопоставление с образцом: прямая деконструкция
match opt {
    Option.some(value) -> print(value)
    Option.none -> print("nothing")
}

3.3 Инновация третья: каррированное связывание методов

YaoXiang использует чистый функциональный дизайн, достигая синтаксического сахара, подобного вызовам методов объектов, через каррирование, без введения ключевых слов class и method.

yaoxiang

# === Определение типа ===

Point: Type = {
    x: Float,
    y: Float,
}

# Основная функция: евклидово расстояние
distance: (a: Point, b: Point) -> Float = {
    dx = a.x - b.x
    dy = a.y - b.y
    return (dx * dx + dy * dy).sqrt()
}

# Связывание синтаксиса метода ([0] означает绑定到第0个参数位置)
Point.distance = distance[0]

# === Использование ===

p1 = Point(3.0, 4.0)
p2 = Point(1.0, 2.0)

# Оба способа вызова полностью эквивалентны
d1 = distance(p1, p2)     # Прямой вызов основной функции
d2 = p1.distance(p2)      # Синтаксический сахар метода

# Каррированное использование
dist_from_p1 = p1.distance  # Частичное применение, ожидание второго параметра
d3 = dist_from_p1(p2)       # 2.828

Инновационная ценность: чистый функциональный дизайн, без скрытого параметра self, функции как значения可以自由传递 и комбинировать.

3.4 Инновация четвёртая: модель спавна (spawn)

«Все сущее действует совместно, и я наблюдаю возвращения.» — «И. Цзин. Гексаграмма 复»
Модель спавна заимствует этот смысл, описывая парадигму программирования: разработчик описывает логику синхронным, последовательным мышлением, а среда выполнения языка автоматически, эффективно выполняет вычислительные единицы параллельно, как все существа действуют совместно, и в итоге统一协同。

Три основных принципа:

Принцип	Описание
Синхронный синтаксис	Код, который вы видите, таков, как он есть, последовательный
Параллельная сущность	Runtime автоматически извлекает параллелизм
Единая координация	Результаты自动汇聚 в нужный момент, обеспечивая логическую корректность

Терминология:

Официальный термин	Соответствующий синтаксис	Объяснение
Спавн-функция	`spawn (params) => body`	Определение вычислительной единицы, участвующей в спавне
Спавн-блок	`spawn { a(), b() }`	Явно объявленная параллельная область, задачи внутри блока выполняются параллельно
Спавн-цикл	`spawn for x in xs { ... }`	Параллелизм данных, тело цикла спавнится на всех элементах
Спавн-значение	`Async(T)`	Значение-будущее в процессе спавна, автоматически ожидается при использовании
Спавн-граф	Ленивый вычислительный граф (DAG)	Сцена, где происходит спавн, описывает зависимости и параллельные отношения
Спавн-планировщик	Runtime планировщик задач	Координирует всё сущее, позволяя им спавниться в нужный момент как разумный центр

Подробнее: RFC-001 Модель спавна

yaoxiang

# === Спавн-функция ===
# Функция с маркером spawn
fetch_data: (url: String) -> JSON spawn = {
    return HTTP.get(url).json()
}

# === Спавн-блок ===
# Выражения внутри spawn { } обязательно выполняются параллельно
compute_all: () -> (Int, Int, Int) spawn = {
    (a, b, c) = spawn {
        heavy_calc(1),    # Задача 1
        heavy_calc(2),    # Задача 2
        another_calc(3)   # Задача 3
    }
    return (a, b, c)
}

# === Автоматическое ожидание ===
main: () -> Void = {
    # Два независимых запроса автоматически выполняются параллельно
    users = fetch_data("https://api.example.com/users")
    posts = fetch_data("https://api.example.com/posts")

    # Точка ожидания автоматически вставляется при необходимости результата
    print(users.length + posts.length)  # Автоматическое ожидание users и posts
}

Безопасность потоков:

yaoxiang

# Ключевое слово ref автоматически обрабатывает безопасность потоков (компилятор автоматически выбирает Rc/Arc)
main: () -> Void = {
    counter = ref SafeCounter(0)

    # Межзадачный shared: компилятор автоматически выбирает Arc
    spawn {
        counter.increment()
    }
    spawn {
        counter.increment()
    }
}

Техническая документация:

Подробнее RFC-001 Модель спавна

Инновационная ценность: когнитивная нагрузка асинхронного программирования снижается до нуля, читаемость кода完全相同 синхронному коду,同时获得高性能 параллельное выполнение。

3.5 Инновация пятая: типы, зависящие от значений (RFC-011)

Статус: в разработке, частичная реализация

Типы могут зависеть от значений,实现真正的类型驱动开发。

yaoxiang

# Тип матрицы: размерности определяются во время компиляции
Matrix: (T: Type, Rows: Int, Cols: Int) -> Type = {
    data: Array(Array(T, Cols), Rows),
}

# Вычисление во время компиляции: factorial(3) = 6
vec: Vec(factorial(3)) = Vec(6)()

# Проверка размерностей во время компиляции
identity_3x3: Matrix(Float, 3, 3) = identity(Float, 3)(3)
# multiply(matrix_2x3, matrix_4x2)  # Ошибка компиляции: несоответствие размерностей

Инновационная ценность:捕获更多 ошибок во время компиляции, реализация более точных гарантий типов.

3.6 Инновация шестая: минималистичный дизайн ключевых слов

YaoXiang определяет только 17 основных ключевых слов, что значительно меньше, чем у主流ных языков:

pub    use    spawn
ref    mut    if     else
else   match  while  for    return
break  continue as     in     unsafe

Сравнение языков	Количество ключевых слов
YaoXiang	17
Rust	51+
Python	35
TypeScript	64+
Go	25

Инновационная ценность:更低记忆负担, более согласованный синтаксис,更容易解析语法结构。

四、Предварительный обзор синтаксиса

Следующие примеры кода демонстрируют стиль языка YaoXiang,帮助您快速感受其设计美学。

4.1 Hello World

yaoxiang

# hello.yx

main: () -> Void = {
    print("Hello, YaoXiang!")
}

4.2 Определения типов и функции

yaoxiang

# Унифицированный синтаксис типов: name: type = value

# Запись
Point: Type = { x: Float, y: Float }

# Обобщённый тип
Option: (T: Type) -> Type = {
    some: (T) -> Self,
    none: () -> Self,
}

# Интерфейсный тип (запись, все поля которой являются функциями)
Serializable: Type = {
    serialize: () -> String,
}

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

# Обобщённая функция
identity: (T: Type) -> ((x: T) -> T) = x

# Многострочная функция
fact: (n: Int) -> Int = {
    if n == 0 { return 1 }
    return n * fact(n - 1)
}

4.3 Сопоставление с образцом

yaoxiang

# Сопоставление с образцом
classify: (n: Int) -> String = {
    return match n {
        0 -> "zero",
        1 -> "one",
        _ if n < 0 -> "negative",
        _ -> "positive",
    }
}

# Деконструкция
Point: Type = { x: Float, y: Float }
match point {
    Point(0.0, 0.0) -> "origin",
    Point(x, y) -> "point at (${x}, ${y})",
}

4.4 Модель владения (RFC-009 v9)

yaoxiang

Point: Type = { x: Float, y: Float }

# По умолчанию Move (нуль-копирование)
p1 = Point(1.0, 2.0)
p2 = p1              # Move, p1 больше недоступен

# &T / &mut T токены (нуль-стоимость во время компиляции)
p2.print()           # Компилятор автоматически создаёт токен &Point
p2.shift(1.0, 1.0)  # Компилятор автоматически создаёт токен &mut Point

# ref: совместное владение (компилятор автоматически выбирает Rc/Arc)
shared = ref p2      # Совместное использование через границы областей видимости

# clone(): явное глубокое копирование
backup = p2.clone()

# unsafe + сырые указатели: системный уровень
unsafe {
    ptr: *Point = &p2
    (*ptr).x = 0.0
}

Градиент владения:

&T / &mut T    Move       ref        clone()    unsafe
    |             |          |           |          |
Токены        По        Совместное   Глубокое   Сырые
заимствования умолчанию владение     копирование указатели
Нуль-стоимость Нуль-копирование Rc/Arc      Явное     Системный
               автоматически                     уровень

4.5 Обработка ошибок

yaoxiang

# Тип Result
Result: (T: Type, E: Type) -> Type = {
    ok: (T) -> Self,
    err: (E) -> Self,
}

divide: (a: Float, b: Float) -> Result(Float, String) = {
    if b == 0.0 {
        return Result.err("Division by zero")
    }
    return Result.ok(a / b)
}

# Использование match для обработки
result = divide(10.0, 2.0)
match result {
    Result.ok(value) -> print(value),
    Result.err(msg) -> print("Error: ${msg}"),
}

4.6 Параллельное программирование (модель спавна)

yaoxiang

# Функция async с маркером spawn
fetch_api: (url: String) -> JSON spawn = {
    response = HTTP.get(url)
    return JSON.parse(response.body)
}

# Блок параллельной конструкции: явный параллелизм
process_all: () -> (JSON, JSON, JSON) spawn = {
    (a, b, c) = spawn {
        fetch_api("https://api1.com/data"),
        fetch_api("https://api2.com/data"),
        fetch_api("https://api3.com/data")
    }
    return (a, b, c)
}

五、Дорожная карта и открытые вопросы

5.1 Принятые проектные решения

Следующие решения经过充分讨论 и审查, не подлежат изменению:

Модуль	Решение	Пояснение
Система типов	Всё есть тип	Значения, функции, модули, обобщения — всё является типами
Синтаксис типов	Унифицированный `name: type = value`	Одна форма объявления охватывает все случаи, `Type` — единственный ключевой слово метатипа
Ключевые слова	17 основных ключевых слов	Без `type`/`fn`/`struct`/`enum`/`trait`/`impl`
Синтаксис функций	Сигнатура + выражение	`name: (params) -> ReturnType = body`
Связывание методов	RFC-004 каррированное связывание	`Type.method = function[position]`
Асинхронная модель	Модель спавна	Маркер `spawn`, ленивое вычисление, автоматический параллелизм
Управление памятью	Модель владения (RFC-009 v9)	Move + токены &T/&mut T + ref + clone + unsafe, без GC
Файл как модуль	Система модулей	Каждый файл `.yx` является модулем
Главная функция	`main: () -> Void`	Точка входа программы
Безопасность потоков	ref автоматически выбирает Rc/Arc	Анализ побега компилятором, невидим для пользователя

5.3 Дорожная карта реализации

┌─────────────────────────────────────────────────────────────────────────────┐
│                          YaoXiang Дорожная карта реализации (пример)              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  v0.1: Rust интерпретатор ───────→ v0.5: Rust компилятор ───────→ v1.0: Rust AOT  │
│        ✅ Выполнено                   │ (текущий этап)            компилятор    │
│                                       │                                         │
│                                       ▼                                         │
│  v0.6: YaoXiang интерпретатор ←────── v1.0: YaoXiang JIT компилятор ←──── v2.0: │
│        (самоперенос)                  (самоперенос)                    YaoXiang AOT │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

六、Как участвовать в разработке

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

6.1 Дискуссии по дизайну

Для кого: исследователи теории языков программирования, любители систем типов, энтузиасты дизайна языков

Как участвовать:

GitHub Discussions: участвуйте в обсуждениях категории «Language Design»
Проектные предложения (RFC): предлагайте дизайн-документы для новых特性, следуя шаблону в каталоге rfcs/
Обзор синтаксиса: предлагайте улучшения для существующего синтаксиса или находите потенциальные проблемы

Подача проектных предложений:

Создайте новый файл в каталоге rfcs/
Заполните шаблон RFC (мотивация, детальный дизайн, анализ преимуществ и недостатков, альтернативные решения)
Создайте Pull Request для рецензирования сообществом
После рассмотрения核心团队 решение о合并 или отклонении

6.2 Реализация компилятора

Для кого: разработчики компиляторов, системные программисты, эксперты по оптимизации производительности

Текущие приоритеты реализации (по приоритету):

Приоритет	Модуль	Пояснение	Сложность
P0	Байткод-виртуальная машина	Улучшение VM инструкций, оптимизация производительности	Средняя
P0	Память runtime	Реализация GC, аллокатор памяти	Высокая
P0	Асинхронный runtime	Полная реализация модели спавна	Высокая
P1	Стандартная библиотека	IO, String, List, Concurrent	Средняя
P1	JIT компилятор	Интеграция Cranelift	Высокая
P2	AOT компилятор	LLVM/ Cranelift backend	Высокая
P3	Самопереносной компилятор	Перепись на YaoXiang	Крайне высокая

Технологический стек:

Язык реализации: Rust (текущий этап)
Генерация кода: Cranelift или LLVM
Инструмент сборки: Cargo
Фреймворк тестирования: Rust #[test] + cargo nextest

Начало работы:

Изучите docs/YaoXiang-implementation-plan.md для понимания архитектуры
Выберите интересующий модуль в каталоге src/
Изучите tests/unit/ для понимания требований к тестированию
Перед отправкой кода убедитесь, что cargo fmt и cargo clippy проходят

6.3 Разработка инструментария

Для кого: разработчики плагинов IDE, любители инструментов, ценители эффективности

Инструменты, требующие разработки:

Инструмент	Статус	Пояснение
LSP сервер	⏳ Ожидает	Поддержка Language Server Protocol
Интеграция отладчика	⏳ Ожидает	Интеграция GDB/LLDB
Форматтер	⏳ Ожидает	`yaoxiang fmt`
Менеджер пакетов	⏳ Ожидает	Управление зависимостями, разрешение версий
Репозиторий пакетов	⏳ Ожидает	Центральный или децентрализованный
REPL	⏳ Ожидает	Интерактивный интерпретатор
Инструмент бенчмаркинга	⏳ Ожидает	Профилирование производительности
VS Code плагин	⏳ Ожидает	Подсветка синтаксиса, автодополнение, отладка
Vim/Neovim плагин	⏳ Ожидает	Подсветка синтаксиса, LSP клиент

Структура проекта:

yaoxiang/
├── src/
│   ├── tools/                    # Инструментарий
│   │   ├── lsp/                  # LSP сервер
│   │   ├── fmt/                  # Форматтер
│   │   ├── repl/                 # REPL
│   │   └── benchmark/            # Бенчмаркинг
│   └── ...
├── extensions/                   # Расширения редактора
│   ├── vscode/                   # VS Code
│   └── vim/                      # Vim/Neovim

6.4 Развитие стандартной библиотеки

Для кого: разработчики библиотек, дизайнеры API, domain experts

Планирование модулей стандартной библиотеки:

Модуль	Приоритет	Пояснение
`std.io`	P0	Файловый IO, консольный ввод-вывод
`std.string`	P0	Операции со строками, форматирование
`std.list`	P0	Операции со списками/массивами
`std.dict`	P0	Словари/хеш-таблицы
`std.math`	P0	Математические функции, константы
`std.time`	P1	Операции с датой и временем
`std.net`	P1	Сетевое программирование, HTTP
`std.concurrent`	P1	Параллельные примитивы, каналы
`std.crypto`	P2	Криптографические хеши, подписи
`std.json`	P1	Парсинг/генерация JSON
`std.regex`	P2	Регулярные выражения
`std.database`	P3	Подключение к базам данных
`std.gui`	P3	Графический интерфейс (долгосрочная перспектива)

Принципы дизайна:

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

6.5 Документация и учебные материалы

Для кого: технические писатели, педагоги, менеджеры сообщества

Документация, требующая contributions:

Документ	Статус	Пояснение
Быстрый старт	✅ Выполнено	Руководство по началу работы за 5 минут
Языковое руководство	✅ Выполнено	Систематическое изучение核心ных концепций
Языковая спецификация	✅ Выполнено	Полное определение синтаксиса и семантики
План реализации	✅ Выполнено	Технические детали реализации компилятора
API документация	⏳ Ожидает	Справочник по API стандартной библиотеки
Учебники	⏳ Ожидает	Продвинутые учебники и лучшие практики
Блог	⏳ Ожидает	Технические статьи и истории дизайна
Перевод	⏳ Ожидает	Поддержка нескольких языков

6.6 Развитие сообщества

Для кого: менеджеры сообщества, организаторы мероприятий, евангелисты

Мероприятия сообщества:

Регулярные онлайн встречи (раз в месяц)
Дискуссии по дизайну и реализации (раз в неделю)
Спринты по написанию кода (раз в квартал)
Офлайн встречи и доклады на конференциях

Каналы распространения:

GitHub Discussions: технические дискуссии
GitHub Issues: отчёты об ошибках и запросы функций
Discord/Slack: общение в реальном времени
Twitter/X: новости проекта
Блог: углублённые статьи

6.7 Руководство по участию

Как начать вносить вклад:

Изучите проект: прочитайте README и документацию по дизайну
Выберите направление: выберите область для вклада по интересам
Настройте окружение: Rust 1.75+, cargo, git
Найдите задачи: посмотрите метку good first issue в GitHub Issues
Отправьте PR: следуйте соглашениям по коммитам, напишите тесты
Участвуйте в рецензировании: review чужой код, участвуйте в дискуссиях

Соглашения по коммитам:

bash

# Формат сообщения коммита
<type>(<scope>): <subject>

# Типы
feat: новая функциональность
fix: исправление ошибки
docs: обновление документации
style: форматирование кода (без влияния на функциональность)
refactor: рефакторинг
perf: оптимизация производительности
test: тесты
chore: инструменты сборки или вспомогательные инструменты

# Примеры
feat(typecheck): add generic type inference
fix(parser): fix infinite loop on invalid input
docs(readme): update installation instructions

Стиль кода:

Следуйте соглашениям rustfmt.toml
Убедитесь, что cargo clippy не выдаёт предупреждений
Пишите необходимые модульные тесты
Обновляйте соответствующую документацию

Приложение A: Шпаргалка по языку

A.1 Ключевые слова

Ключевое слово	Назначение
`pub`	Публичный экспорт
`use`	Импорт модуля
`spawn`	Маркер спавна
`ref`	Совместное владение (компилятор自动но выбирает Rc/Arc)
`mut`	Изменяемая переменная
`if/else if/else`	Условные ветвления
`match`	Сопоставление с образцом
`while/for`	Циклы
`return/break/continue`	Управление потоком
`as`	Преобразование типов
`in`	Проверка членства / списковое включение
`unsafe`	Блок unsafe кода (сырые указатели)

Примечание: Type, true, false, void и др. являются зарезервированными словами, bukan ключевыми словами. Ключевое слово type уже удалено в RFC-010, используется统一的 синтаксис name: Type = value.

A.3 Примитивные типы

Тип	Описание	Размер по умолчанию
`Void`	Пустое значение	0 байт
`Bool`	Логическое значение	1 байт
`Int`	Знаковое целое	8 байт
`Uint`	Беззнаковое целое	8 байт
`Float`	Число с плавающей запятой	8 байт
`String`	UTF-8 строка	Переменный
`Char`	Символ Unicode	4 байта
`Bytes`	Сырые байты	Переменный

A.4 Приоритет операторов

Приоритет	Оператор	Ассоциативность
1	`()` `[]` `.`	Слева направо
2	`as`	Слева направо
3	`*` `/` `%`	Слева направо
4	`+` `-`	Слева направо
5	`<<` `>>`	Слева направо
6	`&` `\|` `^`	Слева направо
7	`==` `!=` `<` `>` `<=` `>=`	Слева направо
8	`not`	Справа налево
9	`and` `or`	Слева направо
10	`if...else`	Справа налево
11	`=` `+=` `-=` `*=` `/=`	Справа налево

Приложение B: Источники вдохновения

Дизайн YaoXiang вдохновлён优秀 идеями следующих языков и проектов:

Источник	Заимствованные аспекты
Rust	Модель владения, нуль-стоимостные абстракции, система типов
Python	Стиль синтаксиса, читаемость, списковые включения
Idris/Agda	Зависимые типы, типово-ориентированная разработка
Изоморфизм Карри-Говарда	Типы как утверждения, программы как доказательства, единая теория типов и логики
TypeScript	Типовые аннотации, типы времени выполнения
MoonBit	Дизайн для дружественности к ИИ, лаконичный синтаксис
Haskell	Чистое функциональное программирование, сопоставление с образцом
OCaml	Вывод типов, вариантные типы

Приложение C: Часто задаваемые вопросы

Q: Какие преимущества у YaoXiang по сравнению с Rust?

A: YaoXiang сохраняет безопасность памяти и нуль-стоимостные абстракции Rust, но использует более простой синтаксис и меньшую когнитивную нагрузку. Модель спавна проще, чем async/await Rust —只需 один маркер spawn,无需手动 управлять Future и Pin. «Все сущее действует совместно», параллельное программирование так же интуитивно, как описание законов природы. Модель владения (RFC-009 v9) использует Move + токены &T/&mut T вместо аннотаций времени жизни, использует типовые атрибуты (Dup/Linear) вместоborrow checker. Унифицированный тип syntax устраняет концептуальную фрагментацию enum/struct/trait/impl.

Q: Для чего подходит YaoXiang?

A: Системное программирование, разработка приложений, веб-сервисы, скрипты, AI-assisted программирование. Цель — стать универсальным языком программирования.

Q: Почему выбран 4-пробельный отступ?

A: 4 пробела обеспечивают чёткое визуальное разделение блоков кода, уменьшают путаницу от вложенности. Это тщательно продуманное проектное решение «дружественности к ИИ».

Q: Когда будет выпущена версия 1.0?

A: Цель v1.0: production-ready. Дата выпуска зависит от прогресса реализации, подробнее в RFC планирования версий.

Q: Как связаться с核心团队?

A: Через GitHub Discussions или канал сообщества Discord. Члены核心团队 регулярно отвечают.

Последнее обновление：2026-05-31
Версия документа：v2.0.0
Лицензия：MIT

«Изменения яо и сян порождают все сущее. Эволюция типов создаёт программы.»
Пусть путешествие дизайна YaoXiang будет с вами.

YaoXiang（爻象）设计宣言 ​

一、为何 создан YaoXiang？ ​

1.1 Заполняемый пробел в языках ​

1.2 Решаемые практические проблемы ​

1.3 Философские корни языка ​

二、Основные философия и принципы ​

2.1 Принцип первый: всё есть тип ​

2.2 Принцип второй: строгая структурированность ​

2.3 Принцип третий:零成本抽象 ​

2.4 Принцип четвёртый: по умолчанию неизменяемость ​

2.5 Принцип пятый: типы как данные ​

三、Ключевые инновации и特性 ​

3.1 Инновация первая: унифицированный тип syntax ​

3.2 Инновация вторая: конструкторы как типы ​

3.3 Инновация третья: каррированное связывание методов ​

3.4 Инновация четвёртая: модель спавна (spawn) ​

3.5 Инновация пятая: типы, зависящие от значений (RFC-011) ​

3.6 Инновация шестая: минималистичный дизайн ключевых слов ​

四、Предварительный обзор синтаксиса ​

4.1 Hello World ​

4.2 Определения типов и функции ​

4.3 Сопоставление с образцом ​

4.4 Модель владения (RFC-009 v9) ​

4.5 Обработка ошибок ​

4.6 Параллельное программирование (модель спавна) ​

五、Дорожная карта и открытые вопросы ​

5.1 Принятые проектные решения ​

5.3 Дорожная карта реализации ​

六、Как участвовать в разработке ​

6.1 Дискуссии по дизайну ​

6.2 Реализация компилятора ​

6.3 Разработка инструментария ​

6.4 Развитие стандартной библиотеки ​

6.5 Документация и учебные материалы ​

6.6 Развитие сообщества ​

6.7 Руководство по участию ​

Приложение A: Шпаргалка по языку ​

A.1 Ключевые слова ​

A.3 Примитивные типы ​

A.4 Приоритет операторов ​

Приложение B: Источники вдохновения ​

Приложение C: Часто задаваемые вопросы ​

YaoXiang（爻象）设计宣言

一、为何 создан YaoXiang？

1.1 Заполняемый пробел в языках

1.2 Решаемые практические проблемы

1.3 Философские корни языка

二、Основные философия и принципы

2.1 Принцип первый: всё есть тип

2.2 Принцип второй: строгая структурированность

2.3 Принцип третий:零成本抽象

2.4 Принцип четвёртый: по умолчанию неизменяемость

2.5 Принцип пятый: типы как данные

三、Ключевые инновации и特性

3.1 Инновация первая: унифицированный тип syntax

3.2 Инновация вторая: конструкторы как типы

3.3 Инновация третья: каррированное связывание методов

3.4 Инновация четвёртая: модель спавна (spawn)

3.5 Инновация пятая: типы, зависящие от значений (RFC-011)

3.6 Инновация шестая: минималистичный дизайн ключевых слов

四、Предварительный обзор синтаксиса

4.1 Hello World

4.2 Определения типов и функции

4.3 Сопоставление с образцом

4.4 Модель владения (RFC-009 v9)

4.5 Обработка ошибок

4.6 Параллельное программирование (модель спавна)

五、Дорожная карта и открытые вопросы

5.1 Принятые проектные решения

5.3 Дорожная карта реализации

六、Как участвовать в разработке

6.1 Дискуссии по дизайну

6.2 Реализация компилятора

6.3 Разработка инструментария

6.4 Развитие стандартной библиотеки

6.5 Документация и учебные материалы

6.6 Развитие сообщества

6.7 Руководство по участию

Приложение A: Шпаргалка по языку

A.1 Ключевые слова

A.3 Примитивные типы

A.4 Приоритет операторов

Приложение B: Источники вдохновения

Приложение C: Часто задаваемые вопросы