Манифест проектирования YaoXiang（爻象）

Версия: v2.0.0 Статус: Официальный релиз Автор: Чэньсюй + сообщество YaoXiang Дата: 2026-05-31

«Дао рождает единое, единое рождает двое, двое рождает трое, трое рождает десять тысяч вещей.» — «Дао Дэ Цзин»
Типы — это Дао, из которого рождается всё сущее.

I. Зачем создавать YaoXiang?

1.1 Заполнение языкового пробела

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

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

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

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

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

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

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

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

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

Современные приложения немыслимы без сети и параллелизма, а асинхронное программирование всегда было кошмаром программистов. Вложенные функции обратного вызова, цепочки Promise, синтаксис async/await — каждое решение увеличивает сложность кода. YaoXiang переработал модель асинхронности: достаточно добавить метку spawn после сигнатуры функции, и компилятор автоматически обработает все асинхронные детали, делая параллельное программирование таким же естественным, как синхронный код.

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

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

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

Название YaoXiang происходит от «爻» (Yao) и «象» (Xiang) из «И Цзин» (Книга Перемен). «爻» — это базовые символы, составляющие гексаграммы, символизирующие изменения инь и ян, взаимное рождение движения и покоя; «象» — это внешнее проявление сущности вещей, представляющее все явления и охватывающее все сущее.

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

Единство (统一性): подобно тому, как простые символы триграмм образуют сложные гексаграммы, YaoXiang использует несколько ключевых концепций (типы, функции, конструкторы) для построения полной модели программирования
Иерархичность (层次性): подобно тому, как образы делятся на врождённые и приобретённые, система типов YaoXiang имеет чёткую иерархическую структуру — от примитивных типов к дженерикам, от значений к метатипам
Изменчивость (变化性): подобно непрерывному чередованию инь и ян, бесконечному разнообразию изменений, YaoXiang поддерживает зависимые типы, позволяя типам эволюционировать в зависимости от значений
Распознаваемость (可识别性): подобно тому, как гексаграммы можно интерпретировать, а все вещи можно представить, YaoXiang предоставляет полные возможности рефлексии типов, информация о типах полностью доступна во время выполнения
Доказуемость (可证明性): подобно тому, как гексаграммы раскрывают законы вещей, система типов YaoXiang следует изоморфизму Карри-Ховарда (типы — это утверждения, программы — это доказательства), процесс проверки типов является верификацией логического доказательства

II. Ключевая философия и принципы

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

2.1 Принцип первый: всё есть тип (一切皆类型)

В мировоззрении YaoXiang тип является абстракцией высшего уровня, центральной концепцией, пронизывающей язык.

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

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

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

2.2 Принцип второй: строгая структурированность (严格结构化)

Синтаксис YaoXiang стремится к «однозначности, предсказуемости и лёгкости разбора».

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

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

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

2.3 Принцип третий: абстракции с нулевой стоимостью (零成本抽象)

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

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

Мономорфизация (单态化): дженерик-функции разворачиваются в конкретные версии на этапе компиляции, без накладных расходов на поиск в виртуальной таблице
Встраивание (内联优化): простые функции автоматически встраиваются, устраняя накладные расходы на вызов функций
Приоритет стекового размещения: мелкие объекты по умолчанию размещаются в стеке, куча используется только при необходимости
Отсутствие GC: модель владения гарантирует безопасность памяти без накладных расходов сборщика мусора во время выполнения

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

2.4 Принцип четвёртый: неизменяемость по умолчанию (默认不可变)

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

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

Переменные по умолчанию неизменяемы, после присваивания их нельзя изменять
При необходимости изменяемости требуется явное объявление mut
Ссылки по умолчанию неизменяемы, изменяемые ссылки требуют метки mut
Передача владения означает, что исходная привязка становится недействительной

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

2.5 Принцип пятый: типы — это данные (类型即数据)

Информация о типах не должна существовать только на этапе компиляции, она должна быть полностью доступна во время выполнения.

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

