Троичный язык программирования T / forpes.ru

Главная
Троичный язык программирования T

Троичный язык программирования T

27.05.2026 21:21

EntityFX 37 14000 Источник

1. Введение

Язык T — низкоуровневый язык системного программирования, аналог языка C для сбалансированной троичной системы счисления. В отличие от двоичных языков, где информация кодируется битами (0 и 1), язык T оперирует тритами — трёхзначными разрядами со значениями –1, 0, +1, которые изображаются символами -, 0, +. Синтаксис языка T близок к C, что делает его доступным для программистов, знакомых с классическим C, но при этом он расширен конструкциями, необходимыми для эффективной работы с троичной логикой и арифметикой.

Язык T двуязычен: все ключевые слова имеют английские и русские варианты. Например, if/если, while/пока, for/для, return/возврат, tint/тцел, sizeof/размер. Это позволяет писать программы как на английском, так и на русском языке без использования макросов.

Полное описание языка T

2. Основные понятия

Трит (trit) — минимальная единица информации в языке T. Принимает три значения: –1 (-), 0 (0), +1 (+). В выражениях трит автоматически повышается до типа tint.

Трайт (tryte) — минимальная адресуемая ячейка памяти, состоящая из 6 тритов. Трайт является аналогом байта в двоичных системах. Диапазон значений трайта: от –364 до +364.

Сбалансированная троичная система — система счисления с основанием 3 и цифрами –1, 0, +1. Её ключевое преимущество перед несбалансированной троичной системой (цифры 0, 1, 2) — естественное представление отрицательных чисел без отдельного знакового разряда. Например, число –5 в сбалансированной троичной системе записывается как -++ (что означает –1·9 + 1·3 + 1·1 = –9 + 3 + 1 = –5), а число +5 — как +-- (1·9 – 1·3 – 1·1 = 9 – 3 – 1 = 5).

3. Система типов

3.1. Целочисленные типы

Все целые типы кратны трайту и используют сбалансированное представление:

Тип	Тритов	Трайтов	Диапазон (сбалансированный)
`tryte`	6	1	–364 … +364
`tshort`	12	2	–265 720 … +265 720
`tint`	18	3	–193 710 244 … +193 710 244
`tlong`	36	6	–7,6·10¹⁶ … +7,6·10¹⁶
`tlong long`	54	9	–2,0·10²⁵ … +2,0·10²⁵

tryte (трайт) — 6 тритов, 1 трайт. Синоним char-подобного типа. Диапазон: –364 … +364.
tshort (ткоротк) — короткое целое, 12 тритов, 2 трайта. Диапазон: –265 720 … +265 720.
tint (тцел) — стандартное целое, 18 тритов, 3 трайта. Диапазон: –193 710 244 … +193 710 244.
tlong (тдлин) — длинное целое, 36 тритов, 6 трайтов. Диапазон: ±7,6·10¹⁶.
tlong long (тдлинлонг) — сверхдлинное целое, 54 трита, 9 трайтов. Диапазон: ±2,0·10²⁵.

Оператор sizeof (размер) возвращает размер типа в трайтах:

sizeof(tryte)   == 1    размер(трайт)   == 1
sizeof(tshort)  == 2    размер(ткоротк) == 2
sizeof(tint)    == 3    размер(тцел)    == 3
sizeof(tlong)   == 6    размер(тдлин)   == 6
sizeof(tdouble) == 6    размер(тдвойн)  == 6

3.2. Вещественные типы

tfloat (твещ) — вещественный тип, 18 тритов (3 трайта). Формат: 6 тритов порядка, 12 тритов мантиссы. Смещение порядка (bias) = 182.
tdouble (тдвойн) — вещественный тип двойной точности, 36 тритов (6 трайтов). Формат: 8 тритов порядка, 28 тритов мантиссы. Смещение порядка (bias) = 3280.

Формат вещественного числа: значение = (скрытый_трит . m₁…mₚ) × 3^(E−bias). Скрытый трит не хранится, мантисса нормализована. Специальные значения: ноль (порядок = 0, мантисса = 0), бесконечность (порядок = макс., мантисса = 0), NaN (порядок = макс., мантисса ≠ 0).

3.3. Логический тип

tril (трил) — логический трит для трёхзначной логики:

true (истина) = +1
maybe (может) = 0
false (ложь) = –1

