Удалил лишние субмодули

Удалил старую реализацию Context В процессе пререхода на новую версию интерпретатора: - Сделал новую версию Data comprehensions - Реализация синтаксическго анализатора ...
rsashka · Mar 12, 2024 · 3cab962 · 3cab962
1 parent 2b0a799
commit 3cab962
Show file tree

Hide file tree

Showing 45 changed files with 10,487 additions and 10,939 deletions.
diff --git a/.gitmodules b/.gitmodules
@@ -1,12 +1,6 @@
 [submodule "contrib/googletest"]
 	path = contrib/googletest
 	url = https://github.com/google/googletest.git
-[submodule "contrib/Lyra"]
-	path = contrib/Lyra
-	url = https://github.com/bfgroup/Lyra.git
-[submodule "contrib/tensorboard_logger"]
-	path = contrib/tensorboard_logger
-	url = https://github.com/RustingSword/tensorboard_logger.git
 [submodule "contrib/text2cpp"]
 	path = contrib/text2cpp
 	url = https://github.com/lostjared/text2cpp.git
diff --git a/backup b/backup
diff --git a/contrib/Lyra b/contrib/Lyra
diff --git a/contrib/tensorboard_logger b/contrib/tensorboard_logger
diff --git a/site/content/ru/docs/arch/errors.md b/site/content/ru/docs/arch/errors.md
@@ -0,0 +1,24 @@
+---
+title: Реализация обработки ошибок и прерываний
+weight: 30
+---
+
+Для обработки [перываний потока выполения](/ru/docs/ops/throw/), а также для обработки ошибкок компилятора 
+используются С++ классы - наследники от std::exception, которые возвращают объект ошибки (значение).
+
+
+Ошибка компилятора возвращает не только тестовое описание, но и объект TermPtr, при обработке которого возникла ошибка,
+тогда как перывание потока выполения возвращается объект ObjPtr.
+```
+std::exception -+-> :ParserError
+                |     (TermPtr)
+                | 
+                +-> :RuntimeError ----> :IntAny --+-> :IntPlus
+                       (ObjPtr)                   |
+                                                  |
+                                                  +-> :IntMinus
+                
+```
+
+**При выполнении (генерации кода) именованные прерывания могут быть реализованы без использования исключений!**
+
diff --git a/site/content/ru/docs/arch/mangling.md b/site/content/ru/docs/arch/mangling.md
@@ -236,10 +236,10 @@ ns {
         @return arg_long + arg_byte;
     }
 
-    # Её С/С++ прототип для первого (основоного) имени
+    # С/С++ прототип для первого (основоного) имени
     # extern "C" _$$_func_embed$( Obj &args );
 
-    # Её С/С++ прототип для второго (дополнительного) имени
+    # С/С++ прототип для второго (дополнительного) имени
     # extern "C" _$$_func_embed$_$(int64_t arg_long, uint8_t arg_byte = 10);
 
     # Тогда при раскрытии блока с расширенным синтаксисом 
