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

[ss-pol]

достаточно было только "C. Перечень изменений"

[gerbert_MX]

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

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

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

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

[EntityFX]

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]

Чтобы такое реализовать - понадобится симулятор троичного процессора, хотя бы уровня микроконтроллера и компилятор, который генерирует под него код с языка T в бинарник тринарник.

[BiTL]

а причем тут разрядность?

[maxp]

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

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

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

[skthn]

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

[BiTL]

сдается мне, что работу проделала нейросетка.

[Real_Egor]

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

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

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

[nin-jin]

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

[kovserg]

А как определятся знак числа например у tint, у обычного int это старший бит, а тут как?

[andy_p]

В троичной сбалансированной логиге это знак старшего ненулевого разряда.

Мне тоже непонятно, зачем нужны ключевые слова на русском.

[LyuMih]

Можно, а зачем?

[Sambash]

А что если параллельно с Risc V был бы Risc T процессор...

[domix32]

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

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

tlong long

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

tprintf, tscanf, tfopen, tgetc

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

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

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

А ВМ для него и компилятор-то есть? Хотя бы на уровне той же Сетуни чтобы команды поддерживались.

[EntityFX]

Тут обсудить можно, если есть возможность: https://t.me/setun_1958

[GarryC]

Если это шутка, то несколько затянутая, а вот если нет, "если еще и фарфор употребите то нет слов".

[Biga]

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

[Antoshink]

А в каких реальных задачах тритичную логику можно применять?

[next_account]

не помешали бы примеры кода на C и аналогичный на T - что бы сразу плюсы увидеть если они есть (не Т++ а положительные моменты 🤣), хотя бы пару базовых задач типа сортировки ну и конечно такой пример где T выгодно смотрится на фоне C.