Логические операторы && (И) и || (ИЛИ) реализуют трёхзначную логику: && — минимум, || — максимум. Оба операнда вычисляются всегда (короткого замыкания нет).

3.4. Трит

trit (трит) — одиночный трит со значениями –1, 0, +1. В выражениях автоматически повышается до tint. Символьные константы '+', '0', '-' имеют тип trit и значения +1, 0, –1 соответственно. Любой другой символ (например, 'A') имеет тип tryte и хранит его код.

4. Литералы

4.1. Десятичные целые литералы

Десятичные литералы требуют обязательного суффикса, определяющего тип:

Суффикс	Тип	Примеры
`y`	`tryte`	`42y`, `-100y`, `0y`
`s`	`tshort`	`1000s`, `-50000s`
`t`	`tint`	`42t`, `-100t`, `0t`
`tl`	`tlong`	`100000tl`, `-5000000tl`
`tll`	`tlong long`	`1000000tll`

4.2. Сбалансированные троичные литералы

Префикс 0t, затем троичные цифры -, 0, +. Допускается символ _ для группировки:

0t+-0_+- — 6 тритов с группировкой
0t+++_+++ — максимальное положительное значение tryte (+364)
0t---_--- — минимальное отрицательное значение tryte (–364)
0t0 — явный троичный ноль

4.3. 27-ричные литералы (tryx)

Префикс 0y, затем цифры, каждая из которых кодирует 3 трита. Алфавит (тройки от --- до +++):

N O P Q R S T U V    (--- … -++)
W X Y Z 0 1 2 3 4    (0-- … 0++)
5 6 7 8 9 A B C D    (+-- … +++)

Допустим нижний регистр. Число цифр = (триты типа) / 3. Примеры:

0yNN — минимальное значение tryte (–364)
0yDD — максимальное значение tryte (+364)
0y000000 — ноль типа tint

Каждая tryx-цифра представляет собой одну из 27 возможных комбинаций трёх тритов. Например, цифра N соответствует --- (все три трита равны –1), цифра D соответствует +++ (все три трита равны +1), цифра 0 соответствует 000 (все три трита равны 0). Таким образом, tryx-запись позволяет компактно представлять троичные числа: для типа tint (18 тритов) требуется всего 6 tryx-цифр вместо 18 троичных цифр.

4.4. 9-ричные литералы (ninary)

Префикс 0n, затем цифры, каждая из которых кодирует 2 трита. Алфавит (старший, младший):

W (--)  X (-0)  Y (-+)  Z (0-)
0 (00)  1 (0+)  2 (+-)  3 (+0)  4 (++)

Число цифр = (триты типа) / 2. Примеры:

0nW04 — последовательность -- 00 ++
0n000 — ноль типа tryte

9-ричная (ninary) запись занимает промежуточное положение между троичной и 27-ричной: каждая цифра кодирует 2 трита, что даёт 9 возможных комбинаций. Для типа tryte (6 тритов) требуется 3 ninary-цифры, для tint (18 тритов) — 9 цифр.

4.5. Вещественные литералы

Десятичная запись: целая и дробная часть через точку, опционально экспонента e. Суффикс f — tfloat, d или без суффикса — tdouble. Примеры: 3.14, -0.001f, 1.0e+2d.

Троичная запись: префикс 0t, мантисса с точкой, e, порядок. Суффикс f или d обязателен. Примеры: 0t+.-0+0e+0f (tfloat), 0t-.0++_---e-+d (tdouble).

5. Управляющие конструкции

5.1. Трёхветвевой if

К традиционным ветвям if и else добавлена опциональная ветвь maybe, которая может следовать в любом порядке относительно else:

if (condition)
    print("истина\n");
maybe
    print("может быть\n");
else
    print("ложь\n");

Если ветвь maybe опущена, то при значении условия maybe управление переходит к следующей после if инструкции.

5.2. Тринарный условный оператор

Тринарный оператор ?? :? :! позволяет выбрать одну из трёх ветвей в зависимости от трёхзначного условия:

условие ?? выраж_истина :? выраж_может :! выраж_ложь

Пример:

tril flag = maybe;
tryte x = (flag == true) ?? 10y :? 0y :! -10y;

Все три выражения вычисляются. Тип результата — общий тип трёх выражений.

5.3. Циклы и переключатели