Запрос типа во время выполнения: для любого значения можно получить информацию о его типе
Рефлексия типов: можно конструировать и манипулировать самими типами
Деконструкция через сопоставление с образцом: конструкторы типов могут непосредственно использоваться в pattern matching
Специализация дженериков: во время выполнения можно получить реализованные типы параметров дженериков

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

III. Ключевые инновации и возможности

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

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

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

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: всё есть имя: тип = значение, Type — единственное ключевое слово метатипа.

yaoxiang

# === Запись (record type) ===

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()

# Pattern matching: непосредственная деконструкция
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 (params) => body`	Определяет вычислительную единицу, которая может участвовать в 并作-исполнении
并作-блок (并作块)	`spawn { a(), b() }`	Явно объявленная область параллелизма, задачи внутри блока выполняются 并作
并作-цикл (并作循环)	`spawn for x in xs { ... }`	Параллелизм по данным, тело цикла 并作-исполняется на всех элементах
并作-значение (并作值)	`Async(T)`	Будущее значение, находящееся в процессе 并作, автоматически ожидается при использовании
并作-граф (并作图)	Граф ленивых вычислений (DAG)	Сцена, где происходит 并作, описывающая зависимости и параллелизм
并作-планировщик (并作调度器)	Планировщик задач среды выполнения	Интеллектуальный центр, координирующий «десять тысяч вещей» для 并作-исполнения в правильный момент

Подробнее: 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)

    # Совместное использование между задачами: компилятор автоматически выбирает 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
arr: Array(Int, factorial(3)) = Array(Int, 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

Ценность инновации: меньшая нагрузка на запоминание, более последовательный стиль синтаксиса, более простая для разбора синтаксическая структура.

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

Следующие примеры кода демонстрируют языковой стиль YaoXiang и помогают быстро ощутить его дизайнерскую эстетику.

4.1 Hello World

yaoxiang

# hello.yx

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

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

yaoxiang

# Унифицированный синтаксис типов: имя: тип = значение

# Запись (record type)
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

# Pattern matching
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

# 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)
}

V. Дорожная карта и открытые вопросы

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

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

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

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

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

VI. Как участвовать в贡献

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

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

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

Способы участия:

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

Подача предложения по дизайну:

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

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

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

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

Приоритет	Модуль	Описание	Сложность
P0	Байткодовая виртуальная машина	Улучшение инструкций VM, оптимизация производительности	Средняя
P0	Среда выполнения памяти	Реализация GC, аллокатор памяти	Высокая
P0	Асинхронная среда выполнения	Полная реализация модели 并作	Высокая
P1	Стандартная библиотека	IO, String, List, Concurrent	Средняя
P1	JIT-компилятор	Интеграция с Cranelift	Высокая
P2	AOT-компилятор	Бэкенд на LLVM/Cranelift	Высокая
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
Форматтер	⏳ Ожидает начала	`yx format`
Менеджер пакетов	⏳ Ожидает начала	Управление зависимостями, разрешение версий
Репозиторий пакетов	⏳ Ожидает начала	Централизованный или децентрализованный
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, отраслевые эксперты

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

Модуль	Приоритет	Описание
`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 Документация и учебные пособия

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

Необходимая документация:

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

6.6 Построение сообщества

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

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

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

Каналы коммуникации:

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

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

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

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

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

bash

# Формат сообщения коммита
<тип>(<область>): <тема>