@@ -248,6 +248,17 @@ ns {
     {%
         int64_t value = $func_embed(10, 20);
     %}
-
 
-```
+```
+*Хотя может имеет смысл сделать inline шаблон для подобного вызова, а не создавать кополнительное имя?*
+
+{{% pageinfo %}}
+```
+./object.h:732:25: error: deduced conflicting types ('int' vs 'const char *') for initializer list element type   
+            auto list = {args...};   
+                        ^~~~~
+test/object_test.cpp:131:21: note: in instantiation of function template specialization 'newlang::Obj::operator()<int, const char *>' requested here   
+    str3 = (*format)(-1, "222");   
+                    ^     
+```
+{{% /pageinfo %}}
diff --git a/site/content/ru/docs/ops/create.md b/site/content/ru/docs/ops/create.md
@@ -53,7 +53,7 @@ weight: 10
 # Создать новый или переопределить printf ???????????????????????????????????????????
 ```
 
-### Присваивание значения сразу нескольким переменным и оператор распаковки словаря
+### Присваивание значения сразу нескольким переменным и оператор распаковки словаря {#expand}
 *NewLang* поддерживает операцию присваивания значения сразу нескольким переменным, 
 которые должны быть перечислены через запятую слева от оператора присвоения. 
 С правой стороны от оператора присвоения может находится только одно значение.
@@ -94,3 +94,47 @@ weight: 10
     };
 ```
 
+## Заполнение данными {#comprehensions}
+
+При заполнении данными *размерных* тензоров существует краткий способ указания их начальных значений.
+Для этого используется многоточие в следующих вариантах:
+- `:Tensor[10](2,3, ...)` - повторение ***всех*** предыдущих данных до полного заполнения тензора, 
+что равносильно записи `:Tensor[10](2,3,  2,3,  2,3,  2,3,  2,3)`.
+
+- `:Tensor[10](2, 3, ... 42 ...)` - заполнение значением `42` до конца тензора, 
+что равносильно записи `:Tensor[10](2,3, 42,42,42,42,42,42,42,42)`.
+
+- `:Tensor[10](2, 3, ... rand() ...)` - заполнение до конца тензора значением, которое будет возвращать функция.
+Указанная функция будет вызываться для **каждого элемента** до полного заполнения тензора (8 раз).
+
+- `:Tensor[10]( rand(), rand(), ...)` - заполнение тензора *двумя* произвольными заначениями,
+то есть функция `rand()` будет вызвана дважды для двух первых элементов,
+после чего эти значения будут использоваться до полного заполнения тензора (как в первом примере).
+
+- `:Tensor( ... 0..0.99..0.1 )` - заполнение тензора элементами диапазона, что равносильно записи   
+`:Tensor(0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)`
+
+- `:Tensor[15]( ... 0..5  ,  ... )` - заполнение тензора элементами диапазона с их повторением до заданного размера тензора:
+`:Tensor(0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4)`
+
+### Заполнение данными в словарях и аргументах функций
+Предыдущие способы заполнения данными возможны только для тензоров фиксированного размера, 
+так как позволяют получить произвольное количество значений, 
+но их можно применять только в конце списка значения для инициализации.
+
+Операторы раскрытия словаря или диапазона создают ограниченное количество значений,
+но за счет этого их можно использовать не только для инициализации тензоров,
+но и в качестве начальных значений у словарей или создания аргументов при вызове функций,
+причем в произвольном месте, а не только в конце списка инициализации:
+
+- `:Tensor( ... 0..0.99..0.1 )` - заполнение тензора без указания его размера элементами диапазона,
+что равносильно записи  `:Tensor(0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)`
+
+- `funtcion( 0, ... dict, 42 )` - раскрытие словаря как индивидуальных *не именованных* аргументов функции,
+к примеру funtcion( 0, 1, 2, 3, 42), если словарь `dict` содержал три элемента `1`, `2` и `3`.
+
+- `funtcion( ...  ... dict, end=4)` - раскрытие словаря как индивидуальных **именованных** аргументов функции.
+Если словарь *dict* будет содержать элементы `(1, two=2, three=3,)`, 
+то это будет равносильно вызову функции `funtcion( 1, two=2, three=3, end=4)`.
+
+
diff --git a/site/content/ru/docs/ops/throw.md b/site/content/ru/docs/ops/throw.md
@@ -17,7 +17,7 @@ weight: 500
 в других языках программирования, а **++**'Строка'**++** - аналогом `return 'Строка';`.
 
 
-### Локальный переход
+### Локальный переход {#local}
 
 Именованные [блоки кода](/ru/docs/ops/block/) могут выступать в качестве локальных меток для передачи потока выполнения.
 Если перед оператором прерывания указать [пространство имен](/ru/docs/syntax/namespace/), 
@@ -27,9 +27,9 @@ weight: 500
 передавая поток выполнения на первую инструкцию блока кода,
 а *положительное* прерывание как оператор **break**, выходя из него.
 
-Так как локальная передача потока управления работает только с *именованными* блоками кода, 
-то переход в начало блока или прерывание потока выполнения с выходом из него, 
-возможна и изнутри вложенных блоков кода.
+Локальная передача потока управления работает с *именованными* блоками кода, 
+поэтому переход в начало блока кода или выход из него, 
+возможны в том числе и изнутри нескольких вложенных именнованных блоков кода.
 
 ```python
     b1 := 1;
@@ -78,10 +78,10 @@ weight: 500
 ```
 
 
-### Возврат результата
+### Возврат результата {#return}
 
-Для возврата результата из тела функции *именованное* используется *положительное* прерывание из блока кода, 
-меткой которого является полное имя функции, вклчая области имен. Полное имя текущей функции (т.е. имя блока кода функции) 
+Для возврата результата из тела функции используется *положительное* прерывание из блока кода, 
+меткой которого является полное имя функции, включая текщую области имен. Полное имя текущей функции (т.е. имя блока кода функции) 
 можно взять в макро-переменой препроцессора `@__FUNC_BLOCK__`.
 
 ```python
@@ -102,21 +102,25 @@ ns:: { # Пространство имен ns
 };
 ```
 
-Для оператора прерывания можно указать и глобальную область видимости
-и при выполнении такого прерывания происходит выход из самого верхнеуровневого блока кода, 
+Для оператора прерывания выполенения можно указать и глобальную область видимости.
+Тогда при выполнении такого прерывания происходит выход из самого верхнеуровневого блока кода, 
 что приводит к завершение работы приложения.
 
 Аналогом такого поведения являются функции `exit()` для *положительного* прерывания
 и `abort()` для *отрицательного*, что отражено в [DSL](/ru/docs/syntax/dsl/).
 
 
-### Перехват прерывааний
+### Перехват прерывааний {#catch}
 
-Для не именованных прерываний, более точным аналогом будет не **return**, а **throw**, т.к. эти операторы не только прерывают 
-выполнение последовательности команд в [блоке кода](/ru/docs/ops/block/) и возвращают результат, но их еще можно *"ловить"*. 
+Именованные прерывания потока выполнения можно использовать только внутри соответствующих блоков кода.
+
+Для не именованных прерываний такое ограничение отсуствует, 
+поэтому более точным аналогом не именованного прерывания будет не *return* или *break*, а ***throw***, 
+т.к. эти операторы не только прерывают выполнение последовательности команд 
+в любом [блоке кода](/ru/docs/ops/block/) и возвращают результат, но их еще и можно *"ловить"*. 
 
 Для перехвата прерываний используются блоки кода с соответствующей семантикой, **{+** ... **+}** - блок кода, который перехватывает 
-положительные прерывания и **{-** ... **-}** - блок кода, который перехватывает прерывания, созданные операторами **\-\-**,
+положительные прерывания и **{-** ... **-}** - блок кода, который перехватывает отрицательные прерывания, созданные операторами **\-\-**,
 и блок кода **{\*** ... **\*}**, который перехватывает сразу оба типа прерываний. 
 
 Например, возврат из нескольких вложенных функций без необходимости обрабатывать результат возврата в каждой из них. 
@@ -150,7 +154,7 @@ ns:: { # Пространство имен ns
 ```
 
 
-### Обработка ошибок
+### Обработка ошибок  {#error}
 
 Оба варианта прерываний равнозначны и "отрицательное" прерывание для возврата ошибки используется только условно.
 Блоки кода с перехватом прерываний, совместно с оператором [оценки выражения](/ru/docs/ops/match/), 
@@ -204,7 +208,7 @@ ns:: { # Пространство имен ns
 ```
 
 
-### Расширенные варинаты прерывания выполнения
+### Расширенные варинаты прерывания выполнения  {#coroutine}
 
 Добавить реализациию для короутин после их полной реализации в clang (скорее всего на уровне аннотаций)
 
@@ -239,13 +243,13 @@ ns {
 };
 ```
 
-Выражение co_yield возвращает значение вызывающей стороне и приостанавливает текущую сопрограмму: 
+> Выражение co_yield возвращает значение вызывающей стороне и приостанавливает текущую сопрограмму: 
 это общий строительный блок возобновляемых функций-генераторов.
 
 
 co_await  **+-**
 
-Унарный оператор co_await приостанавливает сопрограмму и возвращает управление вызывающей стороне. 
+> Унарный оператор co_await приостанавливает сопрограмму и возвращает управление вызывающей стороне. 
 Его операнд представляет собой выражение, которое либо (1) относится к типу класса, определяющему оператор-член co_await, 
 либо может быть передано оператору, не являющемуся членом co_await, либо (2) может быть преобразовано в такой тип класса с помощью текущей сопрограммы.
 
diff --git a/site/content/ru/docs/types/convert.md b/site/content/ru/docs/types/convert.md
@@ -57,37 +57,3 @@ tags: [типы данных]
 >:Tensor( ('first', space=32, second='second',) ) 
 [102, 105, 114, 115, 116, 32, 115, 101, 99, 111, 110, 100,]:Int8
 ```
-
-## Дополнение данными
-```
-# Тензор заданного формата с нулями,
-# где многоточие повторяет последнее значение до требуемого размера
->:Float64[10,2]( 0, ...) 
-[
-  [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,],
-]:Float64
-
-# Тензор со случайными данными, где между многоточиями указана функция,
-# которую следует вызывать каждый раз при получении нового элемента тензора
-#
-# Тут пришлось придумывать новую синтаксическую конструкцию 
-# для вызова функции для каждого нового элемента, т.к. многоточие 
-# перед идентификатором, это оператор раскрытия словаря, 
-# а многоточие после идентификатора, это повторение последнего 
-# значения до конца заданной размерности.
->:Int32[3,2]( ... rand() ...) 
-[
-  [1804289383, 846930886,], [1681692777, 1714636915,], [1957747793, 424238335,],
-]:Int32
-
-# Создание тензора из диапазона
->:Int32[5,2]( 0..10 ); 
-[
-  [0, 1,], [2, 3,], [4, 5,], [6, 7,], [8, 9,],
-]:Int32
-
-# Или даже так
->:Tensor( 0..0.99..0.1 ); 
-[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,]:Float64
-```
-
diff --git a/site/content/ru/docs/types/generics.md b/site/content/ru/docs/types/generics.md
@@ -17,18 +17,19 @@ tags: [типы данных, ООП, коллекции]
       |                |            |               (:DWord64)        (:Char)
       |                |            |                                 (:Byte)
       |                |            |
-      |                |            +-> :Number --> :Float64 --> :Float32 --> :Float16
+      |                |            +-> :Number --> :Float64 --> :Float32 --> :Float16 --> ...
       |                |            |              (:Double)    (:Single)
       |                |            |
       |                |            +-> :Complex ...
       |                | 
       |                +-> :Rational
       | 
       +-> :String -+-> :StrChar
+      |            |  (:FmtChar)
       |            |
       |            +-> :StrWide
-      |            |
-      |            +-> :FmtChar
+      |               (:FmtWide)
+      |            
       |
      ...