Циклы while, for, do-while работают как в C, но условие проверяется на равенство true. При maybe или false цикл прерывается. Переключатель switch также аналогичен C, но тип tril не может быть использован непосредственно — его нужно явно преобразовать в целое.

6. Потритовые операторы

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

& — потритовый минимум: каждый трит результата равен минимуму соответствующих тритов операндов. + & 0 = 0, + & - = -, 0 & - = -.
| — потритовый максимум: каждый трит результата равен максимуму. + | 0 = +, + | - = +, 0 | - = 0.
^ — потритовая сумма по модулю 3 без переноса: + ^ + = - (1 + 1 = 2 → –1), - ^ - = + (–1 + –1 = –2 → +1), + ^ 0 = +, + ^ - = 0.
~ — потритовое отрицание: каждый трит меняет знак. ~+ = -, ~- = +, ~0 = 0.

Эти операторы применимы только к целым типам. Сдвиги << и >> выполняют умножение и деление на 3ⁿ соответственно.

7. Преобразования типов

Неявные преобразования:

trit автоматически повышается до tint в выражениях.
В операциях с разными целыми типами меньший тип повышается до большего: tint → tlong → tlong long.
Целые типы преобразуются в вещественные при смешанных операциях: tint → tfloat → tdouble.
tril неявно преобразуется в trit и наоборот.

Явные преобразования (приведение типа):

tfloat f = (tfloat) a;   // tint → tfloat
tint x = (tint) 3.14;    // tdouble → tint (отбрасывание дробной части)

При присваивании более широкого типа узкому значение усекается до нужного количества тритов.

8. Структуры, объединения и тритовые поля

Язык T поддерживает структуры (struct/структура), объединения (union/объединение) и перечисления (enum/перечисление). Структуры могут содержать тритовые поля — аналог битовых полей в C, но упаковка ведётся по тритам, а не по битам. Тритовые поля позволяют эффективно упаковывать данные, когда требуется хранить значения, не кратные трайту.

9. Стандартная библиотека

Стандартная библиотека языка T адаптирована для троичных типов:

<tio.h> — ввод-вывод: tprintf, tscanf, tfopen, tgetc, tputc, printbal, printtryte, printtril, printfloat, printdouble.
<tstring.h> — строковые операции: tstrlen, tstrcpy, tstrcat, tstrcmp, tstrchr.
<tmath.h> — математические функции: tsin, tcos, tsqrt, tabs, tfabs, tmin, tmax, tfloor, tceil.
<tstdlib.h> — общего назначения: tmalloc, tfree, trealloc, tcalloc, texit, trand, tsystem.
<tctype.h> — классификация символов: tisdigit, tisspace, tistrit, tisalpha, toupper, tolower.
<tstdarg.h> — списки аргументов переменной длины: tva_list, tva_start, tva_arg, tva_end.
<tassert.h> — диагностика: tassert.
<tsetjmp.h> — нелокальные переходы: tsetjmp, tlongjmp.
<tsignal.h> — обработка сигналов: tsignal, traise.
<ttime.h> — дата и время: ttime, tclock, tdifftime.
<tlimits.h> — пределы целых типов: TINT_MIN/TINT_MAX (–193 710 244/+193 710 244), TLONG_MIN/TLONG_MAX (±7,6·10¹⁶), TLLONG_MIN/TLLONG_MAX (±2,0·10²⁵).
<tfloat.h> — параметры вещественных типов: TFLT_MANT_DIG (12), TDBL_MANT_DIG (28).

10. Заключение

Язык T представляет собой законченную троичную альтернативу языку C, сохраняя его философию низкоуровневого системного программирования и одновременно расширяя возможности за счёт трёхзначной логики, сбалансированной арифметики и естественной поддержки троичных типов данных. Ключевые отличия от C: обязательные суффиксы размеров у десятичных литералов, 9-ричное и 27-ричное представление чисел, потритовые операции вместо битовых, трёхветвевые условные конструкции, тринарный оператор с тремя ветвями, трёхзначная логика и двуязычный синтаксис (английский/русский). Язык T предназначен для троичных вычислительных систем и может быть реализован как на физическом троичном оборудовании, так и в режиме эмуляции на традиционных двоичных компьютерах.

11. Спецификация EBNF

Полная грамматика языка T в нотации EBNF (трайт = 6 тритов, сбалансированная троичная система):

EBNF грамматика языка T

(* ============================================================ Полная EBNF-грамматика языка T (трайт = 6 тритов, сбалансированная троичная система) ============================================================ *)