# Типы
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`	Проверка принадлежности/list comprehension
`unsafe`	Блок unsafe-кода (сырые указатели)

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

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	`&` `\|` `^`	Слева направо
9	`==` `!=` `<` `>` `<=` `>=`	Слева направо
10	`and` `or`	Слева направо
11	`if...else`	Справа налево
12	`=` `+=` `-=` `*=` `/=`	Справа налево

Унарные префиксные операторы (! - +) связываются сильнее всех бинарных операторов (стиль Zig, см. SPEC §2.2).

Приложение B: Вдохновение в дизайне

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

Источник	Что заимствовано
Rust	Модель владения, абстракции с нулевой стоимостью, система типов
Python	Стиль синтаксиса, читаемость, list comprehension
Idris/Agda	Зависимые типы, разработка, управляемая типами
Изоморфизм Карри-Ховарда	Типы — это утверждения, программы — это доказательства, единая теория системы типов и логики
TypeScript	Аннотации типов, типы во время выполнения
MoonBit	AI-дружественный дизайн, лаконичный синтаксис
Haskell	Чистый функциональный подход, pattern matching
OCaml	Вывод типов, вариантные типы

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

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

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

В: Для каких типов разработки подходит YaoXiang?

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

В: Почему выбран отступ в 4 пробела?

О: 4 пробела обеспечивают чёткое визуальное разделение блоков кода, уменьшая путаницу от глубины вложенности. Это тщательно продуманное решение «AI-дружественного» дизайна.

В: Когда выйдет версия 1.0?

О: Цель v1.0: готовность к продакшену. Сроки выпуска зависят от хода реализации, подробности см. в RFC о планировании версий.

В: Как связаться с основной командой?

О: Через GitHub Discussions или канал сообщества Discord. Члены основной команды регулярно отвечают.

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

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

Манифест проектирования YaoXiang（爻象） ​

I. Зачем создавать YaoXiang? ​

1.1 Заполнение языкового пробела ​

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

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

II. Ключевая философия и принципы ​

2.1 Принцип первый: всё есть тип (一切皆类型) ​

2.2 Принцип второй: строгая структурированность (严格结构化) ​

2.3 Принцип третий: абстракции с нулевой стоимостью (零成本抽象) ​

2.4 Принцип четвёртый: неизменяемость по умолчанию (默认不可变) ​

2.5 Принцип пятый: типы — это данные (类型即数据) ​

III. Ключевые инновации и возможности ​

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

3.2 Инновация вторая: конструктор — это тип (构造器即类型) ​

3.3 Инновация третья: каррированная привязка методов (柯里化方法绑定) ​

3.4 Инновация четвёртая: модель 并作 (параллельного действия) (并作模型) ​

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

3.6 Инновация шестая: минималистичный дизайн ключевых слов (极简关键字设计) ​

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

4.1 Hello World ​

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

4.3 Сопоставление с образцом (模式匹配) ​

4.4 Модель владения (RFC-009 v9) (所有权模型) ​

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

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

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

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

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

VI. Как участвовать в贡献 ​

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

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

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

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

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

6.6 Построение сообщества ​

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

Приложение A: Краткий справочник по языку ​

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

A.3 Примитивные типы (原类型) ​

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

Приложение B: Вдохновение в дизайне ​

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

Манифест проектирования YaoXiang（爻象）

I. Зачем создавать YaoXiang?

1.1 Заполнение языкового пробела

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

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

II. Ключевая философия и принципы

2.1 Принцип первый: всё есть тип (一切皆类型)

2.2 Принцип второй: строгая структурированность (严格结构化)

2.3 Принцип третий: абстракции с нулевой стоимостью (零成本抽象)

2.4 Принцип четвёртый: неизменяемость по умолчанию (默认不可变)

2.5 Принцип пятый: типы — это данные (类型即数据)

III. Ключевые инновации и возможности

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

3.2 Инновация вторая: конструктор — это тип (构造器即类型)

3.3 Инновация третья: каррированная привязка методов (柯里化方法绑定)

3.4 Инновация четвёртая: модель 并作 (параллельного действия) (并作模型)

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

3.6 Инновация шестая: минималистичный дизайн ключевых слов (极简关键字设计)

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

4.1 Hello World

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

4.3 Сопоставление с образцом (模式匹配)

4.4 Модель владения (RFC-009 v9) (所有权模型)

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

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

V. Дорожная карта и открытые вопросы

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

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

VI. Как участвовать в贡献

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

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

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

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

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

6.6 Построение сообщества

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

Приложение A: Краткий справочник по языку

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

A.3 Примитивные типы (原类型)

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

Приложение B: Вдохновение в дизайне

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