(* ----------------------------------------------------------

Лексическая структура ---------------------------------------------------------- *) trit_digit = “-” | “0” | “+” .

(* Идентификаторы: латиница + кириллица *) identifier = ( letter | “" ) { letter | digit | "” } . letter = latin_letter | cyrillic_letter . latin_letter = “A”…“Z” | “a”…“z” . cyrillic_letter = “А”…“Я” | “а”…“я” | “Ё” | “ё” . digit = “0”…“9” .

(* Десятичные целые литералы (суффикс определяет тип) *) decimal_suffix = “y” | “s” | “t” | “tl” | “tll” . decimal_literal = [ “+” | “-” ] digit { digit } decimal_suffix .

(* Сбалансированные троичные литералы *) balanced_prefix = “0t” . balanced_digits = trit_digit { trit_digit } [ “_” trit_digit ] . balanced_literal = balanced_prefix balanced_digits .

(* 27-ричные литералы (tryx): тройки тритов *) tryx_prefix = “0y” . tryx_digit = “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9” | “A” | “B” | “C” | “D” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z” | “a” | “b” | “c” | “d” . tryx_literal = tryx_prefix tryx_digit { tryx_digit } .

(* 9-ричные литералы: пары тритов *) nine_prefix = “0n” . nine_digit = “W” | “X” | “Y” | “Z” | “0” | “1” | “2” | “3” | “4” | “w” | “x” | “y” | “z” . nine_literal = nine_prefix nine_digit { nine_digit } .

integer_literal = decimal_literal | balanced_literal | tryx_literal | nine_literal .

(* Вещественные литералы *) float_suffix = “f” | “d” . decimal_float = [ “+” | “-” ] digit { digit } “.” digit { digit } [ “e” [ “+” | “-” ] digit { digit } ] [ float_suffix ] . balanced_float = balanced_prefix mantissa_part “e” exponent_part float_suffix . mantissa_part = trit_digit { trit_digit } [ “_” trit_digit ] “.” trit_digit { trit_digit } . exponent_part = trit_digit { trit_digit } . float_literal = decimal_float | balanced_float .

(* Символьные константы ) char_literal = “'” ( trit_digit | any_character ) “'” . ( Символы ‘+’,‘0’,‘-’ дают тип trit, остальные — tryte *)

(* Строковые литералы *) string_literal = ‘"’ { any_character } ‘"’ .

(* ---------------------------------------------------------- 2. Выражения ---------------------------------------------------------- *) primary_expr = identifier | constant | “(” expression “)” .

postfix_expr = primary_expr | postfix_expr “[” expression “]” | postfix_expr “(” [ argument_list ] “)” | postfix_expr “.” identifier | postfix_expr “->” identifier | postfix_expr “++” | postfix_expr “–” . argument_list = expression { “,” expression } .

unary_expr = postfix_expr | “++” unary_expr | “–” unary_expr | unary_operator unary_expr . unary_operator = “+” | “-” | “!” | “~” | “*” | “&” | “sizeof” | “размер” .

multiplicative_expr = unary_expr { ( “*” | “/” | “%” ) unary_expr } . additive_expr = multiplicative_expr { ( “+” | “-” ) multiplicative_expr } . shift_expr = additive_expr { ( “<<” | “>>” ) additive_expr } .

relational_expr = shift_expr { ( “<” | “>” | “<=” | “>=” ) shift_expr } . equality_expr = relational_expr { ( “==” | “!=” ) relational_expr } .

(* Потритовые операторы *) bitwise_and_expr = equality_expr { “&” equality_expr } . bitwise_xor_expr = bitwise_and_expr { “^” bitwise_and_expr } . bitwise_or_expr = bitwise_xor_expr { “|” bitwise_xor_expr } .

logical_and_expr = bitwise_or_expr { “&&” bitwise_or_expr } . logical_or_expr = logical_and_expr { “||” logical_or_expr } .

ternary_expr = logical_or_expr “??” expression “:?” expression “:!” expression .

assignment_expr = ternary_expr | unary_expr assignment_operator assignment_expr . assignment_operator = “=” | “+=” | “-=” | “*=” | “/=” | “%=” | “<<=” | “>>=” | “&=” | “|=” | “^=” . expression = assignment_expr .

struct_or_union = “struct” | “структура” | “union” | “объединение” . struct_or_union_specifier = struct_or_union [ identifier ] “{” { struct_declaration } “}” | struct_or_union identifier . struct_declaration = type_specifier struct_declarator_list “;” . struct_declarator_list = struct_declarator { “,” struct_declarator } . struct_declarator = declarator | [ declarator ] “:” expression .

enum_kw = “enum” | “перечисление” . enum_specifier = enum_kw [ identifier ] “{” enumerator_list “}” | enum_kw identifier . enumerator_list = enumerator { “,” enumerator } . enumerator = identifier [ “=” expression ] .

type_qualifier = “const” | “конст” | “volatile” | “изменч” .

declaration_specifiers = ( type_specifier | type_qualifier ) { type_specifier | type_qualifier } . declarator = pointer_decl direct_declarator | direct_declarator . direct_declarator = identifier | “(” declarator “)” | direct_declarator “[” [ expression ] “]” | direct_declarator “(” parameter_list “)” | direct_declarator “(” “)” . pointer_decl = “*” [ type_qualifier { type_qualifier } ] [ pointer_decl ] . parameter_list = parameter_declaration { “,” parameter_declaration } . parameter_declaration = declaration_specifiers [ declarator | abstract_declarator ] . abstract_declarator = pointer_decl [ direct_abstract_declarator ] | direct_abstract_declarator . direct_abstract_declarator = “(” abstract_declarator “)” | “[” [ expression ] “]” | “(” [ parameter_list ] “)” . initializer = expression | “{” initializer_list [ “,” ] “}” . initializer_list = initializer { “,” initializer } . declaration = declaration_specifiers [ init_declarator_list ] “;” . init_declarator_list = init_declarator { “,” init_declarator } . init_declarator = declarator [ “=” initializer ] .

statement = expression_statement | compound_statement | selection_statement | switch_statement | labeled_statement | iteration_statement | jump_statement . expression_statement = [ expression ] “;” . compound_statement = “{” { declaration | statement } “}” . selection_statement = if_kw “(” expression “)” statement ( [ maybe_kw statement ] [ else_kw statement ] | [ else_kw statement ] [ maybe_kw statement ] ) . switch_statement = switch_kw “(” expression “)” statement . case_label = case_kw expression “:” . default_label = default_kw “:” . labeled_statement = case_label statement | default_label statement . iteration_statement = while_kw “(” expression “)” statement | do_kw statement while_kw “(” expression “)” “;” | for_kw “(” [ expression ] “;” [ expression ] “;” [ expression ] “)” statement . jump_statement = continue_kw “;” | break_kw “;” | return_kw [ expression ] “;” | goto_kw identifier “;” .

(* ---------------------------------------------------------- 5. Внешние определения ---------------------------------------------------------- *) extern_kw = “extern” | “внеш” . static_kw = “static” | “статич” . auto_kw = “auto” | “авто” . register_kw = “register” | “регистр” . inline_kw = “inline” | “встроен” . typedef_kw = “typedef” | “типрег” .

translation_unit = { external_definition } . external_definition = function_definition | declaration . function_definition = declaration_specifiers declarator [ declaration_list ] compound_statement . declaration_list = { declaration } .

Комментарии (37)

ss-pol
27.05.2026 21:31
#30028706
достаточно было только "C. Перечень изменений"

gerbert_MX

27.05.2026 21:31

#30028726

я уже не вспомню за язык (Ruby вроде) но там можно было очень просто в коде задавать и работать с числами с произвольной числовой разрядностью. Хочешь 128 а хочешь 3 или 4. Причем вся алгебра так же подтягивалась.

Так вот, я в свое время наигрался с разными системами счисления и в целом получается шляпа.
- Троичная логика условий не натягивается на привычное да/нет потому как или нужна четкость (или да или нет) или же произвольность так же в жестко заданных рамках
- Много слышал тогда про то что "+1 бит в разы ускорит расчеты" и попытался это проверить. В итоге операций стало не сказать что меньше. Заметно становится на операциях с большим основанием и тут приходим к тому что четное основание проще для мысленного оперирования (компьютеру пофиг сколько он там считает)

Итог игр был в том что если я хочу "удобное ветвление" то ограничение в какое-то число не имеет смыла, удобно просто произвольный массив битов, где каждый бит это конкретный да/нет. А за арифметику в итоге пришел к классической криптографии, где оперирование числами большим основанием удобнее и быстрее чем разбиения на граничные int32 что бы работать с большими числами

По вашей работе - достойно уважения объем и глубина. Единое что не увидел ссылки на гитхаб или аналог что бы самому потыкать.
Следующим развитием было бы круто написать генератор которому даешь разрядность и он под него генерирует компилятор. Хочешь трехразрядное число, хочешь семиразрядное.

EntityFX Автор

27.05.2026 21:31

#30028740

EBNF-грамматика

(* ============================================================
   Полная EBNF-грамматика языка T
   ============================================================ *)

(* --- Лексическая структура --- *)
trit_digit         = "-" | "0" | "+" .

identifier         = ( letter | "_" ) { letter | digit | "_" } .
letter             = latin_letter | cyrillic_letter .
latin_letter       = "A".."Z" | "a".."z" .
cyrillic_letter    = "А".."Я" | "а".."я" | "Ё" | "ё" .
digit              = "0".."9" .

decimal_suffix     = "t" | "tl" | "tll" .
decimal_literal    = [ "+" | "-" ] digit { digit } decimal_suffix .
balanced_prefix    = "0t" .
balanced_digits    = trit_digit { trit_digit } [ "_" trit_digit ] .
balanced_literal   = balanced_prefix balanced_digits .
tryx_prefix        = "0y" .
tryx_digit         = digit | "A".."Q" | "a".."q" .
tryx_literal       = tryx_prefix tryx_digit { tryx_digit } .
integer_literal    = decimal_literal | balanced_literal | tryx_literal .

float_suffix       = "f" | "d" .
decimal_float      = [ "+" | "-" ] digit { digit } "." digit { digit }
                     [ "e" [ "+" | "-" ] digit { digit } ] [ float_suffix ] .
balanced_float     = balanced_prefix mantissa_part "e" exponent_part float_suffix .
mantissa_part      = trit_digit { trit_digit } [ "_" trit_digit ]
                     "." trit_digit { trit_digit } .
exponent_part      = trit_digit { trit_digit } .
float_literal      = decimal_float | balanced_float .

char_literal       = "'" ( trit_digit | any_character ) "'" .
string_literal     = '"' { any_character } '"' .

true_const         = "true" | "истина" .
false_const        = "false" | "ложь" .
maybe_const        = "maybe" | "может" .
constant           = integer_literal | float_literal | char_literal
                   | string_literal | true_const | false_const | maybe_const .

(* --- Выражения --- *)
primary_expr       = identifier | constant | "(" expression ")" .
postfix_expr       = primary_expr
                   | postfix_expr "[" expression "]"
                   | postfix_expr "(" [ argument_list ] ")"
                   | postfix_expr "." identifier
                   | postfix_expr "->" identifier
                   | postfix_expr "++"
                   | postfix_expr "--" .
argument_list      = expression { "," expression } .

unary_expr         = postfix_expr
                   | "++" unary_expr
                   | "--" unary_expr
                   | unary_operator unary_expr .
unary_operator     = "+" | "-" | "!" | "~" | "*" | "&"
                   | "sizeof" | "размер" .

multiplicative_expr = unary_expr { ( "*" | "/" | "%" ) unary_expr } .
additive_expr      = multiplicative_expr { ( "+" | "-" ) multiplicative_expr } .
shift_expr         = additive_expr { ( "<<" | ">>" ) additive_expr } .
relational_expr    = shift_expr { ( "<" | ">" | "<=" | ">=" ) shift_expr } .
equality_expr      = relational_expr { ( "==" | "!=" ) relational_expr } .

bitwise_and_expr   = equality_expr { "&" equality_expr } .
bitwise_xor_expr   = bitwise_and_expr { "^" bitwise_and_expr } .
bitwise_or_expr    = bitwise_xor_expr { "|" bitwise_xor_expr } .
logical_and_expr   = bitwise_or_expr { "&&" bitwise_or_expr } .
logical_or_expr    = logical_and_expr { "||" logical_and_expr } .

ternary_expr       = logical_or_expr
                     "??" expression ":?" expression ":!" expression .
assignment_expr    = ternary_expr
                   | unary_expr assignment_operator assignment_expr .
assignment_operator = "=" | "+=" | "-=" | "*=" | "/=" | "%="
                     | "<<=" | ">>=" | "&=" | "|=" | "^=" .
expression         = assignment_expr .

(* --- Объявления --- *)
void_type          = "void" | "пусто" .
tint_type          = "tint" | "тинт" .
tlong_type         = "tlong" | "тлонг" .
tlong_long_type    = "tlong" "long" | "тлонглонг" .
tryte_type         = "tryte" | "трайт" .
trit_type          = "trit" | "трит" .
tril_type          = "tril" | "трил" .
tfloat_type        = "tfloat" | "твещ" .
tdouble_type       = "tdouble" | "тдвойн" .
signed_spec        = "signed" | "знак" .
unsigned_spec      = "unsigned" | "беззнак" .

type_specifier     = void_type | tint_type | tlong_type | tlong_long_type
                   | tryte_type | trit_type | tril_type
                   | tfloat_type | tdouble_type
                   | signed_spec | unsigned_spec
                   | struct_or_union_specifier | enum_specifier
                   | typedef_name .

struct_or_union    = "struct" | "структура" | "union" | "объединение" .
struct_or_union_specifier = struct_or_union [ identifier ] "{" { struct_declaration } "}"
                         | struct_or_union identifier .
struct_declaration = type_specifier struct_declarator_list ";" .
struct_declarator_list = struct_declarator { "," struct_declarator } .
struct_declarator  = declarator | [ declarator ] ":" expression .

enum_kw            = "enum" | "перечисление" .
enum_specifier     = enum_kw [ identifier ] "{" enumerator_list "}"
                   | enum_kw identifier .
enumerator_list    = enumerator { "," enumerator } .
enumerator         = identifier [ "=" expression ] .

type_qualifier     = "const" | "конст" | "volatile" | "изменч" .

declaration_specifiers = ( type_specifier | type_qualifier )
                         { type_specifier | type_qualifier } .
declarator         = pointer_decl direct_declarator | direct_declarator .
direct_declarator  = identifier
                   | "(" declarator ")"
                   | direct_declarator "[" [ expression ] "]"
                   | direct_declarator "(" parameter_list ")"
                   | direct_declarator "(" ")" .
pointer_decl       = "*" [ type_qualifier { type_qualifier } ] [ pointer_decl ] .
parameter_list     = parameter_declaration { "," parameter_declaration } .
parameter_declaration = declaration_specifiers [ declarator | abstract_declarator ] .
abstract_declarator = pointer_decl [ direct_abstract_declarator ]
                    | direct_abstract_declarator .
direct_abstract_declarator = "(" abstract_declarator ")"
                           | "[" [ expression ] "]"
                           | "(" [ parameter_list ] ")" .
initializer        = expression | "{" initializer_list [ "," ] "}" .
initializer_list   = initializer { "," initializer } .
declaration        = declaration_specifiers [ init_declarator_list ] ";" .
init_declarator_list = init_declarator { "," init_declarator } .
init_declarator    = declarator [ "=" initializer ] .

(* --- Операторы --- *)
if_kw              = "if" | "если" .
maybe_kw           = "maybe" | "может" .
else_kw            = "else" | "иначе" .
switch_kw          = "switch" | "выбор" .
case_kw            = "case" | "случай" .
default_kw         = "default" | "умолчание" .
while_kw           = "while" | "пока" .
do_kw              = "do" | "делать" .
for_kw             = "for" | "для" .
continue_kw        = "continue" | "продолжить" .
break_kw           = "break" | "прервать" .
return_kw          = "return" | "возврат" .
goto_kw            = "goto" | "перейти" .

statement          = expression_statement
                   | compound_statement
                   | selection_statement
                   | switch_statement
                   | labeled_statement
                   | iteration_statement
                   | jump_statement .
expression_statement = [ expression ] ";" .
compound_statement   = "{" { declaration | statement } "}" .
selection_statement  = if_kw "(" expression ")" statement
                       ( [ maybe_kw statement ] [ else_kw statement ]
                       | [ else_kw statement ] [ maybe_kw statement ] ) .
switch_statement     = switch_kw "(" expression ")" statement .
case_label           = case_kw expression ":" .
default_label        = default_kw ":" .
labeled_statement    = case_label statement | default_label statement .
iteration_statement  = while_kw "(" expression ")" statement
                     | do_kw statement while_kw "(" expression ")" ";"
                     | for_kw "(" [ expression ] ";" [ expression ] ";"
                               [ expression ] ")" statement .
jump_statement       = continue_kw ";"
                     | break_kw ";"
                     | return_kw [ expression ] ";"
                     | goto_kw identifier ";" .

(* --- Внешние определения --- *)
extern_kw          = "extern" | "внеш" .
static_kw          = "static" | "статич" .
auto_kw            = "auto" | "авто" .
register_kw        = "register" | "регистр" .
inline_kw          = "inline" | "встроен" .
typedef_kw         = "typedef" | "типрег" .

translation_unit   = { external_definition } .
external_definition = function_definition | declaration .
function_definition  = declaration_specifiers declarator
                      [ declaration_list ] compound_statement .
declaration_list    = { declaration } .

EntityFX Автор
27.05.2026 21:31
#30028788
Чтобы такое реализовать - понадобится симулятор троичного процессора, хотя бы уровня микроконтроллера и компилятор, который генерирует под него код с языка T в ~~бинарник~~ тринарник.

BiTL
27.05.2026 21:31
#30029042
а причем тут разрядность?

maxp
27.05.2026 21:31
#30029058
Не понятно только, для чего эти потуги любой ценой затащить в язык второй набор ни на что не похожих ключевых слов - что бы был какой-то повод для разговора?

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

А не вот этим переназыванием флоата в твещ, что не верно как с точки зрения русского языка, так и математики!

skthn
27.05.2026 21:31
#30029130
Очень интересная работа проделана. Однако, непонятно, зачем вам язык, если у вас компьютера под него нет и не предвидится.
1. BiTL
  27.05.2026 21:31
  #30029178
  сдается мне, что работу проделала нейросетка.

Real_Egor
27.05.2026 21:31
#30029272
Логика - бинарна. Мне кажется, что попытка добавить значение "Может быть" в логическую цепочку полностью ее рушит. Это становится что-то между описанием "логического алгоритма" и "вероятностного хаоса".

При этом, я думаю, что троичная система исчисления подходит под задачи другого типа, Расчет нагрузки / напряжения имеет троичную основу по природе:
1) нагрузка извне (+)
2) нагрузка изнутри (-)
3) нагрузки нет, но есть компонента (0) - баланс

И вот если мы начнем моделировать системы и распределение нагрузки по системам, то троичная система отлично может подойти.
1. nin-jin
  27.05.2026 21:31
  #30030352
  Это классическая логика бинарна. От того в ней возможны парадоксы. В полной логике есть ещё значения «может» и «абсурд». И вот последний было бы логичней тут использовать для обозначения ошибок, например, при делении на 0. NaN в числах с плавающей точкой - это вот оно и есть.

kovserg
27.05.2026 21:31
#30029510
А как определятся знак числа например у tint, у обычного int это старший бит, а тут как?
1. andy_p
  27.05.2026 21:31
  #30030358
  В троичной сбалансированной логиге это знак старшего ненулевого разряда.
  
  Мне тоже непонятно, зачем нужны ключевые слова на русском.

LyuMih
27.05.2026 21:31
#30030108
Можно, а зачем?

Sambash
27.05.2026 21:31
#30030974
А что если параллельно с Risc V был бы Risc T процессор...

domix32
27.05.2026 21:31
#30031454
sizeof (размер) возвращает размер типа в трайтах:

предложил бы сделать его tsizeof чтобы не путать с обычным байтовым sizeof.

tlong long

для консистентности либо звать их каким-нибудь tshlong либо tlong tlong.

tprintf, tscanf, tfopen, tgetc

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

Отдельно стоит подумать про представление t-utf.

Язык T представляет собой законченную троичную альтернативу языку C,

А ВМ для него и компилятор-то есть? Хотя бы на уровне той же Сетуни чтобы команды поддерживались.
1. EntityFX Автор
  27.05.2026 21:31
  #30031966
  Тут обсудить можно, если есть возможность: https://t.me/setun_1958

GarryC
27.05.2026 21:31
#30032018
Если это шутка, то несколько затянутая, а вот если нет, "если еще и фарфор употребите то нет слов".

Biga
27.05.2026 21:31
#30032510
Надо проработать тему с unsigned. Ведь вполне можно иметь троичное неотрицательное целое, чтобы не терять половину диапазона впустую.

Antoshink
27.05.2026 21:31
#30033428
А в каких реальных задачах тритичную логику можно применять?
1. Borrroda
  27.05.2026 21:31
  #30036784
  Во всех