The OpenNET Project / Index page

[ новости /+++ | форум | теги | ]

форумы
правила/FAQ
поиск
регистрация
вход
слежка
RSS


Вариант для распечатки  
Пред. тема | След. тема 
Форум Разговоры, обсуждение новостей
Режим отображения отдельной подветви беседы [ Отслеживать ]

Оглавление

В июне в Переславле-Залесском состоится конференция 'СПО в высшей школе', opennews (??), 27-Май-24, (0) [смотреть все]

Сообщения [Сортировка по времени | RSS]


34. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +2 +/–
Сообщение от n00by (ok), 28-Май-24, 10:18 
Очень просто. Написал к примеру я "никому не нужную" (ц) программку. Мне и говорят: делай нам из неё пакетик, и свободен.
Ответить | Правка | Наверх | Cообщить модератору

62. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  –1 +/–
Сообщение от Sw00p aka Jerom (?), 28-Май-24, 12:00 
программиравайдавай.jpg
Ответить | Правка | Наверх | Cообщить модератору

147. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 29-Май-24, 16:14 
> программиравайдавай.jpg

Напрограммировал:


* The Tribute to Pereslavl-Zalessky
ноль "0";
один "1";
_2-e { ноль; один }
_8-e { _2-e; "2"; "3"; "4"; "5"; "6"; "7"; }
_10e { _8-e; "8"; "9" }
_16e { _10e; "A"; "B"; "C"; "D"; "E"; "F"; }
тип {
  _2-e = _2-e;
  _8-e = _8-e;
  _10e = _10e;
  _16e = _16e;
  .    = -;
}
очередь {
      = ;
  ? . = (? " - " <тип ?>) "\t" <очередь .>;
}
начало = <очередь "0123456789ABCDEFG">;

$ refal radix.ref
Поле зрения:
(0 - _2-e)    (1 - _2-e)    (2 - _8-e)    (3 - _8-e)    (4 - _8-e)    (5 - _8-e)    (6 - _8-e)
(7 - _8-e)    (8 - _10e)    (9 - _10e)    (A - _16e)    (B - _16e)    (C - _16e)    (D - _16e)
(E - _16e)    (F - _16e)    (G - -)

Теперь думаю, что это такое вообще.
Ответить | Правка | Наверх | Cообщить модератору

154. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 29-Май-24, 18:26 
>[оверквотинг удален]
> начало = <очередь "0123456789ABCDEFG">;
> $ refal radix.ref
> Поле зрения:
> (0 - _2-e) (1 - _2-e) (2 - _8-e) (3 - _8-e)
> (4 - _8-e) (5 - _8-e) (6 - _8-e)
> (7 - _8-e) (8 - _10e) (9 - _10e) (A - _16e)
> (B - _16e) (C - _16e) (D - _16e)
> (E - _16e) (F - _16e) (G - -)
>
> Теперь думаю, что это такое вообще.

Тут _2-e

8-e { _2-e; "2"; "3"; "4"; "5"; "6"; "7"; }

разве не подмножество?

8-e { { ноль; один }; "2"; "3"; "4"; "5"; "6"; "7"; }

и как в таком случае у вас метчинг происходит?

Ответить | Правка | Наверх | Cообщить модератору

161. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 30-Май-24, 06:50 
>[оверквотинг удален]
>> (7 - _8-e) (8 - _10e) (9 - _10e) (A - _16e)
>> (B - _16e) (C - _16e) (D - _16e)
>> (E - _16e) (F - _16e) (G - -)
>>
>> Теперь думаю, что это такое вообще.
> Тут _2-e
> 8-e { _2-e; "2"; "3"; "4"; "5"; "6"; "7"; }
> разве не подмножество?
> 8-e { { ноль; один }; "2"; "3"; "4"; "5"; "6"; "7";
> }

8-e по смыслу получается { "0"; "1"; "2"; "3"; "4"; "5"; "6"; "7"; }

В Рефале подобное называется функцией. Но там положено, что бы в каждом предложении был спецсимвол =. Слева от него образец, а справа результат - вычисляется, если аргумент подходит под образец. Иначе рассматривается следующее предложение (разделяются точкой с запятой).

> и как в таком случае у вас метчинг происходит?

По вот этой очереди:

тип {
  _2-e = _2-e;
  _8-e = _8-e;
  _10e = _10e;
  _16e = _16e;
  .    = -;
}

Если убрать первое предложение, то "0" распознается как _8-e и т.д. Но это так у меня.

В Рефал-5, что бы получить тот же вывод, функция "тип" должны быть примерно такой:

type {
  "0" = _2-e;
  "1" = _2-e;
  "2" = _8-e;
  "3" = _8-e;
  "4" = _8-e;
  "5" = _8-e;
  "6" = _8-e;
  "7" = _8-e;
  "8" = _10e;
  "9" = _10e;
  "A" = _16e;
  "B" = _16e;
  "C" = _16e;
  "D" = _16e;
  "E" = _16e;
  "F" = _16e;
   .  = -;
}

Если же надо проверить, является ли "0" шестнадцатиричной, тогда придётся написать отдельную функцию. Рефал как бы очень высокоуровневый и сортирует списки меньшим количеством строк чем Лисп, но где-то регекспы получаются проще.

В Рефал нельзя так просто слева от скобки указать имя функции (оно рассматривается просто как идентификатор и матчится только с таким же). У меня разрешено объявление функций только с образцом, а если их имена встречаются в образце, тогда их образцы подставляются вместо имени. Теперь я буду джва года думать, почему авторы языка так не сделали.

Ответить | Правка | Наверх | Cообщить модератору

180. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 30-Май-24, 17:10 
> 8-e по смыслу получается { "0"; "1"; "2"; "3"; "4"; "5"; "6";
> "7"; }
> В Рефале подобное называется функцией. Но там положено, что бы в каждом
> предложении был спецсимвол =. Слева от него образец, а справа результат
> - вычисляется, если аргумент подходит под образец. Иначе рассматривается следующее предложение
> (разделяются точкой с запятой).

Ясно, пришлось прочитать справочник. http://www.refal.net/rf5_frm.htm

Но, что это такое?

ноль "0";
один "1";

почему вне функций? Или вот это

_2-e { ноль; один }

Где сопоставления внутри функции?

Вот БНФ функции

program ::= f-definition
        f-definition  program
        f-definition ;  program
            external-decl ;  program
            program  external-decl ;

f-definition ::= f-name {  block }
         $ENTRY  f-name {  block }

external-decl ::= $EXTERNAL  f-name-list
                  $EXTERN  f-name-list
                  $EXTRN  f-name-list

f-name-list ::= f-name
                f-name , f-name-list

block ::= sentence
          sentence ;
          sentence ;  block

sentence ::= left-side  conditions  =   right-side
         left-side  conditions  ,  block-ending

left-side ::= pattern

conditions ::= empty
               , arg : pattern conditions

arg ::= expression

right-side ::= expression

block-ending ::= arg : { block }


И имена идентификаторов с маленькой буквы. Эт вообще валидный синтаксис? Или это диалект Рефала?

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

Эт ваш диалект Рефала?


left-side ::= pattern

А где определение pattern ?

right-side ::= expression

Тут понятно - общее выражение судя БНФ.

expression ::= empty
               term expression

term ::= symbol
         variable  
         (expression)
         <f-name expression>

f-name ::= identifier
empty ::=


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

Я немного не понял, что вы имеете ввиду, вы хотите в left-side иметь возможность указать идентификаторы функций?


пс: мне чет не понравился этот Рефал, ерланг намного понятней. Рефал ближе к истокам понятия Кодирование Чёрча, чем к функциональному яп современного мира.

Ответить | Правка | Наверх | Cообщить модератору

195. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 31-Май-24, 11:34 
>[оверквотинг удален]
>> "7"; }
>> В Рефале подобное называется функцией. Но там положено, что бы в каждом
>> предложении был спецсимвол =. Слева от него образец, а справа результат
>> - вычисляется, если аргумент подходит под образец. Иначе рассматривается следующее предложение
>> (разделяются точкой с запятой).
> Ясно, пришлось прочитать справочник. http://www.refal.net/rf5_frm.htm
> Но, что это такое?
> ноль "0";
> один "1";
> почему вне функций?

Это сахар над

ноль { "0"; }

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

> Или вот это
> _2-e { ноль; один }
> Где сопоставления внутри функции?

Сопоставление происходит в той функции, где имя данной встречается в образце.

В Рефал-5 в таком случае имена функций рассматриваются как уникальные значения, совпадать может только с таким же именем, если оно встретится в аргументе.

Поскольку язык как бы функциональный, но иногда надо где-то хранить значения, там придумана "копилка", во время исполнения вот таким вызовом присваивается значение:

<Br "ноль" "=" "0">

С ней есть проблема: имена "переменных" нигде не объявляются, их приходится искать текстовым редактором. Я под переменные задействовал те функции, что не валидны с точки зрения языка. Это "ноль" можно ещё и во время исполнения изменять, удалять или добавлять предложения. Просто потому, что это очень просто технически: скомпилированные в байт-код функции хранятся в том же списке, где и аргументы ("поле зрение" в терминологии Рефала). Потом немного доработал распознаватель в исполнителе байт-кода, и получилось вот такое. Если бы "функция ноль" не была определена в исходнике таким образом, то распознавалась бы как и раньше.

>[оверквотинг удален]
> sentence ::= left-side  conditions  =   right-side
>       left-side  conditions  ,  
> block-ending
> left-side ::= pattern
> conditions ::= empty
>            
>    , arg : pattern conditions
> arg ::= expression
> right-side ::= expression
> block-ending ::= arg : { block }

Турчин сделал Рефал, что бы вот такое не писать, а описывать на Рефале. Не знаю, какой смайлик тут ставить. %)

> И имена идентификаторов с маленькой буквы. Эт вообще валидный синтаксис? Или это
> диалект Рефала?

Диалект.

>> У меня разрешено объявление функций только с образцом, а если их имена
>> встречаются в образце, тогда их образцы подставляются вместо имени.
> Эт ваш диалект Рефала?

Скорее, опытный образец.

> left-side ::= pattern
> А где определение pattern ?

Весь язык в книге Турчина на страницах 3 и 4. Паттерн идёт до знака равенства и может быть пуст. может содержать цифры, буквы, идентификаторы (имена функций) и структурные скобки (для группировки данных, должны быть парными) - если образец совпадает с аргументами, тогда вычисляется идущее после =, иначе смотрится следующее предложение. Ещё могут встречаться переменные, куда попадают оставшиеся данные.

> right-side ::= expression
> Тут понятно - общее выражение судя БНФ.

Оно же выражение-результат. После знака равенства.

>[оверквотинг удален]
> term ::= symbol
>          variable
>          (expression)
>          <f-name expression>
> f-name ::= identifier
> empty ::=
>> Теперь я
>> буду джва года думать, почему авторы языка так не сделали.
> Я немного не понял, что вы имеете ввиду, вы хотите в left-side
> иметь возможность указать идентификаторы функций?

Я хочу понять, почему Турчин и последователи такое не сделали, когда само напрашивается и в строчках кода цена копеечная. У меня, например, вложенные блоки пока не поддерживаются: заметно усложнят раскрутку стека переменных в интерпретаторе, а его декомпозицию раньше времени делать не хочется.

> пс: мне чет не понравился этот Рефал, ерланг намного понятней. Рефал ближе
> к истокам понятия Кодирование Чёрча, чем к функциональному яп современного мира.

Эрланг это для профессоров, а Рефал ближе к народу, это нормальные алгорифмы Маркова. Функциональным его называют, вероятно, что бы не шокировать знатоков тезиса Чёрча-Тьюринга.

Ответить | Правка | Наверх | Cообщить модератору

201. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 31-Май-24, 15:39 
> Это сахар над

А вот тут я думаю "ошибка", как может (должен ли) НАМ содержать в себе "сахар"? В нем нет необходимости, это же лишнее "переписывание" (подстановки).

> Сопоставление происходит в той функции, где имя данной встречается в образце.

это же "неявно", и как можно использовать что-либо "неявное" для формального определения. Помимо "сахара" к ним можно отнести и "built-in"-ы.

> Турчин сделал Рефал, что бы вот такое не писать, а описывать на
> Рефале. Не знаю, какой смайлик тут ставить. %)

Ну и какой тип грамматики тогда? Разве не второй (контекстно-свободная), как и БНФ?

https://ru.wikipedia.org/wiki/%D0%A4%D0%...

Вот тут https://habr.com/ru/articles/682972/ обсуждение, и задались вопросом, "а не тоже самое ли это, что и ТМ или лямда Черча". Ну вот чем "перепись" (правила подстановки) отличаются от таблиц состояний (переходов) той же ТМ?

> Диалект.
> Скорее, опытный образец.

Ясно.

> Весь язык в книге Турчина на страницах 3 и 4. Паттерн идёт
> до знака равенства и может быть пуст. может содержать цифры, буквы,
> идентификаторы (имена функций) и структурные скобки (для группировки данных, должны быть
> парными) - если образец совпадает с аргументами, тогда вычисляется идущее после
> =, иначе смотрится следующее предложение. Ещё могут встречаться переменные, куда попадают
> оставшиеся данные.

Я к тому, что привели неполное БНФ определение в книге.

> Я хочу понять, почему Турчин и последователи такое не сделали, когда само
> напрашивается и в строчках кода цена копеечная. У меня, например, вложенные
> блоки пока не поддерживаются: заметно усложнят раскрутку стека переменных в интерпретаторе,
> а его декомпозицию раньше времени делать не хочется.

Я думаю в виду неявности.

ноль "0";
один "1";
_2-e { ноль; один }

тип {
  _2-e = _2-e;
}

неявно развернется в

type {
  "0" = _2-e;
  "1" = _2-e;
}


> а Рефал ближе к народу, это нормальные алгорифмы Маркова.

НАМ - это правила подстановок (не вычислений), а Рефал это именно функциональный ЯП, там же есть определение функции.

Ответить | Правка | Наверх | Cообщить модератору

204. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 31-Май-24, 17:56 
>> Это сахар над
> А вот тут я думаю "ошибка", как может (должен ли) НАМ содержать
> в себе "сахар"? В нем нет необходимости, это же лишнее "переписывание"
> (подстановки).

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

В случае вычислимых функций мне так проще писать и больше похоже на курс математики.

x = 1; // эта функция "вычисляется" и вернёт 1, если ей не передавать аргументы.

>> Сопоставление происходит в той функции, где имя данной встречается в образце.
> это же "неявно", и как можно использовать что-либо "неявное" для формального определения.
> Помимо "сахара" к ним можно отнести и "built-in"-ы.
>> Турчин сделал Рефал, что бы вот такое не писать, а описывать на
>> Рефале. Не знаю, какой смайлик тут ставить. %)
> Ну и какой тип грамматики тогда? Разве не второй (контекстно-свободная), как и
> БНФ?
> https://ru.wikipedia.org/wiki/%D0%A4%D0%...
> Вот тут https://habr.com/ru/articles/682972/

rule Q [ * C m dT ]
rule C 4200
rule m 5
rule dT 20

print Q

У него * каким-то хитрым образом оказалось определено. В Рефале это часть библиотеки. Можно сделать, что бы перемножало больше 2-х множителей, но пока только 2, потому приходится определять ещё одно умножение:

mul {
   ?1 ?2     = <?1 * ?2>;
   ?1 ?2 ... = <<?1 * ?2> mul ...>;
}

Q = (<mul <C>  <m> <dT>>); // скобки () не нужны, добавлены, поскольку это аналог []
C = 4200;
m = 5;
dT = 20;

go = <Q>;

По-моему, = понятнее. <> только мозолят глаз, это вызов функций (или применение правил). Без них можно примерно так:

Q2 = (mul C m dT);
subst {
  ?     = <Mu ?>;            
  ? ... = <Mu ?> <subst ...>; // Mu вызывает 1-ю функцию из списка
}
apply (?a ...) = <Mu ?a <subst ...>>;

go = <apply <Q2>>;

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

Вернее было бы передать в программу на Рефале задачу прямо в текстовом виде, что бы по образцам ("кг", "Дж/кг×°C") найти рядом значения и посчитать:


теплообмен
  .1 "масс"        .2 " " .масса        " кг"
  .3 "теплоёмкост" .4 " " .теплоёмкость " Дж/кг×°C"
  .5 "на "                .нагрев       "°C" ...
    = <* <* <Numb .масса> <Numb .теплоёмкость>> <Numb .нагрев>>;
начало = <теплообмен "Воде, массой 5 кг и теплоёмкостью 4200 Дж/кг×°C, сообщили теплоту. В результате её температура изменилась на 20°C.">;

Ветвлений в Рефале "нет", поскольку они происходят при выборе подходящего образца.

И там дальше принимаются вводить массу ключевых слов, а в Рефале их по сути нет, только знаки препинания.

> обсуждение, и задались вопросом, "а не тоже
> самое ли это, что и ТМ или лямда Черча". Ну вот
> чем "перепись" (правила подстановки) отличаются от таблиц состояний (переходов) той же
> ТМ?

Так это должно быть очевидно из тезиса Чёрча-Тьюринга. Почему-то к ним приписали третьим физика Дойча, хотя следовало бы Маркова - всё таки по НАМ есть ЯП, а по "Теории Всего" Дойча пока только Elden Ring.

>> Диалект.
>> Скорее, опытный образец.
> Ясно.
>> Весь язык в книге Турчина на страницах 3 и 4. Паттерн идёт
>> до знака равенства и может быть пуст. может содержать цифры, буквы,
>> идентификаторы (имена функций) и структурные скобки (для группировки данных, должны быть
>> парными) - если образец совпадает с аргументами, тогда вычисляется идущее после
>> =, иначе смотрится следующее предложение. Ещё могут встречаться переменные, куда попадают
>> оставшиеся данные.
> Я к тому, что привели неполное БНФ определение в книге.

Как было http://refal.ru/rf5_frm.htm так и скопировал в pdf.

>[оверквотинг удален]
> один "1";
> _2-e { ноль; один }
> тип {
>   _2-e = _2-e;
> }
> неявно развернется в
> type {
>   "0" = _2-e;
>   "1" = _2-e;
> }

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

тип {
  {"0"; "1"} = _2-e;
}

поддержать несложно, и теперь уже, наверное, нужно.

>> а Рефал ближе к народу, это нормальные алгорифмы Маркова.
> НАМ - это правила подстановок (не вычислений), а Рефал это именно функциональный
> ЯП, там же есть определение функции.

Так и в Си есть определения функций. Рефал подставляет так: в примере "теплообмен" переменные .масса  .теплоёмкость и .нагрев принимают подходящие значения и подставляются в результат, после чего для них вызываются функции Numb и подставляют вместо текстового представления целые числа, остальное откидывается.

Ответить | Правка | Наверх | Cообщить модератору

211. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 01-Июн-24, 01:13 
> Так это должно быть очевидно из тезиса Чёрча-Тьюринга. Почему-то к ним приписали
> третьим физика Дойча, хотя следовало бы Маркова - всё таки по
> НАМ есть ЯП, а по "Теории Всего" Дойча пока только Elden
> Ring.

покопался по вики и наткнулся на

https://en.wikipedia.org/wiki/Semi-Thue_system

странно, что нет русской версии этой страницы, далее

https://en.wikipedia.org/wiki/Abstract_rewriting_system

и в конце вот эта

https://en.wikipedia.org/wiki/Word_problem_(mathematics)

у которой тоже нет русской версии, и расставлет все "точки над И" в вопросе - "хотя следовало бы Маркова".

1914: Axel Thue poses the word problem for finitely presented semigroups.

1947: Emil Post and Andrey Markov Jr. independently construct finitely presented semigroups with unsolvable word problem.[14][15] Post's construction is built on Turing machines while Markov's uses Post's normal systems.[3]

SRS (string rewriting system) как я понял ввел Thue для попытки разрешения Word problem. НАМ и есть та самая SRS.

> Как было http://refal.ru/rf5_frm.htm так и скопировал в pdf.

Так предъява не вам, а к оригиналу :) Там местами ошибки есть, и картинка 1.1 неправильная где

(A + B) * (C + D)


> Вот такую запись:
> тип {
>   {"0"; "1"} = _2-e;
> }
> поддержать несложно, и теперь уже, наверное, нужно.

СТОП:

Почему должно разворачиваться в

type {
   "0" = _2-e;
   "1" = _2-e;
}

Это ведь не сматчится ни с первым ни со вторым правилом.

> и подставляют вместо текстового представления целые числа

ну а как представлены эти числа? Тут:

https://ru.wikipedia.org/wiki/%D0%9A%D0%...

они представлены как функция. А в случае с НАМ это часть алфавита. И приходится его расширять, а расширяя мы получаем современный функциональный ЯП. Вон добавили юникод в Рефал, а как - расширив алфавит.

Ответить | Правка | Наверх | Cообщить модератору

215. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 01-Июн-24, 11:58 
>> Так это должно быть очевидно из тезиса Чёрча-Тьюринга. Почему-то к ним приписали
>> третьим физика Дойча, хотя следовало бы Маркова - всё таки по
>> НАМ есть ЯП, а по "Теории Всего" Дойча пока только Elden
>> Ring.
> покопался по вики и наткнулся на
> https://en.wikipedia.org/wiki/Semi-Thue_system
> странно, что нет русской версии этой страницы, далее

Потому что не надо никому. Турчин жил в эпоху, когда здесь началось кукурузозамещение. Той политики партии поныне в большинстве своём и придерживаются. Все должны знать английский™, а уж способные понять вон то - тем более. Иначе в обмен на кого будут дарить исходники?

>[оверквотинг удален]
> и в конце вот эта
> https://en.wikipedia.org/wiki/Word_problem_(mathematics)
> у которой тоже нет русской версии, и расставлет все "точки над И"
> в вопросе - "хотя следовало бы Маркова".
> 1914: Axel Thue poses the word problem for finitely presented semigroups.
> 1947: Emil Post and Andrey Markov Jr. independently construct finitely presented semigroups
> with unsolvable word problem.[14][15] Post's construction is built on Turing machines
> while Markov's uses Post's normal systems.[3]
> SRS (string rewriting system) как я понял ввел Thue для попытки разрешения
> Word problem. НАМ и есть та самая SRS.

Так это совсем неудобно получается? Thue надобно первым писать, а уж затем Чёрча с Тьюрингом. Очень неудобные вопросы возникают. Как так вышло, что в какой-то дремучей стране смогли ту идею хоть как-то развить, в отличие от лидеров.

>> Как было http://refal.ru/rf5_frm.htm так и скопировал в pdf.
> Так предъява не вам, а к оригиналу :) Там местами ошибки есть,
> и картинка 1.1 неправильная где
> (A + B) * (C + D)

Спасибо.

>[оверквотинг удален]
>> тип {
>>   {"0"; "1"} = _2-e;
>> }
>> поддержать несложно, и теперь уже, наверное, нужно.
> СТОП:
> Почему должно разворачиваться в
> type {
>    "0" = _2-e;
>    "1" = _2-e;
> }

Оно не развернётся в два предложения, но результат будет одинаков. По правилам Рефал смотрит образец в первом предложении, если не походит, тогда следующее и т.д. В новой записи получается, что у одного предложения два образца. Проверяются по тем же правилам: первый, второй, ...

> Это ведь не сматчится ни с первым ни со вторым правилом.

ноль "0";
один "1";
_2-e { ноль; один }

тип {
  _2-e = _2-e;
}

вместо _2-e слева от = выполнена подстановка { ноль; один } и при этом вместо ноль и один подставлены "0" и "1". Справа от = _2-e ничем не заменяется (для этого требовались бы <> и наличие = в определении _2-e).

>> и подставляют вместо текстового представления целые числа
> ну а как представлены эти числа? Тут:
> https://ru.wikipedia.org/wiki/%D0%9A%D0%...
> они представлены как функция.

Числа это обычный uint64_t (в оригинале у Турчина последовательность uint32_t, то есть длинная арифметика; мне пока не понятно, надо ли такое). Если на самом Рефале реализовать арифметику, то получится громоздко и считать будет долго. Потому арифметика пишется функциями на Си.

> А в случае с НАМ это часть алфавита.

При этом 0 и "0" не одно и тоже. Вот https://github.com/STrusov/refal-machine/blob/master/Примеры/арифметика.реф
пример вычислений где

всецифры = "Z" "I" "2" "3" "4" "5" "6" "7" "8" "9";

> И приходится его расширять, а расширяя мы получаем современный функциональный ЯП.
> Вон добавили юникод в Рефал, а как - расширив алфавит.

Там академичный подход, вот они и расширяли алфавит год. Я показал Рефал одному программисту на баш (в хорошем смысле этого слова, и знает Perl), так он, привыкший к консоли, сходу выдал "это же можно сделать так, что бы мышкой составлять все эти функции?" Кому-то Рефал понятнее, если воспринимать его императивно, а значит для большинства проще функциональных ЯП.

Ответить | Правка | Наверх | Cообщить модератору

220. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 01-Июн-24, 13:18 
> Потому что не надо никому.

А ничего и не изменилось с тех пор, ну хоть не убили!

> Так это совсем неудобно получается? Thue надобно первым писать, а уж затем
> Чёрча с Тьюрингом. Очень неудобные вопросы возникают.

Вот, честно, я вообще не понимаю этой ереси с "именными" теоремами (гипотезами) и т.д. Из-за этого возникакают вот такие неудобные вопросы. Но математика не для самодуров. Имена, даты - важны в контексте истории, их надо помнить не отрицаю, но математика и без имен и дат этих существует. В случае кого "надобно первым писать" зависит от контекста, кто какую перед собой задачу ставил и какую проблему решал. Таким макаром надо первым туда пихнуть Гильберта, ибо эт он во всем виноват, своим формализмом всея вокруг (обмазать). Я противник этой ереси, для меня важно исторически знать вклад каждого в данный вопрос даже и не очень важно хронологически (вопрос кто первый - это же во вред всегда, история Лейбница и Ньютона, печальная история с Перельманом).

> Как так вышло, что
> в какой-то дремучей стране смогли ту идею хоть как-то развить, в
> отличие от лидеров.

Таким макаром можно и говорить, почему математики прошедших вермен начинались на Аль-... и теперь вообще ни одного, и страны, не дремучие тогда, щас пни (пень).

> Оно не развернётся в два предложения, но результат будет одинаков.

Да, все правильно, меня замкнуло.


> ноль "0";
> один "1";
> _2-e { ноль; один }
> тип {
>   _2-e = _2-e;
> }
> вместо _2-e слева от = выполнена подстановка { ноль; один } и
> при этом вместо ноль и один подставлены "0" и "1". Справа
> от = _2-e ничем не заменяется (для этого требовались бы <>
> и наличие = в определении _2-e).

Вот кстати пропустил момент, справа от = там нет <> (вызова функции), но почему тогда _2-e не в кавычках? Это же просто получается строка.

тип {
   _2-e = "_2-e";
}

> Если на самом Рефале реализовать арифметику, то получится громоздко и считать будет долго.
> Потому арифметика пишется функциями на Си.

Тоже самое и про кодирование Черча:

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

>> А в случае с НАМ это часть алфавита.
> При этом 0 и "0" не одно и тоже.

Потомучто два разных слова 0 (1 символ) и "0" - три символа, " - кавычка ведь тоже часть алфавита. И все зависит от выбранных правил (грамматики). Кстати, к вопросу грамматики, НАМ все же к какому типу (по ерархии Хомского) грамматик относится?

> "это же можно сделать так, что бы мышкой составлять все эти функции?"

в отличии от всяких ЯП с goto :)

> Кому-то Рефал
> понятнее, если воспринимать его императивно, а значит для большинства проще функциональных
> ЯП.

Зависит от восприятия, детям ведь унарная арифметика понятнее чем десятичная. Эт как всю жизнь читал текста слева направо, а теперь изучаешь какой-нибудь язык из семитской группы.

Ответить | Правка | Наверх | Cообщить модератору

226. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 01-Июн-24, 17:05 
>> Потому что не надо никому.
> А ничего и не изменилось с тех пор, ну хоть не убили!

Изменилось не так давно. Торговцы имеют смысл, когда надо привезти вагон муки, складировать и так далее - они честно зарабатывают свою долю. Для доставки ПО всё это не требуется, даже компакт-диски отмерли. Весь этот симулякр с упаковкой отомрёт, как только RedHat, а за ним и Debian обеспечат воспроизводимые сборки. Исходники ведь безопасны, так нас учат дистрибуторы? :) И народ созревает, покупает СтимДек и спрашивает, как поставить игрушки с торрентов.

>> Так это совсем неудобно получается? Thue надобно первым писать, а уж затем
>> Чёрча с Тьюрингом. Очень неудобные вопросы возникают.
> Вот, честно, я вообще не понимаю этой ереси с "именными" теоремами (гипотезами)

Нет понимания, потому что у математиков и коммерсантов все ценности диаметрально противоположны. Жители США исходно умели строить фигвам, всё остальное там создали понаехавшие. В том числе и схемки для привлечения новых талантов. В общем случае должны быть: 1) отличная от нуля вероятность перемещения; 2) разность потенциалов.

> и т.д. Из-за этого возникакают вот такие неудобные вопросы. Но математика
> не для самодуров. Имена, даты - важны в контексте истории, их
> надо помнить не отрицаю, но математика и без имен и дат
> этих существует. В случае кого "надобно первым писать" зависит от контекста,
> кто какую перед собой задачу ставил и какую проблему решал. Таким
> макаром надо первым туда пихнуть Гильберта, ибо эт он во всем
> виноват, своим формализмом всея вокруг (обмазать). Я противник этой ереси, для
> меня важно исторически знать вклад каждого в данный вопрос даже и
> не очень важно хронологически (вопрос кто первый - это же во
> вред всегда, история Лейбница и Ньютона, печальная история с Перельманом).

Мне в этом плане интересно, что лямбда Чёрча - это хорошо и правильно, когда функции чистые, но в лучшем случае 1% всего населения имеет способность её понять. И из тех добрая половина читает проповеди о чистоте души, а вторая вычисляет превращение гелия в тритий. В большинстве своём люди мыслят предметно и потому имеем, что почти всё написано на императивных языках, со всеми вытекающими. Если Турчин хотел от Рефала суперкомпиляцию, то мне кажется, что это некий компромисс. ну и опять же - может оказаться понятнее соотечественникам Маркова.

>> Как так вышло, что
>> в какой-то дремучей стране смогли ту идею хоть как-то развить, в
>> отличие от лидеров.
> Таким макаром можно и говорить, почему математики прошедших вермен начинались на Аль-...
> и теперь вообще ни одного, и страны, не дремучие тогда, щас
> пни (пень).

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

>[оверквотинг удален]
>> вместо _2-e слева от = выполнена подстановка { ноль; один } и
>> при этом вместо ноль и один подставлены "0" и "1". Справа
>> от = _2-e ничем не заменяется (для этого требовались бы <>
>> и наличие = в определении _2-e).
> Вот кстати пропустил момент, справа от = там нет <> (вызова функции),
> но почему тогда _2-e не в кавычках? Это же просто получается
> строка.
> тип {
>    _2-e = "_2-e";
> }

"_2-e" это строка из 4-х символов, а _2-е это идентификатор (технически, ссылка на байткод функции). Когда оно выводится для человека, нет особой разницы, что возвращать, можно и в кавычках (у меня в консоли различаются цветом, но это наверное надо сделать отключаемым). Если же результат передавать в другую функцию, то матчиться будет по-разному. Строку можно разобрать на символы, склеить и т.п, а идентификатор в виде текста оказывается только при выводе.

>> Если на самом Рефале реализовать арифметику, то получится громоздко и считать будет долго.
>> Потому арифметика пишется функциями на Си.
> Тоже самое и про кодирование Черча:
> """
> Кодировка Черча, как правило, не используется для практической реализации примитивных
> типов данных.
> """

В функциональных языках функции обычно объекты первого класса, их можно вернуть из другой функции как значение. В Рефале возвращается ссылка. Можно сконструировать скобочками замыкание, но по возможностям оно примитивно по сравнению с обычными функциями.

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

Вот такое способ работы с файлами:

<Open 'r' 3 "файл">
<
<Close 3>

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

>>> А в случае с НАМ это часть алфавита.
>> При этом 0 и "0" не одно и тоже.
> Потомучто два разных слова 0 (1 символ) и "0" - три символа,
> " - кавычка ведь тоже часть алфавита. И все зависит от
> выбранных правил (грамматики).

Кавычка есть только в исходнике и на уровне лексера. В обрабатываемых данных и то и то 1 элемент (ячейка памяти). Такая ячейка помещается в т.н. s-переменную.

Когда s-переменная стоит в начале образца, в неё попадёт первый элемент данных (кроме скобок).

f {
  s.1 e.1 = <Print s.1>; // подставит в результат первый символ строки, зхатем его выведет Print.
}

> Кстати, к вопросу грамматики, НАМ все же к
> какому типу (по ерархии Хомского) грамматик относится?

Здесь https://cmcmsu.info/download/formal.grammars.and.languages.2... на стр 10 пишут, что тип 0.

>> "это же можно сделать так, что бы мышкой составлять все эти функции?"
> в отличии от всяких ЯП с goto :)

У меня как раз в этом Рефале транслятор был изначально в 1000 строк из которых треть goto. :) Т.е. это достаточно простой язык, что бы вот так написать почти без ошибок.

>> Кому-то Рефал понятнее, если воспринимать его императивно,
>> а значит для большинства проще функциональных ЯП.
> Зависит от восприятия, детям ведь унарная арифметика понятнее чем десятичная. Эт как
> всю жизнь читал текста слева направо, а теперь изучаешь какой-нибудь язык
> из семитской группы.

Это скорее когнитивная ригидность. А восприятие Мичиганского рыбного теста у разных народов разное https://garbuzenko.livejournal.com
На западе как раз всё свелось к однострочным функциям без комментариев в Clean Code.

Ответить | Правка | К родителю #220 | Наверх | Cообщить модератору

231. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 01-Июн-24, 23:22 
> а _2-е это идентификатор (технически, ссылка
> на байткод функции).

Базисном Рефале просто этого нет:

right-side ::= expression

expression ::= empty
               term expression

term ::= symbol
         variable  
         (expression)
         <f-name expression>

f-name ::= identifier

empty ::=

> (у меня в консоли различаются цветом, но это наверное надо сделать отключаемым). Если же результат передавать
> в другую функцию, то матчиться будет по-разному.

left-side = <f-name _2-е> - так ведь нельзя передавать, надо так ведь <f-name <_2-е>>

или в вашем диалекте разрешено передавать идентификатор в качестве аргумента?


> Как раз с этим у меня самый затык. Вернуть как результат байт-код
> сгенерированной функции несложно.

анонимную функцию? функцию без явного идентификатора?

> Но если эта функция делает что-то полезное, вроде
> чтения файла, то в какой-то момент потребуется описатель файла закрыть. Обычно
> это делает сборщик мусора, но в Рефале все данные хранятся в
> двусвязном списке и "сами" освобождаются, когда больше не требуются. Когда мегабайт
> освобождается за О(1) очень не хочется весь этот список просматривать на
> наличие описателя.

ну надо какой нить "сахар" добавить в определение функции, чтобы запрещать вызов конкретных функций в анонимных (безидентификаторных) функциях, корочь ересь :)

> Вот такое способ работы с файлами:
> <Open 'r' 3 "файл">
> <
> <Close 3>
> наверняка и есть одна из причин, почему язык не пошёл. Лямбды как
> раз пригодились бы, а там пусть функциональным называется. :)

Вот мне непонятно откуда блин взялось это понятие, всегда что-либо надо открыть, сделать дело, закрыть. Почему сразу нельзя сделать дело? Что значит открыть файл? Почему не сразу прочти или запиши по адресу. Мы же не открываем ячейки на ленте Тьюринга, а после записи символа закрываем.

> Здесь https://cmcmsu.info/download/formal.grammars.and.languages.2... на стр
> 10 пишут, что тип 0.

ясно

> Это скорее когнитивная ригидность. А восприятие Мичиганского рыбного теста у разных народов
> разное https://garbuzenko.livejournal.com
> На западе как раз всё свелось к однострочным функциям без комментариев в
> Clean Code.

Тема хорошая, вот появился термин "когнитивной слепоты", а вот что с "когнитивной глухотой"? ведь музыка русских композиторов (всех я даже сказал) высоко ценится на условном западе.

Есть такое наивное рассуждение, что глазное зрение эт орган истины (очевидное - очам видно, то есть от Бога), а вот на ухо шепчет (информация воспринимаемая органами слуха) лукавый (черт) в основном ложь. Отсюда если существует "когнитивная слепота", и не существует "когнитивной глухоты", то наивное утверждение совсем не истинно. :)

Ответить | Правка | К родителю #226 | Наверх | Cообщить модератору

232. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 02-Июн-24, 15:16 
>[оверквотинг удален]
> right-side ::= expression
> expression ::= empty
>            
>    term expression
> term ::= symbol
>          variable
>          (expression)
>          <f-name expression>
> f-name ::= identifier
> empty ::=

Да, в Базисном Рефале этого нет. Я и писал, что мне непонятно, почему нет. Добавить проще, чем условия и вложенные блоки после =

>> (у меня в консоли различаются цветом, но это наверное надо сделать отключаемым). Если же результат передавать
>> в другую функцию, то матчиться будет по-разному.
> left-side = <f-name _2-е> - так ведь нельзя передавать, надо так ведь
> <f-name <_2-е>>

Сам по себе идентификатор это часть алфавита. Определили - расширили алфавит. К предопределённым "0" и 0 добавили ещё и Ноль. Если при определении задано тело функции и в её предложениях есть =, то вычислительный скобочки <> такую функцию вызывают. Вызов <_2-е> приведёт к ошибке "отождествление невозможно", поскольку предложения в _2-е содержат лишь образцы. У меня это определяется на стадии трансляции (выводится "активное выражение должно содержать имя вычислимой функции"), но интерпретатор всё равно запускается.

> или в вашем диалекте разрешено передавать идентификатор в качестве аргумента?

Так же и в Базисном Рефале. Пока нет <>, функции не вызываются. Можно идентификатор передать аргументом в функцию Mu, она вызовет функцию по имени (идентификатору, или определённому текстовой строкой в кавычках).

>> Как раз с этим у меня самый затык. Вернуть как результат байт-код
>> сгенерированной функции несложно.
> анонимную функцию? функцию без явного идентификатора?

Идентификатор представляет собой номер ячейки с байт-кодом функции. Если байткод сгенерировать во время исполнения, то идентификатор для неё появится - это не проблема. Если вернуть сам идентификатор (то есть ссылку), то потребуется отслеживать эту ссылку для сборки мусора, иначе можно нагенерировать 100500 функций в рекурсивном вызове и завершится память. Если вернуть функцию "по значению", то есть бай-код её тела, то мусор соберётся сам собой, как только такая функция выйдет из поля зрения. Генерация происходит за O(n) в обоих случаях. Удаление - за O(1) во втором.

>> Но если эта функция делает что-то полезное, вроде
>> чтения файла, то в какой-то момент потребуется описатель файла закрыть. Обычно
>> это делает сборщик мусора, но в Рефале все данные хранятся в
>> двусвязном списке и "сами" освобождаются, когда больше не требуются. Когда мегабайт
>> освобождается за О(1) очень не хочется весь этот список просматривать на
>> наличие описателя.
> ну надо какой нить "сахар" добавить в определение функции, чтобы запрещать вызов
> конкретных функций в анонимных (безидентификаторных) функциях, корочь ересь :)

Так вот как раз лямбды обретают практический смысл, если при их создании вызвать эти конкретные функции, и захватить результат вызова. Так то можно и именованную функцию передать в Map или Apply. Можно и нагородить замыкание из круглых скобочек, будет похоже на LISP.

>> Вот такое способ работы с файлами:
>> <Open 'r' 3 "файл">
>> <
>> <Close 3>
>> наверняка и есть одна из причин, почему язык не пошёл. Лямбды как
>> раз пригодились бы, а там пусть функциональным называется. :)
> Вот мне непонятно откуда блин взялось это понятие, всегда что-либо надо открыть,
> сделать дело, закрыть. Почему сразу нельзя сделать дело? Что значит открыть
> файл? Почему не сразу прочти или запиши по адресу. Мы же
> не открываем ячейки на ленте Тьюринга, а после записи символа закрываем.

Ядро ОС так устроено, со времён Керниганна и Риччи. При открытии создаётся объект ядра со ссылками на блоки в ФС. В пространство пользователя возвращается описатель (хендл), идентификатор того объекта. В принципе, разумно, коду пользователя было бы проще просто писать в файл, а эти объекты в ядре на первый взгляд можно кешировать, что бы не создавать каждый раз. Но возникает проблема с консистентностью, когда разные приложения пишут в один файл и какое-то из них хочет монопольный доступ. Как определить, что оно больше не будет записывать? Здесь нужны новые подходы, как в Фантом ОС, например.

>> Здесь https://cmcmsu.info/download/formal.grammars.and.languages.2... на стр
>> 10 пишут, что тип 0.
> ясно
>> Это скорее когнитивная ригидность. А восприятие Мичиганского рыбного теста у разных народов
>> разное https://garbuzenko.livejournal.com
>> На западе как раз всё свелось к однострочным функциям без комментариев в
>> Clean Code.
> Тема хорошая, вот появился термин "когнитивной слепоты", а вот что с "когнитивной
> глухотой"? ведь музыка русских композиторов (всех я даже сказал) высоко ценится
> на условном западе.

Другой канал ввода. Другие части мозга обрабатывают. Не такое значение имеет, как картина перед глазами. Кошки умеют выделять звуки, просыпаются от шороха или чириканья, когда рядом грохочет трактор и они спят.

> Есть такое наивное рассуждение, что глазное зрение эт орган истины (очевидное -
> очам видно, то есть от Бога), а вот на ухо шепчет
> (информация воспринимаемая органами слуха) лукавый (черт) в основном ложь. Отсюда если
> существует "когнитивная слепота", и не существует "когнитивной глухоты", то наивное утверждение
> совсем не истинно. :)

Когнитивной слепоты множество видов. За писателем текст вычитывает редактор и корректор. Когда "глаз замылился" и очевидное не видно, а на следующий день думаешь "как же так?" - это когнитивная слепота.

Ответить | Правка | К родителю #231 | Наверх | Cообщить модератору

236. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 02-Июн-24, 18:57 
> Я и писал, что мне непонятно,
> почему нет. Добавить проще, чем условия и вложенные блоки после =

Может сохранение "чистоты"? Сайд эффекты появятся ведь.

> Вызов <_2-е> приведёт к ошибке "отождествление
> невозможно", поскольку предложения в _2-е содержат лишь образцы.

Так ведь нет понятия "безаргументной" функции, <_2-е> - это не равносильно вызову с пустым аргументом?

> Если вернуть функцию "по значению", то

А там лишнего копирования не будет? А сайд эффекты? В итоге не получится что-то вроде монады?


> Здесь нужны новые подходы,
> как в Фантом ОС, например.

Идеи Завалишина еще дадут о себе знать.

> Когнитивной слепоты множество видов. За писателем текст вычитывает редактор и корректор.
> Когда "глаз замылился" и очевидное не видно, а на следующий день
> думаешь "как же так?" - это когнитивная слепота.

Эта ошибка, которую он "проглядел" по сути "не произнесенное про себя слово", мы не понимаем написанный текст просто водя по нему глазами, мы обязательно про себя произносим звуки распознавая символы текста. И выходит, что не глаза являются органом осмысления, а внутренний слух. Глаза просто "выделятор", мозг потом матчит со "звуком", "звук" мозгом произносится, и внутреннее ухо слышит его, и уже слуховая подсистема мозга маппит смысл. :)

Ответить | Правка | К родителю #232 | Наверх | Cообщить модератору

237. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 03-Июн-24, 12:07 
>> Я и писал, что мне непонятно,
>> почему нет. Добавить проще, чем условия и вложенные блоки после =
> Может сохранение "чистоты"? Сайд эффекты появятся ведь.

Нет там побочных эффектов, в образце появляется ссылка на другие образцы. И реализуется так же просто: если есть ссылка, то смотрится образец, на который она ссылается. М.б. Турчин не хотел, что бы кому-то пришла идея развить это дальше, до вычисления (разрешить скобки <>) в образце, полагая такое ересью. Как раз об этом я теперь и думаю - вроде бы опять проще вложенных блоков и условий. :)

>> Вызов <_2-е> приведёт к ошибке "отождествление
>> невозможно", поскольку предложения в _2-е содержат лишь образцы.
> Так ведь нет понятия "безаргументной" функции, <_2-е> - это не равносильно вызову
> с пустым аргументом?

Равносильно. Аргументов в обычном понимании в Рефале нет. Есть поле зрения (ПЗ) - какой-то "список" данных, м.б. пустой. Если вызвать _2-е с пустым ПЗ, то у неё нет предложения с соответствующим образцом, что бы сматчить пустое ПЗ. В том числе поэтому она и не вызывается, а используется как символ алфавита, который раскрывается в другие символы.

>> Если вернуть функцию "по значению", то
> А там лишнего копирования не будет? А сайд эффекты? В итоге не
> получится что-то вроде монады?

Если генерировать функцию, то так или иначе надо где-то разместить её байт-код. Можно вернуть на него ссылку. Можно генерировать сразу там, где создаётся результат вызывающей функции. То есть лишнего копирования нет. В списочной реализации Рефала минимум лишних копирований: части списка перелинковываются из аргумента в результат. В простейших случаях, когда результат равен аргументу:

e. = e.; // . = .; в моём диалекте

вообще никаких изменений не происходит.

>> Здесь нужны новые подходы,
>> как в Фантом ОС, например.
> Идеи Завалишина еще дадут о себе знать.

Все эти докеры-шмокеры примерно в том направлении и движутся, если об этом призадуматься. Процесс (приложение) изолируется от остальных, включая часть файловой системы.

>> Когнитивной слепоты множество видов. За писателем текст вычитывает редактор и корректор.
>> Когда "глаз замылился" и очевидное не видно, а на следующий день
>> думаешь "как же так?" - это когнитивная слепота.
> Эта ошибка, которую он "проглядел" по сути "не произнесенное про себя слово",

Да, я так одну книжку прочёл, и лишь позже узнал, что главного героя зовут иначе.)

> мы не понимаем написанный текст просто водя по нему глазами, мы
> обязательно про себя произносим звуки распознавая символы текста. И выходит, что
> не глаза являются органом осмысления, а внутренний слух. Глаза просто "выделятор",
> мозг потом матчит со "звуком", "звук" мозгом произносится, и внутреннее ухо
> слышит его, и уже слуховая подсистема мозга маппит смысл. :)

На уходе от такой схемы основаны техники скорочтения. Форматирование исходного текста так же призвано ломать привычку, сдвигая детали в сторону. Блок-схемы, UML и ДРОКОН -всё это ставит целью ускорить понимание в целом, не углубляясь в детали.

Ответить | Правка | К родителю #236 | Наверх | Cообщить модератору

239. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 03-Июн-24, 14:09 
> до вычисления (разрешить скобки <>) в образце,
> полагая такое ересью.

динамический образец?

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

С такими правилами правая сторона должна быть без свободных переменных?

> Если вызвать _2-е с пустым
> ПЗ, то у неё нет предложения с соответствующим образцом, что бы
> сматчить пустое ПЗ. В том числе поэтому она и не вызывается,
> а используется как символ алфавита, который раскрывается в другие символы.

А не логично было бы, из-за того, что у функции нет формального определения аргумента(ов), неявным (если явно не задано правило) образом определять правило метчинга пустого образца, которое будет возвращать пустой результат в место ошибки "не метчинга ни с одним образцом". То есть поведение по умолчанию, если не задано иное правило метчинга пустого "аргумента".

fun {
   =  ; // по умолчанию
}

> В списочной реализации
> Рефала минимум лишних копирований: части списка перелинковываются из аргумента в результат.
> В простейших случаях, когда результат равен аргументу:
> e. = e.; // . = .; в моём диалекте
> вообще никаких изменений не происходит.

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

> Все эти докеры-шмокеры примерно в том направлении и движутся, если об этом
> призадуматься. Процесс (приложение) изолируется от остальных, включая часть файловой
> системы.

Ну вот приложение калькулятор есть необходимость значить что есть в системе там сетевая подсистема? Нет, но "взломав" калькулятор, мы же может взаимодествовать с сетью. В этом случае ОС как монолит - ересь. Единая физ память ОС и прилолжения - ересь и т.д. (все конечно с точки зрения современных реалий, безопасности)


> Да, я так одну книжку прочёл, и лишь позже узнал, что главного
> героя зовут иначе.)

:))

> На уходе от такой схемы основаны техники скорочтения.

Первоклашки не просто так читают в слух, и по слогам, в самом начале обучения.

Ответить | Правка | К родителю #237 | Наверх | Cообщить модератору

241. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 03-Июн-24, 19:11 
>> до вычисления (разрешить скобки <>) в образце,
>> полагая такое ересью.
> динамический образец?

Да, наверное так это следует называть. То есть результат вызова использовать в качестве (части) образца.

> """
> Имеются следующие важные ограничения на правую часть предложения: правая часть может включать
> только такие свободные переменные, которые входят также и в левую часть
> """

Не вполне точно называть ограничением. Смысл в том, что при обработке образца (левой части) в переменные "попадают" данные из аргумента функции (поля зрения). Когда переменная встречается в правой части, вместо неё подставляется значение. Если её нет слева, то что подставлять?

> С такими правилами правая сторона должна быть без свободных переменных?

Не понятно, почему возник такой вопрос. Образец будет обрабатываться как обычно, переменным присваиваться подходящие значения. Как только дело дойдёт до закрывающей скобки > - так будет вызвана функция, идентификатор которой находится между скобок <>. Если внутри скобок были переменные, то к этому моменту им уже присвоены значения. Соответственно, есть что подставлять в правую часть.

С таким вызовом возникает сложность из-за правил обработки e-переменных (произвольный размер) - в каких-то случаях может случиться откат влево по образцу, размер переменной увеличится на 1, и произойдёт очередная попытка сматчить. Может оказаться, что функция в образце вызывается многократно. Но в таких случаях и без того вычислительная сложность высока, их следует избегать, структурировать данные скобками ().

>[оверквотинг удален]
>> сматчить пустое ПЗ. В том числе поэтому она и не вызывается,
>> а используется как символ алфавита, который раскрывается в другие символы.
> А не логично было бы, из-за того, что у функции нет формального
> определения аргумента(ов), неявным (если явно не задано правило) образом определять правило
> метчинга пустого образца, которое будет возвращать пустой результат в место ошибки
> "не метчинга ни с одним образцом". То есть поведение по умолчанию,
> если не задано иное правило метчинга пустого "аргумента".
> fun {
>    =  ; // по умолчанию
> }

Сейчас можно последним предложением ловить все неподходящие данные, ставить e-переменную в образце:

fun {
1 = <Prout "да">;
0 = <Prout "нет">;
. = <Prout "не знаю: " . >;
}

Если в функции что-то не определено в образцах, может быть программист ошибся, забыл? Как эту ситуацию определить?

Существуют диалекты Рефала, где вместо останова исполнителя с ошибкой возвращается что-то условленное, что можно обработать. У меня технически возвращается идентификатор функции и образец, который она не смогла распознать, но на этом исполнитель останавливается. Можно изменить поведение, и возвращать например в структурных скобках: (fun бесполезные "аргументы"). Наверное, такое было бы полезно, если бы Рефал использовался как интерпретатор командной строки и можно было бы исправить что-то и вызвать повторно. Когда исполняется программа из файла, пока не совсем понятно, что с этим делать: оно и дальше будет вызывать ошибку распознавания. При этом восстановить аргументы вызывающих функций проблематично, они уже переработаны.

По поводу отсутствия сигнатур функций - это вообще отдельная интересная тема. Автор Рефал-5-Лямбда формализует их в комментариях, наверное с расчётом их анализировать. Турчин же работал над "суперкомпиляцией". Хотел определять все возможные варианты входных данных, строить граф вызовов и как-то это просчитывать. В принципе ведь, возможные аргументы формализованы образцами в предложениях функции. Другое дело, что во время исполнения может прийти неведомо что.

>> В списочной реализации
>> Рефала минимум лишних копирований: части списка перелинковываются из аргумента в результат.
>> В простейших случаях, когда результат равен аргументу:
>> e. = e.; // . = .; в моём диалекте
>> вообще никаких изменений не происходит.
> В принципе надо пробывать, представьте, что каждый допустим символ аргумента определяет
> динамически образец для сопоставления следующего :)

Примерно так и есть с условиями и блоками в расширенном Рефале. Но там появляются дополнительно спецсимволы , (запятая) и : (двоеточие). Я такую запись как-то не очень воспринимаю. Функции в базовом Рефале похожи на систему уравнений из школьного курса (если не считать <>) и по виду и по смыслу.

>> Все эти докеры-шмокеры примерно в том направлении и движутся, если об этом
>> призадуматься. Процесс (приложение) изолируется от остальных, включая часть файловой
>> системы.
> Ну вот приложение калькулятор есть необходимость значить что есть в системе там
> сетевая подсистема? Нет, но "взломав" калькулятор, мы же может взаимодествовать с
> сетью. В этом случае ОС как монолит - ересь. Единая физ
> память ОС и прилолжения - ересь и т.д. (все конечно с
> точки зрения современных реалий, безопасности)

Именно это достаточно просто ограничить в современных ОС, отфильтровав системные вызовы. С файловой системой всё сложнее, нужно хотя бы что-то типа подтомов ZFS/BtrFS для каждого приложения, которому требуется что-то писать в файлы. И ФС это не просто структуры данных на блочном устройстве, на всё это завязаны менеджер памяти, таблица страниц. Оракловскую ZFS не смогли интегрировать в ядро Linux, прикрутили сбоку изолентой.

>> Да, я так одну книжку прочёл, и лишь позже узнал, что главного
>> героя зовут иначе.)
> :))
>> На уходе от такой схемы основаны техники скорочтения.
> Первоклашки не просто так читают в слух, и по слогам, в самом
> начале обучения.

Потому что так учат. В классе имеет смысл, поскольку кто-то читает лучше и остальные за ними тянутся. Я таблицу умножения не учил почти в школе, до этого игрался с калькулятором, тыкал кнопочки без понимания, оно как-то запомнилось. Вот тот скринсейвер из х/ф "Матрица", когда разные цифры мелькают на экране - он в СССР имел практический смысл. Были такие тесты на профпригодность, считали там нули, например.

Ответить | Правка | К родителю #239 | Наверх | Cообщить модератору

243. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 03-Июн-24, 20:17 
> Если её нет слева, то что подставлять?

Ну выходит, результат вызова функции-образца - это своего рода константа будет, а переменные в правой части можно использовать только когда они явно есть в левой части (в образце). Я к тому, что не будет ситуации, чтобы функция возвращала образец как результат, содержащий свободные переменные. Хотя говорите байт-код, думаю и это возможно, но это будет жутко нелогично и не явно.

Пример псевдокодом:

funA {
<funB> = s.A  
}

funB возвратила неявно образец с переменной А, но данные в эту переменную попадают в области функции funA, хотя логично как указал выше, что они попали бы в funB, и тогда бы возвращалсябы константный образец, и в funA необходимости в переменной A отпадает. Короч, надо думать.

> Не понятно, почему возник такой вопрос. Образец будет обрабатываться как обычно, переменным
> присваиваться подходящие значения.

Пример выше разве допустим будет?

> Если внутри скобок были переменные, то к этому моменту им уже
> присвоены значения. Соответственно, есть что подставлять в правую часть.

funA {
<funB s.A> = s.A  
}

s.A в конексте funA заполнятся (присваивается) так ведь?

> Если в функции что-то не определено в образцах, может быть программист ошибся,
> забыл? Как эту ситуацию определить?

Поведение по-умолчанию я предусматривал к безаргументному вызову (с пустым аргументом). Если просто вызывать функцию (без аргумента), то она возвращает пустоту. А если вызвал с аргументом и там уже что-то не сматчилось, то это в любом случае ошибка сопоставления. То есть правило матчинга пустого только аргумента, может матчится по дефолту.

> Существуют диалекты Рефала, где вместо останова исполнителя с ошибкой возвращается что-то
> условленное, что можно обработать. У меня технически возвращается идентификатор функции
> и образец, который она не смогла распознать, но на этом исполнитель
> останавливается. Можно изменить поведение, и возвращать например в структурных скобках:
> (fun бесполезные "аргументы"). Наверное, такое было бы полезно, если бы Рефал
> использовался как интерпретатор командной строки и можно было бы исправить что-то
> и вызвать повторно. Когда исполняется программа из файла, пока не совсем
> понятно, что с этим делать: оно и дальше будет вызывать ошибку
> распознавания. При этом восстановить аргументы вызывающих функций проблематично, они
> уже переработаны.

Все зависит уже от назначения этого ЯП, если для формальной верификации, то останов считаю лучше. Если для общего назначения, принцип "лет-ит-креш" (эрлангеновский) - ересь как по мне.

> По поводу отсутствия сигнатур функций - это вообще отдельная интересная тема. Автор
> Рефал-5-Лямбда формализует их в комментариях, наверное с расчётом их анализировать. Турчин
> же работал над "суперкомпиляцией". Хотел определять все возможные варианты входных данных,
> строить граф вызовов и как-то это просчитывать. В принципе ведь, возможные
> аргументы формализованы образцами в предложениях функции. Другое дело, что во время
> исполнения может прийти неведомо что.

Это же подобие одной и той же функции с разной арностью, как в эрленге, но и с ограничениями на сами аргументы (возможно guard-ы).

"""
Например, пусть исходный алгоритм — вычисление квадрата числа: square(x) => x * x. Для x = 0 можно получить более короткий и более быстрый вариант алгоритма, который просто возвращает ноль: square(0) => 0.
"""

В случае с эрлангом было бы что-то вроде этого:

square(x) when x==0 ->
return 0

Или просто без аргумента:

square() ->
return 0

> С файловой системой всё сложнее

Как говорится, пока петух не клюнет, ждем когда Линусу какой-нить ваннакрай зашифрует диск, после этого придем к осознанию, что нужна новая модель взаимодействия прикладного ПО с системой и ее ресурсами, принципа максимального изолирования.


> Были такие тесты на профпригодность, считали там нули, например.

Жесть, только глаза портить, эт как овец считать, чтобы заснуть? :)

Ответить | Правка | К родителю #241 | Наверх | Cообщить модератору

248. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 04-Июн-24, 11:59 
>> Если её нет слева, то что подставлять?
> Ну выходит, результат вызова функции-образца - это своего рода константа будет,

Да.

> переменные в правой части можно использовать только когда они явно есть
> в левой части (в образце).

Технически, переменная - это ссылка на какой-то элемент аргумента функции.

> Я к тому, что не будет
> ситуации, чтобы функция возвращала образец как результат, содержащий свободные переменные.
> Хотя говорите байт-код, думаю и это возможно, но это будет жутко
> нелогично и не явно.
> Пример псевдокодом:
> funA {
> <funB> = s.A
> }
> funB возвратила неявно образец с переменной А, но данные в эту переменную
> попадают в области функции funA

В принципе, такое можно реализовать. То есть вызов <funB> вернёт байт-код, который исполнитель поймёт как  

funA {
s.A = s.A
}

Проблема в том, что почему бы funB не вернуть s.B? Что с этим делать? При трансляции придётся проверять, что может возвращать funB. А если она вызывается ещё где-то? Гипотетически, возможно, но транслятор превратится из однопроходного в 600 строк в суперкомпилятор (по Турчину). Потому вместо этого в Расширенном Рефале используются вложенные блоки. Можно ещё подумать о таком синтаксисе:

funA {
<{ = s.A }> = s.A
}

Но здесь опять же нарушается логика Рефала, где в результатном выражении переменная принимает значение, полученное при просмотре образца.

Тогда надо как-то выделять случай, когда возвращается опкод переменной, а не присвоенное значение например:

funA {
<{ = [s.A] }> = s.A
}

> хотя логично как указал выше, что
> они попали бы в funB, и тогда бы возвращалсябы константный образец,
> и в funA необходимости в переменной A отпадает. Короч, надо думать.

То есть первая часть (попали бы в funB) вот так

funA {
s.A = <funB s.A>;
}

А вторая часть - дальше результат вызова передать следующей функции - примерно так:

funA {
s.A = <funC <funB s.A>>;
}

"""
Вообще, блок считается синтаксическим сахаром, и запись

Result : { …A… } : { …B… } : { …C… }

является эквивалентом для

<{ …C… } <{ …B… } <{ …A… } Result>>>

т.е. обычной композицией безымянных вложенных функций.

"""

https://github.com/bmstu-iu9/refal-5-lambda/tree/master?tab=...

>> Не понятно, почему возник такой вопрос. Образец будет обрабатываться как обычно, переменным
>> присваиваться подходящие значения.
> Пример выше разве допустим будет?

Нет. Теперь я понял.

>> Если внутри скобок были переменные, то к этому моменту им уже
>> присвоены значения. Соответственно, есть что подставлять в правую часть.
> funA {
> <funB s.A> = s.A
> }
> s.A в конексте funA заполнятся (присваивается) так ведь?

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

>> Если в функции что-то не определено в образцах, может быть программист ошибся,
>> забыл? Как эту ситуацию определить?
> Поведение по-умолчанию я предусматривал к безаргументному вызову (с пустым аргументом).
> Если просто вызывать функцию (без аргумента), то она возвращает пустоту. А
> если вызвал с аргументом и там уже что-то не сматчилось, то
> это в любом случае ошибка сопоставления. То есть правило матчинга пустого
> только аргумента, может матчится по дефолту.

В том то и дело, что "аргумент" с т.з. Рефала всегда есть - это Поле Зрение. Может быть пустым. Когда функция состоит из нескольких предложений, цена вопроса - написать одно предложение
= ;

Зато это приобретает смысл в случае однострочных функций! При этом не ломает обратную совместимость, если разрешить только для них. Обычно по =; происходит выход из рекурсии, что обязывает даже в простейших случаях писать { } и два предложения. Плюсом, если делать такое умолчание, не обязательно генерировать опкоды для такого предложения. Достаточно в исполнителе добавить проверку. И флажок в командную строку, что бы можно было изменить поведение, если мешает.

Сейчас флажки можно указывать в хешбанге, загрузчик Линукса передаёт командную строку интерпретатору, если запускать программу выставив бит исполнения, а не передавая аргументом в refal.

Можно, наверное, разрешить "глобальное" предложение:

=; // задаём всем функциям последнее предложение.

Но в этом случае придётся думать, как быть с модулями.

>[оверквотинг удален]
>> останавливается. Можно изменить поведение, и возвращать например в структурных скобках:
>> (fun бесполезные "аргументы"). Наверное, такое было бы полезно, если бы Рефал
>> использовался как интерпретатор командной строки и можно было бы исправить что-то
>> и вызвать повторно. Когда исполняется программа из файла, пока не совсем
>> понятно, что с этим делать: оно и дальше будет вызывать ошибку
>> распознавания. При этом восстановить аргументы вызывающих функций проблематично, они
>> уже переработаны.
> Все зависит уже от назначения этого ЯП, если для формальной верификации, то
> останов считаю лучше. Если для общего назначения, принцип "лет-ит-креш" (эрлангеновский)
> - ересь как по мне.

Верификацией пусть участники конференций занимаются.) Из очевидных для меня применений: встроить интерпретатор в программу на др. ЯП и разбирать конфиги или предметно-ориентированный язык, функция на Си возвращает ошибку и перекладывает заботы на вызывающую сторону. Из не совсем пока очевидных: описывать графический интерфейс. Что такое "общее применение", я не знаю.:)

>> По поводу отсутствия сигнатур функций - это вообще отдельная интересная тема. Автор
>> Рефал-5-Лямбда формализует их в комментариях, наверное с расчётом их анализировать. Турчин
>> же работал над "суперкомпиляцией". Хотел определять все возможные варианты входных данных,
>> строить граф вызовов и как-то это просчитывать. В принципе ведь, возможные
>> аргументы формализованы образцами в предложениях функции. Другое дело, что во время
>> исполнения может прийти неведомо что.
> Это же подобие одной и той же функции с разной арностью, как
> в эрленге, но и с ограничениями на сами аргументы (возможно guard-ы).

Что бы пронять арность, надобно быть математиком, либо выдавать определённый результат на Мичиганском рыбном тесте. Если в России люди селились по берегам рек, то поколениями по ним и сплавляли что-то: сверху по течению сгружали в реку, а ниже вылавливали, кто бревно, а кто мешок с мукой. Вот это и есть Поле Зрения и переменные Рефала, понятные и в деревне.

>[оверквотинг удален]
> Например, пусть исходный алгоритм — вычисление квадрата числа: square(x) => x *
> x. Для x = 0 можно получить более короткий и более
> быстрый вариант алгоритма, который просто возвращает ноль: square(0) => 0.
> """
> В случае с эрлангом было бы что-то вроде этого:
> square(x) when x==0 ->
>  return 0
> Или просто без аргумента:
> square() ->
>  return 0

Эрланг ломает мой шаблон словом return вместо square() -> 0.

>> С файловой системой всё сложнее
> Как говорится, пока петух не клюнет, ждем когда Линусу какой-нить ваннакрай зашифрует
> диск, после этого придем к осознанию, что нужна новая модель взаимодействия
> прикладного ПО с системой и ее ресурсами, принципа максимального изолирования.

Это вероятностный сценарий, когда RH доделает цифровые подписи и интеграцию с UEFI. Надо будет как-то заставить сообщество одобрить переход под покровительство Microsoft. :)

>> Были такие тесты на профпригодность, считали там нули, например.
> Жесть, только глаза портить, эт как овец считать, чтобы заснуть? :)

Нет, успеть за минуту подсчитать количество. :) Такое никто не способен в принципе, но 10% из рискнувших выдают заметно отличающийся в лучшую сторону от остальных результат. То есть сейчас в индустрии примерно 90% посторонние люди, в отладчике ничего толком не увидят, а по коду наивно ищут при помощи grep или Ctrl+F. :) Подозреваю, что оставшиеся 10% смогут выполнить 146% всей работы, если не будут отвлекаться остальными.

Ответить | Правка | К родителю #243 | Наверх | Cообщить модератору

250. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 05-Июн-24, 14:05 
> Достаточно в исполнителе добавить проверку.
> И флажок в командную строку, что бы можно было изменить поведение,
> если мешает.

Синтаксис ЯП должен быть явным и ясным при чтении ЧЕЛОВЕКОМ, и всякая магия с флагами компилятора и тем же поведением по умолчанию (синтаксическим сахаром и т.д.), я считаю ересью. Компилятор этот со своим флагом сегодня есть, а завтра нет, нельзя специфицировать язык и говорить, чтобы компилятор имел флаг какой-то.

У человека говорящего на "великом-могучем", должны быть здоровые зубы.

> Можно, наверное, разрешить "глобальное" предложение:
> =; // задаём всем функциям последнее предложение.
> Но в этом случае придётся думать, как быть с модулями.

Вот поэтому, лучше не делать ничего неявного и по умолчанию.


> Верификацией пусть участники конференций занимаются.)

Там где нужна спецификация ПО там и появляется ее верификация, а далее по верифицированной спецификации можно уверенно генерировать целевой исполняемый код.

> Что такое "общее применение", я не знаю.:)

ЯП с большой стд либой, мульти-парадигменный, и используемый в повседневных задачах. Таким ЯП может быть любой тьюринг-полный ЯП.

> Эрланг ломает мой шаблон словом return вместо square() -> 0.

Эт псевдокод если че. Акцент там на функцию и ограничении ее аргумента. Там можно описать функцию со всеми ее допустимыми аргументами.

funA (X) when X=0 ->
funA (X) when X=1 ->
funA (X) when X=2 ->
funA (X) when X=3 ->
.....

тоже самое и в Рефал:

funA {
"0" = <>
"1" = <>
"2" = <>
.....
}

разницы никакой.

> Подозреваю, что оставшиеся 10%
> смогут выполнить 146% всей работы, если не будут отвлекаться остальными.

А это в любой области так, нет же понятия "коллективного гения". Об этом даже не надо думать, "паразиты" будут существовать всегда.

Ответить | Правка | К родителю #248 | Наверх | Cообщить модератору

253. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 05-Июн-24, 16:33 
>> Достаточно в исполнителе добавить проверку.
>> И флажок в командную строку, что бы можно было изменить поведение,
>> если мешает.
> Синтаксис ЯП должен быть явным и ясным при чтении ЧЕЛОВЕКОМ, и всякая
> магия с флагами компилятора и тем же поведением по умолчанию (синтаксическим
> сахаром и т.д.), я считаю ересью. Компилятор этот со своим флагом
> сегодня есть, а завтра нет, нельзя специфицировать язык и говорить, чтобы
> компилятор имел флаг какой-то.
> У человека говорящего на "великом-могучем", должны быть здоровые зубы.

Тут стоит вспомнить Мичиганский рыбный тест: люди разные, и дихотомий на самом деле больше. Что ясно одному, не очень ясно другому. Ключ - это не синтаксис. Он служит запасным вариантом, если вдруг потребуется переопределить синтаксис с пустым предложением =; которое как раз и добавляется _неявно_. :)

>> Можно, наверное, разрешить "глобальное" предложение:
>> =; // задаём всем функциям последнее предложение.
>> Но в этом случае придётся думать, как быть с модулями.
> Вот поэтому, лучше не делать ничего неявного и по умолчанию.

Вроде бы, не я предложил добавлять неявное предложение при определении функции. Я лишь прикидываю, когда оно может оказаться уместно, и что делать, если вдруг не окажется.

>> Верификацией пусть участники конференций занимаются.)
> Там где нужна спецификация ПО там и появляется ее верификация, а далее
> по верифицированной спецификации можно уверенно генерировать целевой исполняемый код.

Верификация ПО может и появляется, но ПО почему-то в действительности не видно.

>> Что такое "общее применение", я не знаю.:)
> ЯП с большой стд либой, мульти-парадигменный, и используемый в повседневных задачах. Таким
> ЯП может быть любой тьюринг-полный ЯП.

Определения я знаю (и мультипарадигменный раньше в него не входило). Повседневные задачи у всех разные. Потому и появляются 100500 вариантов 10-го правила Гринспена.

>[оверквотинг удален]
> funA (X) when X=3 ->
> .....
> тоже самое и в Рефал:
> funA {
>  "0" = <>
>  "1" = <>
>  "2" = <>
>  .....
> }
> разницы никакой.

Единственно, что в Рефале без кавычек, если числа.

>> Подозреваю, что оставшиеся 10%
>> смогут выполнить 146% всей работы, если не будут отвлекаться остальными.
> А это в любой области так, нет же понятия "коллективного гения". Об
> этом даже не надо думать, "паразиты" будут существовать всегда.

Не факт. Есть такая штука - порог вхождения. Его старательно пытаются понизить. Заодно внушаются разные весёлые шаблоны мышления вроде "деревянный велосипед" и "изобрести колесо". Раньше были анекдоты про русских программистов, которым лишь бы всё попереписывать. Давно их не слышал. :)

Ответить | Правка | К родителю #250 | Наверх | Cообщить модератору

255. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 05-Июн-24, 18:49 
> Тут стоит вспомнить Мичиганский рыбный тест: люди разные, и дихотомий на самом
> деле больше. Что ясно одному, не очень ясно другому. Ключ -
> это не синтаксис. Он служит запасным вариантом, если вдруг потребуется переопределить
> синтаксис с пустым предложением =; которое как раз и добавляется _неявно_.
> :)

И как это записать в стандарте языка?

Либо строго - "компилятор ДОЛЖЕН реализовать флаг явного и неявного определения синтаксиса пустого сопоставлением с образцом.",

либо - "компилятор МОЖЕТ реализовать флаг неявного ...".

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

Явность, ясность, однозначность должна быть :)

> Вроде бы, не я предложил добавлять неявное предложение при определении функции.

Эт не "предъява", я называю это "рассуждение в диалогах", контр-аргументирование собственных аргументов.

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

Все правильно, и на каждый аргумент "уместного" надо искать контр-аргумент "не уместного". И этот процес можно делать в паре с собеседником (диалог), при этом меняясь местами.

> Верификация ПО может и появляется, но ПО почему-то в действительности не видно.

Потому-что, это долго и дорого, а "пиззнессу" это не нужно, осознание нужности придет со следующим циклом развития  этой области, а пока только развитие нынешнего цикла должно достичь дна (деградировать).


> Повседневные задачи у всех разные.

А по большей части это банальная симуляция деятельности (скамономика).

> Не факт. Есть такая штука - порог вхождения. Его старательно пытаются понизить.
> Заодно внушаются разные весёлые шаблоны мышления вроде "деревянный велосипед" и "изобрести
> колесо". Раньше были анекдоты про русских программистов, которым лишь бы всё
> попереписывать. Давно их не слышал. :)

Отчуждение первобытного опыта.

Ответить | Правка | К родителю #253 | Наверх | Cообщить модератору

256. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 06-Июн-24, 11:29 
>> Тут стоит вспомнить Мичиганский рыбный тест: люди разные, и дихотомий на самом
>> деле больше. Что ясно одному, не очень ясно другому. Ключ -
>> это не синтаксис. Он служит запасным вариантом, если вдруг потребуется переопределить
>> синтаксис с пустым предложением =; которое как раз и добавляется _неявно_.
>> :)
> И как это записать в стандарте языка?

Никак, поскольку стандарта языка нет. В Рефал-5 нет и функций с одним предложением.

> Либо строго - "компилятор ДОЛЖЕН реализовать флаг явного и неявного определения синтаксиса
> пустого сопоставлением с образцом.",
> либо - "компилятор МОЖЕТ реализовать флаг неявного ...".
> И во-втором случае, поступай как хочешь. Код для одного компилятора будет валидным,
> для другого - нет, либо "забыл врубить флаг".
> Явность, ясность, однозначность должна быть :)

Вот мне ясно: я могу это сделать вот так, это легко, потому можно добавить и неявное предложения с пустым образцом к функциям. Просто так взять и добавить - рискованно, поскольку может сломать обратную совместимость с Рефал-5.

Если функция с одним предложением вызывает сама себя - однозначно, там требуется =; вторым предложением, иначе выход из рекурсии невозможен. Если не вызывает - тогда не ясно, зачем это вообще нужно, и необходимость думать о синтаксисе отпадает.

>> Вроде бы, не я предложил добавлять неявное предложение при определении функции.
> Эт не "предъява", я называю это "рассуждение в диалогах", контр-аргументирование собственных
> аргументов.

А заодно исключение возможных вариантов решения. Ключ транслятору это не синтаксис языка. В Си задают ключ -std=с99, а какой стандарт в исходниках - это и так знатоку Си ясно из их содержимого.

>> Я лишь прикидываю, когда оно может оказаться уместно, и что делать, если
>> вдруг не окажется.
> Все правильно, и на каждый аргумент "уместного" надо искать контр-аргумент "не уместного".
> И этот процес можно делать в паре с собеседником (диалог), при
> этом меняясь местами.

Есть такая штука - формула полной вероятности. Вот в неё слагаемыми надо списывать помимо синтаксиса много чего ещё: транслятор, пользователей, ...

>> Верификация ПО может и появляется, но ПО почему-то в действительности не видно.
> Потому-что, это долго и дорого, а "пиззнессу" это не нужно, осознание нужности
> придет со следующим циклом развития  этой области, а пока только
> развитие нынешнего цикла должно достичь дна (деградировать).

Во многих случаях она никому не нужна, особенно в "приложениях".

>> Повседневные задачи у всех разные.
> А по большей части это банальная симуляция деятельности (скамономика).
>> Не факт. Есть такая штука - порог вхождения. Его старательно пытаются понизить.
>> Заодно внушаются разные весёлые шаблоны мышления вроде "деревянный велосипед" и "изобрести
>> колесо". Раньше были анекдоты про русских программистов, которым лишь бы всё
>> попереписывать. Давно их не слышал. :)
> Отчуждение первобытного опыта.

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

Ответить | Правка | К родителю #255 | Наверх | Cообщить модератору

259. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 07-Июн-24, 14:51 
> Никак, поскольку стандарта языка нет. В Рефал-5 нет и функций с одним
> предложением.

в смысле нет?

funA {
"hi" = "hello";
}


> Если функция с одним предложением вызывает сама себя - однозначно, там требуется
> =; вторым предложением, иначе выход из рекурсии невозможен.

потому-что там где есть вход - должен (может) быть и выход. И =; не обязан быть условием выхода из рекурсии. =; своего рода граничное условие обычного цикла, когда известна длина данных. И использования бесконечных циклов никто не запрещал (ивент лупы всякие), просто рекурсия должна быть грамотно оформлена. А так в любом случае есть интерпретаторские ограничения на глубину рекурсии (а как реализовать ивент луп тогда?).

> А заодно исключение возможных вариантов решения. Ключ транслятору это не синтаксис языка.
> В Си задают ключ -std=с99, а какой стандарт в исходниках -
> это и так знатоку Си ясно из их содержимого.

То есть если я просто беру код (без всякой инструкции по сборке), и перед тем как скормить компилятору, должен разобраться какому он стандарту соответствует, выставить флаги компилятора и собрать бинарник. Почему компилятор такой "тупой" сам не может определить какой стандарт? Новый стандарт, почему компилятор не новый, зачем городить флаги (ключи) и всякую ересь?

> Есть такая штука - формула полной вероятности. Вот в неё слагаемыми надо
> списывать помимо синтаксиса много чего ещё: транслятор, пользователей, ...

Эт как неравенства Белла и "скрытые параметры"? :)

> Сдаётся мне, что люди как раз и вышли из пещер, когда кого
> попало перестали допускать ко всему подряд.

По-конкретней, не понял. Что мешает обезьянам стать "людьми", то есть сменить образ своего существования?

Ответить | Правка | К родителю #256 | Наверх | Cообщить модератору

260. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 07-Июн-24, 15:41 
>> Никак, поскольку стандарта языка нет. В Рефал-5 нет и функций с одним
>> предложением.
> в смысле нет?
> funA {
>  "hi" = "hello";
> }

Здесь блок {} а в нём одно предложение.
Имел ввиду, что такого нет:

funA "hi" = "hello";

Вот для них м.б. вполне допустимо создавать неявно второе. Если кто-то потрудился написать скобочки, значит ему ничего не стоит дописать ещё и =;

>> Если функция с одним предложением вызывает сама себя - однозначно, там требуется
>> =; вторым предложением, иначе выход из рекурсии невозможен.
> потому-что там где есть вход - должен (может) быть и выход. И
> =; не обязан быть условием выхода из рекурсии. =; своего рода
> граничное условие обычного цикла, когда известна длина данных. И использования бесконечных
> циклов никто не запрещал (ивент лупы всякие), просто рекурсия должна быть
> грамотно оформлена. А так в любом случае есть интерпретаторские ограничения на
> глубину рекурсии (а как реализовать ивент луп тогда?).

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

Вообще, функции с блоками в Рефал обычно большие, особенно когда есть сложенные блоки. Там может быть и 10 и 20 предложений запросто. В образцах проверяются аргументы на валидность. Если среди них не написано =;, скорее всего, так и должно быть, либо программист забыл. Считаю, в них неявно добавлять не следует.

Функции из одного предложения обычно какие-то вспомогательные, для простых действий. При их вызове аргументы скорее всего уже проверены раньше. Удалить первый символ - легко написать. Удалить все "а" - надо рекурсию с выходом по пустому ПЗ. Если она вызывается однократно, то проще написать вложенные блок, а это не улучшит читаемость. Вот для таких случаев неявное =; имеет смысл - именованная функция сделает код и понятнее, и компактнее.

>> А заодно исключение возможных вариантов решения. Ключ транслятору это не синтаксис языка.
>> В Си задают ключ -std=с99, а какой стандарт в исходниках -
>> это и так знатоку Си ясно из их содержимого.
> То есть если я просто беру код (без всякой инструкции по сборке),
> и перед тем как скормить компилятору, должен разобраться какому он стандарту
> соответствует, выставить флаги компилятора и собрать бинарник. Почему компилятор такой
> "тупой" сам не может определить какой стандарт? Новый стандарт, почему компилятор
> не новый, зачем городить флаги (ключи) и всякую ересь?

Он и определит при попытке трансляции. Навалит ошибок и в них укажет, что нужен новый стандарт.

>> Есть такая штука - формула полной вероятности. Вот в неё слагаемыми надо
>> списывать помимо синтаксиса много чего ещё: транслятор, пользователей, ...
> Эт как неравенства Белла и "скрытые параметры"? :)

Это когда у имеющихся слагаемых условия оказываются противоречивы. Значит, не хватает слагаемых. Если на уровне синтаксиса не решается, или может вызвать удивление пользователей, когда старые программы перестанут работать, значит решение следует искать в другом месте. Например, ключ транслятору.

>> Сдаётся мне, что люди как раз и вышли из пещер, когда кого
>> попало перестали допускать ко всему подряд.
> По-конкретней, не понял. Что мешает обезьянам стать "людьми", то есть сменить образ
> своего существования?

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

Ответить | Правка | К родителю #259 | Наверх | Cообщить модератору

262. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 07-Июн-24, 18:00 
Как раз в исходном примере в #147

очередь {
      = ;
  ? . = (? " - " <тип ?>) "\t" <очередь .>;
}

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

очередь ? . = (? " - " <тип ?>) "\t" <очередь .>;

Очевидно, что без пустого образца произойдёт ошибка сопоставления. Если же по факту функция работает, значит такой случай как-то обрабатывается.

Ответить | Правка | К родителю #259 | Наверх | Cообщить модератору

263. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 10-Июн-24, 10:56 
В общем, показал Даниилу, он оценил как "выглядит красиво".

Благодарю за идею. В коммите будет "Благодаря идее Sw00p aka Jerom c Opennet.ru." Пока не отправлял в основную ветку, если вдруг надо изменить.

Мне нравится, что доработка - по сути две строки, и как раз в том месте висел лишний if (из-за боле компактного кодирования таких функций), которому нашлось полезное применение.


--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -176,9 +176,15 @@ next_sentence:
       cur = vm->u[prev].next;
       assert(ep == -1);
       local = 0;
-      // Оставлено для однострочных, поскольку не содержат rf_sentence
-      if (!next_sentence)
+      // Однострочные без блока не содержат опкод rf_sentence,
+      // потому требуют отдельного обработчика завершения (по !next_sentence).
+      // Используем это и считаем, что имеется неявное второе предложение
+      //  = ;
+      if (!next_sentence) {
+         if (rf_is_evar_empty(vm, prev, next))
+            goto return_with_empty;
          goto recognition_impossible;
+      }
       ip = next_sentence;
       next_sentence = 0;
       bp = fn_bp;
@@ -604,6 +610,7 @@ execute_byte_code:
          assert(result);
          rf_splice_evar_prev(vm, result, vm->free, next);
          rf_free_last(vm);
+return_with_empty:
          if (!sp--)
             break;
          ip     = stack[sp].ip;

Ответить | Правка | К родителю #259 | Наверх | Cообщить модератору

264. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 11-Июн-24, 19:45 
> В общем, показал Даниилу, он оценил как "выглядит красиво".

Отлично. :)

Ответить | Правка | К родителю #263 | Наверх | Cообщить модератору

265. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 14-Июн-24, 10:22 
Вот теперь может быть понятно, зачем я хотел "трубу" как синтаксический сахар для вызова функции.

очередь {
      = ;
  ? . = (? " - " <тип ?>) "\t" <очередь .>;
}

очередь ? . = (? " - " <тип ?>) "\t" <очередь .>;

очередь ? . = (? " - " <тип ?>) "\t" <_ .>; // _ (например) псевдоним для текущей функции.

очередь ? . = (? " - " <тип ?>) "\t" . | _; // пока не ясно, как отделить передаваемый аргумент

очередь ? . = (? " - " <тип ?>) "\t" . |; // когда нет имени, рекурсивно вызывается исполняемая функция.


Если реализовать "блоки", разделяемые двоеточием (при этом позволить и однострочные) - можно вызывать из блока самого себя (исполняемый в данный момент блок, как анонимную функцию). По сути получается как цикл императивном в языке: можно ведь рассматривать {} в for как анонимную функцию, что вызывает себя рекурсивно. :)

Ответить | Правка | К родителю #264 | Наверх | Cообщить модератору

266. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 16-Июн-24, 12:59 
> Вот теперь может быть понятно, зачем я хотел "трубу" как синтаксический сахар
> для вызова функции.

Сколько не встречал примера трубных вызовов в том же шелле, всегда среди них должен присутствовать вызов awk :) И задаюсь вопросом, зачем? Очевидно, предварительная обработка результата предыдущего вызова, для последующего, в качестве аргумета. Ну напиши обработчик сразу на awk, в чем проблема, зачем городить "трубу".

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

> очередь ? . = (? " - " <тип ?>) "\t" <очередь
> .>;

Стандартно, ясно, явно и все понятно.

> очередь ? . = (? " - " <тип ?>) "\t" <_
> .>; // _ (например) псевдоним для текущей функции.

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


> очередь ? . = (? " - " <тип ?>) "\t" .
> | _; // пока не ясно, как отделить передаваемый аргумент

Эт я не понял.

> очередь ? . = (? " - " <тип ?>) "\t" .
> |; // когда нет имени, рекурсивно вызывается исполняемая функция.

Вариант с псевдонимом <_ .> яснее. И делать акциент именно на <>.

> Если реализовать "блоки", разделяемые двоеточием (при этом позволить и однострочные) -
> можно вызывать из блока самого себя (исполняемый в данный момент блок,
> как анонимную функцию).

Как тут ?

https://github.com/bmstu-iu9/refal-5-lambda/tree/master?tab=...


Foo {
  некоторый образец
    , условие
    : { …блок 1… }
    : { …блок 2… }
    : образец условия
    = результатное выражение;
}

А смысл в левой части (в образце) вызывать анонимныую функцию? Там как раз таки имеет смысл вызвать именованную определенню в другом месте функцию.

Вообще смысл анонимных функций в том, что их можно передавать в качестве аргументов, и получать в качестве результата именованных функций (так и безымянных).

<{ …C… } <{ …B… } <{ …A… } Result>>>

Это смысла не имеет я так думаю, ибо можно записать так:

<{ …C… …B… …A… } Result>


> По сути получается как цикл императивном в языке:
> можно ведь рассматривать {} в for как анонимную функцию, что вызывает
> себя рекурсивно. :)

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

Пример:

FunA {

} - определение именованной функции


{

} - определения чего? блока разделителя области видимости, или анонимная (безымянная) функция?


Можно ввести ограничение на определение безымянных только в именных функциях?

Ответить | Правка | К родителю #265 | Наверх | Cообщить модератору

267. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 16-Июн-24, 14:54 
>> Вот теперь может быть понятно, зачем я хотел "трубу" как синтаксический сахар
>> для вызова функции.
> Сколько не встречал примера трубных вызовов в том же шелле, всегда среди
> них должен присутствовать вызов awk :) И задаюсь вопросом, зачем? Очевидно,
> предварительная обработка результата предыдущего вызова, для последующего, в качестве
> аргумета. Ну напиши обработчик сразу на awk, в чем проблема, зачем
> городить "трубу".

Рефал просматривает Поле Зрения последовательно. Не всегда возможно одновременно поменять заглавные буквы на строчные и заменить арабские цифры римскими.

> Надо понимать, что "трубная" функция или "функция-труба" накладывает некоторые ограничения
> на их применимость, должна быть согласованность "входов-выходов" и их типов. В
> идеале, "трубная" функция должна быть по сути "чистой" функцией, то есть
> без сайд-эффектов, чтобы гарантировать всю цепочку вызовов.

Все функции в Рефал чистые. Они даже Поле Зрения не меняют, а принимают его и выдают результат как ПЗ для другой функции. Состояние могут менять только некоторые библиотечные функции для работы с "ящиками". Потому в исходном #147 я и написал "теперь думаю, что это такое вообще".

_2-e { ноль; один } // вот это "ящик", и его содержимое можно изменить.

>> очередь ? . = (? " - " <тип ?>) "\t" <очередь
>> .>;
> Стандартно, ясно, явно и все понятно.
>> очередь ? . = (? " - " <тип ?>) "\t" <_
>> .>; // _ (например) псевдоним для текущей функции.
> Можно, как "сахар", но я всегда явно вызывал бы функцию по имени.
> (Эт как близкого друга можно междусобойчиком звать по прозвищу, а вот
> при посторонних уважаемых людях надо бы - как мать родная назвала
> - по имени :)

Копи-пасту не запретишь, и в результате по имени может быть вызвано что-то не то. this в С++ ввели не просто так. Но основное предназначение не для именованных функций, а для вложенных блоков, где нет имени.

>> очередь ? . = (? " - " <тип ?>) "\t" .
>> | _; // пока не ясно, как отделить передаваемый аргумент
> Эт я не понял.

Это как вариант предыдущей записи с <>, с трубой вместо скобочек. Скобочки отделяют аргументы вызываемой функции от остального, а у трубы такого нет, она же одна.

>> очередь ? . = (? " - " <тип ?>) "\t" .
>> |; // когда нет имени, рекурсивно вызывается исполняемая функция.
> Вариант с псевдонимом <_ .> яснее. И делать акциент именно на <>.

Ну, пока других вариантов и нет. Всякие гипотетические прикидываю, потому что это по сути реверс-инженерия: не очень ясно, что получится и итоге. :)

>[оверквотинг удален]
> Как тут ?
> https://github.com/bmstu-iu9/refal-5-lambda/tree/master?tab=...
> Foo {
>   некоторый образец
>     , условие
>     : { …блок 1… }
>     : { …блок 2… }
>     : образец условия
>     = результатное выражение;
> }

Да. Блоки могут так же идти и после =. Каждый блок по сути анонимная функция. При этом имеет доступ к переменным основной функции, поэтому, если выносить блок в отдельную функцию, то она выйдет сложнее. Для Рефала обычны функции с множеством блоков и даже на несколько страниц.

Сейчас блок не может просто так вызвать сам себя. Есть варианты Рефал, где блоки именуются; возможно имя блока располагать между : и { -- там сейчас ничего писать нельзя. В Рефал-Лямбда блок можно передать аргументом в функции Map, Apply и т.п., но в простейших случаях хотелось бы обеспечить рекурсивный вызов блоком самого себя.

Если блок состоит из одного предложения, то его можно записать без скобочек {}. В таком случае второе предложение =; теперь создаётся неявно. Рекурсивный вызов позволит просто записывать простейшие циклы, большее от него вряд ли требуется.

> А смысл в левой части (в образце) вызывать анонимныую функцию? Там как
> раз таки имеет смысл вызвать именованную определенню в другом месте функцию.

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

Например, для поддержки : в правой части требуется новый опкод. Что с ним делать интерпретатору, если вдруг встретится в левой? По-идее, следует не полагаться на транслятор (выдаст ошибку синтаксиса и не сгенерирует), а обрабатывать как ошибку.

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

ширина; высота;

прямоугольник {
.1 (ширина ?ш) .2 : .3 (высота ?в) .4 = (высота ": " ?в ", " ширина ": " ?ш);
}

начало =
   <прямоугольник (ширина 2) (высота 3)> "\n"
   <прямоугольник (высота 2) (ширина 3)> "\n"
   ;

./refal tests/И.ref
Поле зрения:
(высота: 3, ширина: 2)
(высота: 2, ширина: 3)

М.б. оно и не надо, но это экономнее (в реализации), чем обрабатывать ошибку.

> Вообще смысл анонимных функций в том, что их можно передавать в качестве
> аргументов, и получать в качестве результата именованных функций (так и безымянных).

Это называется "first class citizens". При этом "гражданин" ничего сам с собой поделать не может. Дискриминация. :)

> <{ …C… } <{ …B… } <{ …A… } Result>>>
> Это смысла не имеет я так думаю, ибо можно записать так:
> <{ …C… …B… …A… } Result>

В данном случае каждое из …C…, …B… и …A… - это набор разделённых ; предложений, исполняемых по по логике "ИЛИ" (если первое не подошло, тогда следующее). Если …C… обрабатывает все возможные наборы данных, то остальные (…B… и …A…) исполняться не будут.

Потому по ссылке первый вариант аналогичен

Result : { …A… } : { …B… } : { …C… }

Result - это ПЗ для { …A… }. Результат { …A… } - ПЗ для { …B… } и т.д.

>> По сути получается как цикл императивном в языке:
>> можно ведь рассматривать {} в for как анонимную функцию, что вызывает
>> себя рекурсивно. :)
> Ну тогда получается просто разделитель области видимости, и вовсе не анонимная функция.

Закрывающая скобка } в цикле for вызывает повторно тело цикла (с проверкой условий, естественно). Так же и continue вызывает повторно. Си более функциональный, чем думают некоторые. Императивен там оператор запятая, про который мало кто из пишущих на Си знает. :)

> Пример:
> FunA {
> } - определение именованной функции
> {
> } - определения чего? блока разделителя области видимости, или анонимная (безымянная) функция?

В Рефал-5 это называется блок. Именованная функция состоит из имени и последующего блока. Т.о. это безымянная функция. Но на верхнем уровне исходника такую объявить нельзя, только внутри другой функции.

> Можно ввести ограничение на определение безымянных только в именных функциях?

Так оно и есть. Технически можно было бы определять их, но непонятно как их адресовать и что с ними делать. :)

Ответить | Правка | К родителю #266 | Наверх | Cообщить модератору

268. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 18-Июн-24, 20:32 
> Сейчас блок не может просто так вызвать сам себя. Есть варианты Рефал,
> где блоки именуются; возможно имя блока располагать между : и {
> -- там сейчас ничего писать нельзя. В Рефал-Лямбда блок можно передать
> аргументом в функции Map, Apply и т.п., но в простейших случаях
> хотелось бы обеспечить рекурсивный вызов блоком самого себя.

Если для блока добавить имена, и возможность вызывать самого себя - то чем это будет отличаться от обычных функций? Между блоком и функцией нет разницы.

> Если блок состоит из одного предложения, то его можно записать без скобочек
> {}. В таком случае второе предложение =; теперь создаётся неявно. Рекурсивный
> вызов позволит просто записывать простейшие циклы, большее от него вряд ли
> требуется.

funA
{

{
   {arg}
}

}

ну вот пример простого цикла на базе анонимной функции {} которая может вызывать себя рекурсивно (по имени Я).

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


funA
{

{
   {arg}
}

<funA arg>
}


Хотя вызов рекурсии анонимной можно записать {} такими скобками, а явный именной вызов - <>.

funA
{

{
   {arg} // рекурсивный вызов анонимки
}

<arg> // рекурсивный вызов funA
}

Стоп: вернем все как было, и пусть вызов всегда однозначно будет <>

funA
{

{
   <arg> // рекурсивный вызов анонимки
}

<arg> // рекурсивный вызов funA
}

Читабельность сломалась, нужно искать {}, чтобы понять к вызову какой функции имеет отношение.


> М.б. оно и не надо, но это экономнее (в реализации), чем обрабатывать
> ошибку.

УУУУ произвольный порядок аргументов у функции - это бомба замедленного действия. И поле холивара для программистов.


> Это называется "first class citizens". При этом "гражданин" ничего сам с собой
> поделать не может. Дискриминация. :)

Имя у "гражданина" нужно когда к нему обращается другой "гражданин", а сам к себе "гражданин" обращается по "имени" - Я.

И по логике, рекурсивная функция должна определяться не так:

funA()
{
   funA();
}

а вот так:

funA()
{
  self(); // this(), Iam(), можно вообще просто ();
}


>[оверквотинг удален]
>> <{ …C… …B… …A… } Result>
> В данном случае каждое из …C…, …B… и …A… - это набор
> разделённых ; предложений, исполняемых по по логике "ИЛИ" (если первое не
> подошло, тогда следующее). Если …C… обрабатывает все возможные наборы данных,
> то остальные (…B… и …A…) исполняться не будут.
> Потому по ссылке первый вариант аналогичен
> Result : { …A… } : { …B… } : { …C…
> }
> Result - это ПЗ для { …A… }. Результат { …A… }
> - ПЗ для { …B… } и т.д.

Тут поправочка, должно было быть так <{ …A… …B… …C… } Result>.

Это

<{ …C… } <{ …B… } <{ …A… } Result>>>

вложенные вызовы, то есть последовательны, и "ИЛИ" и есть последовательность.

funA
{
  A = <funA B>;
  B = <funA C>;
  C = <funA "">;
  =; // неявно
}

Не равносильно?

> Закрывающая скобка } в цикле for вызывает повторно тело цикла (с проверкой
> условий, естественно). Так же и continue вызывает повторно. Си более функциональный,
> чем думают некоторые. Императивен там оператор запятая, про который мало кто
> из пишущих на Си знает. :)

for ()
{

}

и есть в сущности функция с именем for, мы же собственные функции в С for-ом назвать ведь не можем :)

{
{arg}
}

вот такой анонимный рекурсивный вызов и есть по сути for цикл. А continue это тупо псевдоним. Break -  по сути может быть вызов с пустым аргументом (терминатор рекурсии неявный) {пусто}


> В Рефал-5 это называется блок. Именованная функция состоит из имени и последующего
> блока. Т.о. это безымянная функция. Но на верхнем уровне исходника такую
> объявить нельзя, только внутри другой функции.

Ну как выше и говорил, если мы захотим добавить имена к блокам, и самообращение (рекурсивный вызов), то ничем от обычной функции отличаться не будет.


>> Можно ввести ограничение на определение безымянных только в именных функциях?
> Так оно и есть. Технически можно было бы определять их, но непонятно
> как их адресовать и что с ними делать. :)

Можно и не вводить :)

{
{}
}

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

Ответить | Правка | К родителю #267 | Наверх | Cообщить модератору

269. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 19-Июн-24, 14:03 
>> Сейчас блок не может просто так вызвать сам себя. Есть варианты Рефал,
>> где блоки именуются; возможно имя блока располагать между : и {
>> -- там сейчас ничего писать нельзя. В Рефал-Лямбда блок можно передать
>> аргументом в функции Map, Apply и т.п., но в простейших случаях
>> хотелось бы обеспечить рекурсивный вызов блоком самого себя.
> Если для блока добавить имена, и возможность вызывать самого себя - то
> чем это будет отличаться от обычных функций? Между блоком и функцией
> нет разницы.

Блок и есть функция. В книге Турчина даже детали реализации указаны, для блока генерируется отдельная функция. Но есть и разница: блок видит переменные охватывающей функции. С одной стороны, это упрощает функцию-блок (в сравнении, если бы она определялась отдельно), даёт ей больше возможностей. С другой - реализация усложняется, приходится захватывать "внешние" переменные. У меня пока получается достаточно просто (если это слово применимо в вермишели из goto).

>[оверквотинг удален]
>> вызов позволит просто записывать простейшие циклы, большее от него вряд ли
>> требуется.
> funA
> {
>  {
>    {arg}
>  }
> }
> ну вот пример простого цикла на базе анонимной функции {} которая может
> вызывать себя рекурсивно (по имени Я).

Запись {arg} не может быть вызовом в Рефал, поскольку это определение блока. Не хочется делать из него LISP, у меня от однотипных скобочек в глазах рябит.

> Но тут нужно понимать, что тогда синтаксис для рекурсии именной функции должен
> быть явным.
> funA
> {
>  {
>    {arg}
>  }
>  <funA arg>
> }

Сейчас вызов именованной ф. такой и есть.

>[оверквотинг удален]
> Стоп: вернем все как было, и пусть вызов всегда однозначно будет <>
> funA
> {
>  {
>    <arg> // рекурсивный вызов анонимки
>  }
>  <arg> // рекурсивный вызов funA
> }
> Читабельность сломалась, нужно искать {}, чтобы понять к вызову какой функции имеет
> отношение.

Сломалась, потому такое прописывается в правилах кодирования. В Си обязывают форматировать фигурные скобки отступами.) С другой стороны, не обязательно же все вызывать без имени. Когда ф. небольшая и нет имени, тогда можно, иначе объявить дурным тоном.

>> М.б. оно и не надо, но это экономнее (в реализации), чем обрабатывать
>> ошибку.
> УУУУ произвольный порядок аргументов у функции - это бомба замедленного действия. И
> поле холивара для программистов.

В Рефале он произвольный весьма условно: обязательно придётся "именовать" аргументы (ставить рядом идентификатор), без этого не распознаются. Опять же, можно ограничить правилами кодирования. Если же под "аргументом" ф. понимать файл с конфигом - вот тогда это может быть полезно и упростить программу: вместо рекурсивного разбора можно считать всё набором образцов.

>> Это называется "first class citizens". При этом "гражданин" ничего сам с собой
>> поделать не может. Дискриминация. :)
> Имя у "гражданина" нужно когда к нему обращается другой "гражданин", а сам
> к себе "гражданин" обращается по "имени" - Я.

Есть даже такой анекдот:

- Тук-тук!
- Кто там?
- Я!
- Как, я?

> И по логике, рекурсивная функция должна определяться не так:
> funA()
> {
>    funA();
> }
> а вот так:
> funA()
> {
>   self(); // this(), Iam(), можно вообще просто ();
> }

В первом приближении у меня и было имя _ (м.б. не очень подходит, поскольку в других языках на этом символе всякое другие). Если без имени, то |

Если вызывать так:

<arg1 arg2 arg3> // (1)

то есть нюансы. Сейчас в Рефал-М имя функции не обязательно идёт первым, можно

<х1 прибавить х2>

и x2 (но не x1) в свою очередь может быть именем вычислимой функции и как-то вызываться в ф. прибавить. Тогда придётся запретить в (1) аргументами вычислимые функции - а это не дело, лучше использовать псевдоним _ или другой.

>[оверквотинг удален]
>> Потому по ссылке первый вариант аналогичен
>> Result : { …A… } : { …B… } : { …C…
>> }
>> Result - это ПЗ для { …A… }. Результат { …A… }
>> - ПЗ для { …B… } и т.д.
> Тут поправочка, должно было быть так <{ …A… …B… …C…
> } Result>.
> Это
> <{ …C… } <{ …B… } <{ …A… } Result>>>
> вложенные вызовы, то есть последовательны, и "ИЛИ" и есть последовательность.

Выше "естественно" вызываются И A, И B, И С. Через "ИЛИ", как ниже, приходится менять ПЗ, что бы выбиралось следующее предложение:

> funA
> {
>   A = <funA B>;
>   B = <funA C>;
>   C = <funA "">;
>   =; // неявно
> }
> Не равносильно?

Да, можно как-то так записывать. Я так делал, что ф. первым предложением проверяет аргументы, а далее вызывает себя же и делает что-то полезное. Почему-то не нашёл в чужом коде такого. Наверное, потому что тот код использует условия и блоки, а у меня их поддержки не было. Блоки ведь не пишут в одну строку, а оформляют столбиком левее основных образцов, потому за счёт форматирования получается понятнее.

>> Закрывающая скобка } в цикле for вызывает повторно тело цикла (с проверкой
>> условий, естественно). Так же и continue вызывает повторно. Си более функциональный,
>> чем думают некоторые. Императивен там оператор запятая, про который мало кто
>> из пишущих на Си знает. :)
> for ()
> {
> }
> и есть в сущности функция с именем for, мы же собственные функции
> в С for-ом назвать ведь не можем :)

Разве что, формально, ; среди аргументов не может быть.

> {
>  {arg}
> }
> вот такой анонимный рекурсивный вызов и есть по сути for цикл. А
> continue это тупо псевдоним. Break -  по сути может быть
> вызов с пустым аргументом (терминатор рекурсии неявный) {пусто}

Ну вот это обычно рвёт сишникам шаблон примерно как синтаксис Rust.

>> В Рефал-5 это называется блок. Именованная функция состоит из имени и последующего
>> блока. Т.о. это безымянная функция. Но на верхнем уровне исходника такую
>> объявить нельзя, только внутри другой функции.
> Ну как выше и говорил, если мы захотим добавить имена к блокам,
> и самообращение (рекурсивный вызов), то ничем от обычной функции отличаться не
> будет.

Добавлять надо, название обязывает: Ре[курсиыных] Ф[ункций] Ал [горитмический]. С именами пока не уверен. Объявлять их в синтаксисе можно, между : и { всё равно ничего не пишется. Но переусердствовать не хочется: если начинается вложенность блоков больше 2-х, есть подозрение, что пора начинать декомпозицию, выносить в отдельные функции.

>>> Можно ввести ограничение на определение безымянных только в именных функциях?
>> Так оно и есть. Технически можно было бы определять их, но непонятно
>> как их адресовать и что с ними делать. :)
> Можно и не вводить :)
> {
>  {}
> }
> это тупо цикл, а технически ссылка есть у всякой функции, эт только
> у программиста нет возможности использовать неявную ссылку на функцию.

Вот и не вижу возможность вызвать такое. Впрочем, раз есть модули, может как-то для них пригодится. У модуля есть имя-идентификатор и пока транслятор на такое выдаёт "имя модуля без функции не имеет смысла". Был бы смысл писать туда тесты для функций модуля, например. Запустил модуль отдельно - он сам себя протестировал. А при импорте модуля это { } пропускается.

Ответить | Правка | К родителю #268 | Наверх | Cообщить модератору

270. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 20-Июн-24, 13:20 
> Блок и есть функция.

Функция определяется так:

Имя-функции
{

}

А вызывается эта функция так:

<Имя-функции аргументы>


Блок же определяется так:

Нет-имени
{

}

А как вызывается? Вызывается в момент определения? Тогда лучше писать так:


<Нет-имени{

} аргументы>


И рекурсивный вызов будет таким:

<{ <{} аргументы> } аргументы>

Можно и как аргумент передать:

<{} <{ <{ }>} аргументы>>

> Запись {arg} не может быть вызовом в Рефал, поскольку это определение блока.
> Не хочется делать из него LISP, у меня от однотипных скобочек
> в глазах рябит.

А в чем тогда смысл блока? Если мы говорим, что это по сути функция, но не функция с явным вызовом.


> Сейчас вызов именованной ф. такой и есть.

<{}> - вот вызов анонимной (блока). Семантика за <> сохраняется - вызвать.


> Сломалась, потому такое прописывается в правилах кодирования. В Си обязывают форматировать
> фигурные скобки отступами.) С другой стороны, не обязательно же все вызывать
> без имени. Когда ф. небольшая и нет имени, тогда можно, иначе
> объявить дурным тоном.

<{} <{ <{ }>} аргументы>> - ломает читабельность, но можно и так:

<{}
    <{
        <{ }>
     } аргументы>
>
> Разве что, формально, ; среди аргументов не может быть.

; они ввели в виду того, что for (инит; луп-кондишене; инкремент) отделить явно условие выхода из цикла и икнремент, так как в такой записи:

for (arg1, arg2, arg3, ..., )

невозможно определить какой из аргументов за что отвечает. Либо ограничить for (arg1, arg2, arg3)

и запись for (i = 0, j = 0;;) будет невалидной.


> Ну вот это обычно рвёт сишникам шаблон примерно как синтаксис Rust.

Рвет, все потому-что, ни в одном ЯП нет описания почему ввели именно такой, а не другой синтаксис. То есть никто (из создателей языков) не хочет пояснить людям, что ими двигало при выборе. Многие скажут - потому-что в С так, другие скажут не хотел как в Лиспе и т.д. Хотел сделать "С с классами", о чем это говорит? Правильно, жди синтаксис С.


> Добавлять надо, название обязывает: Ре[курсиыных] Ф[ункций] Ал [горитмический]. С именами
> пока не уверен. Объявлять их в синтаксисе можно, между : и
> { всё равно ничего не пишется. Но переусердствовать не хочется: если
> начинается вложенность блоков больше 2-х, есть подозрение, что пора начинать декомпозицию,
> выносить в отдельные функции.

И думаю надо делать это через псевдоним:

{
A = <{} аргумент>;
}


> Вот и не вижу возможность вызвать такое. Впрочем, раз есть модули, может
> как-то для них пригодится. У модуля есть имя-идентификатор и пока транслятор
> на такое выдаёт "имя модуля без функции не имеет смысла". Был
> бы смысл писать туда тесты для функций модуля, например. Запустил модуль
> отдельно - он сам себя протестировал. А при импорте модуля это
> { } пропускается.

Ну вот такое самоопределение-и-вызов

<{

} аргументы>

Ответить | Правка | К родителю #269 | Наверх | Cообщить модератору

272. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 20-Июн-24, 21:09 
>> Блок и есть функция.
> Функция определяется так:
> Имя-функции
> {
> }

Т.е. именованный блок.

> А вызывается эта функция так:
> <Имя-функции аргументы>

Да, скобки <> вызывают блок функции по имени функции. Когда до них (скобок) доходит дело при исполнении.

> Блок же определяется так:
> Нет-имени
> {
> }
> А как вызывается? Вызывается в момент определения?

Скорее, в "точке определения". Под "моментом" можно понимать время написания исходника.

> Тогда лучше писать так:
> <Нет-имени{  } аргументы>

Так и сделано в Рефал-5-Лямбда.

> И рекурсивный вызов будет таким:
> <{ <{} аргументы> } аргументы>

Здесь сначала вызовется (пустой?) блок во внутренних скобках, результат разместится вместо них, следом произойдёт вызов блока во внешних скобках. Пустой блок не является вычислимой функцией, т.е. первый вызов остановит программу. Если бы пустой, то получается, что результат вызова формирует тело внешнего блока, т.е. генерирует ф. во время исполнения -- это кажется довольно мощной штукой, но пока не ясно, как к этому подойти. Мысль использовать {} как псевдоним для текущей функции м.б. стоящая, но не в такой записи.

Потому на деле всё немного иначе:

аргументы : { образец = результат } // "сахар" для <{ образец = результат } аргументы >

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

Запись со скобками <> в Рефал-5-Лямбда используют, передавая блок аргументом в Map и подобные функции -- они и обеспечивают вызов блока в цикле.

$ENTRY PrintLines-2 {
  e.Lines = <Map { (e.Line) = <Prout e.Line>; } e.Lines>;
}

Если же блоки идут один за другим:

f {
  образец = результат : { образец = результат } : { образец = результат } ;
}

тогда получается, что вместо блока должно быть можно писать идентификатор функции! Это не я сейчас придумал, это Турчин почему-то не сделал.

f {
  образец = результат : f1 : f ;
}

Занятно, что это по сути то самое, что я и хотел (но вместо двоеточия писать "трубу").

> Можно и как аргумент передать:
> <{} <{ <{ }>} аргументы> >

<> может иметь смысл внутри {} только в правой части после =

<{ = }
  <{ = <{ = }> }
    аргументы
  >
>

и я это плохо читаю, вот так разносить угловые скобки - это к лисперам. Двоеточие как раз позволяет записывать без них и форматировать фигурными скобками.

>> Запись {arg} не может быть вызовом в Рефал, поскольку это определение блока.
>> Не хочется делать из него LISP, у меня от однотипных скобочек
>> в глазах рябит.
> А в чем тогда смысл блока? Если мы говорим, что это по
> сути функция, но не функция с явным вызовом.

Блок состоит из предложении и принимает аргумент, когда вызывается. Запись {аргумент} для меня не ясна.

>> Сейчас вызов именованной ф. такой и есть.
> <{}> - вот вызов анонимной (блока). Семантика за <> сохраняется - вызвать.

Да, вот так вызывается в Рефал-5-Лямбда:

<{} arg> // arg м.б. пустым

>> Сломалась, потому такое прописывается в правилах кодирования. В Си обязывают форматировать
>> фигурные скобки отступами.) С другой стороны, не обязательно же все вызывать
>> без имени. Когда ф. небольшая и нет имени, тогда можно, иначе
>> объявить дурным тоном.
> <{} <{ <{ }>} аргументы>> - ломает читабельность, но можно и так:
> <{}
>     <{
>         <{ }>
>      } аргументы>

Я не могу это прочитать. Сначала надо лезть в середину. У нас текст для людей принято читать слева направо, сверху вниз. Двоеточие как раз и решает этот вопрос:

Go {
=
: { обр = рез }
: { обр = рез аргументы }
: { обр = рез }
}

<> нужны, когда требуется вызвать подряд несколько функций, и их результаты последовательно поместить в выражении-результате. Я лучше буду ковырять машинный код, чем разбирать нагромождение вложенностей <> больше 2-х.

>>
>> Разве что, формально, ; среди аргументов не может быть.
> ; они ввели в виду того, что for (инит; луп-кондишене; инкремент) отделить
> явно условие выхода из цикла и икнремент, так как в такой
> записи:
> for (arg1, arg2, arg3, ..., )
> невозможно определить какой из аргументов за что отвечает. Либо ограничить for (arg1,
> arg2, arg3)
> и запись for (i = 0, j = 0;;) будет невалидной.

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

>> Ну вот это обычно рвёт сишникам шаблон примерно как синтаксис Rust.
> Рвет, все потому-что, ни в одном ЯП нет описания почему ввели именно
> такой, а не другой синтаксис. То есть никто (из создателей языков)
> не хочет пояснить людям, что ими двигало при выборе. Многие скажут
> - потому-что в С так, другие скажут не хотел как в
> Лиспе и т.д. Хотел сделать "С с классами", о чем это
> говорит? Правильно, жди синтаксис С.

Потому что берётся первый попавшийся спецсимвол, в лучшем случае по аналогии с чем-то, вот и всё.)

С блоками в Рефал-5 мне более-менее понятно - похожи на систему уравнений из школьной математики. С вызовом <> не очень понятно, но что есть, то есть.

>> Добавлять надо, название обязывает: Ре[курсиыных] Ф[ункций] Ал [горитмический]. С именами
>> пока не уверен. Объявлять их в синтаксисе можно, между : и
>> { всё равно ничего не пишется. Но переусердствовать не хочется: если
>> начинается вложенность блоков больше 2-х, есть подозрение, что пора начинать декомпозицию,
>> выносить в отдельные функции.
> И думаю надо делать это через псевдоним:
> {
>  A = <{} аргумент>;
> }

В общем-то, вот такое:

идентификатор { } // в Рефал-М можно сократить до идентификатор;

имеет особый смысл - определяет идентификатор, который можно сопоставить с самим собой (типа enum в Си)

То есть {} может служить как синоним для имени текущего блока (даже несмотря на то, что у Турчина скобочки определены на уровне лексера).

Есть ещё такая функция Mu, которая не очень вписывается в программу, если её писать русскими словами. Она вызывает функцию по имени (используется в Map и т.п.):

<функция аргументы>

<Mu функция аргументы>

<Mu "функция" аргументы>

Ей хочется дать псевдоним из спецсимвола, м.б. заодно

<{функция} аргументы>

<{"функция"} аргументы>

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

>> Вот и не вижу возможность вызвать такое. Впрочем, раз есть модули, может
>> как-то для них пригодится. У модуля есть имя-идентификатор и пока транслятор
>> на такое выдаёт "имя модуля без функции не имеет смысла". Был
>> бы смысл писать туда тесты для функций модуля, например. Запустил модуль
>> отдельно - он сам себя протестировал. А при импорте модуля это
>> { } пропускается.
> Ну вот такое самоопределение-и-вызов
> <{
> } аргументы>

Имел ввиду, когда {} определено вне <> и именованных функций.

Ответить | Правка | К родителю #270 | Наверх | Cообщить модератору

275. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 21-Июн-24, 16:15 
>> И рекурсивный вызов будет таким:
>> <{ <{} аргументы> } аргументы>
> Здесь сначала вызовется (пустой?) блок во внутренних скобках, результат разместится вместо
> них, следом произойдёт вызов блока во внешних скобках. Пустой блок не
> является вычислимой функцией, т.е. первый вызов остановит программу. Если бы пустой,
> то получается, что результат вызова формирует тело внешнего блока, т.е. генерирует
> ф. во время исполнения -- это кажется довольно мощной штукой, но
> пока не ясно, как к этому подойти. Мысль использовать {} как
> псевдоним для текущей функции м.б. стоящая, но не в такой записи.

<{} аргументы> - это не пустой блок (анонимная функция) имелся ввиду, это псевдоним на родительский блок (анонимную функцию).

Запишем иначе рекурсивный пример анонимного блока:

<{ ...Некоторые предложения...И рекурсия...=<_ аргументы2> } аргументы1>

На этапе трансляции определяется по <{ - что это анонимный блок, парсится и внутри по <_ определяется рекурсия на родителя.

<{

<_

<Имя-функции

Вот эти три конструкции вызова функции определяются на этапе трансляции, ибо константны и однозначны.

А вот если меня функции это выражение или переменная

<arg1

то в рантайме.


> Потому на деле всё немного иначе:
> аргументы : { образец = результат } // "сахар" для <{ образец
> = результат } аргументы >
> но вторая запись позволена в любом месте выражения-результата, а первая только после
> него.
> Запись со скобками <> в Рефал-5-Лямбда используют, передавая блок аргументом в Map
> и подобные функции -- они и обеспечивают вызов блока в цикле.

А рекурсия у блоков в Рефал-5-Лямбда есть?


>> Можно и как аргумент передать:
>> <{} <{ <{ }>} аргументы> >
> <> может иметь смысл внутри {} только в правой части после =

Это {} не пустой блок имелся ввиду.

> Блок состоит из предложении и принимает аргумент, когда вызывается. Запись {аргумент} для
> меня не ясна.

{arg} - тут arg имелось ввиду содержимое блока (тело), сорри, условно написано, как и в случае с {}.


>> <{}> - вот вызов анонимной (блока). Семантика за <> сохраняется - вызвать.
> Да, вот так вызывается в Рефал-5-Лямбда:
> <{} arg> // arg м.б. пустым

Да, <{...Тело Блока...}> плюс неявный =; если явно не переопределен, и по факту в безаргументном он должен быть и переопределен.

<{ = какой-то результат; }> - вот так должен выглядеть безаргументный вызов анонимной функции (блока).


>> <{} <{ <{ }>} аргументы>> - ломает читабельность, но можно и так:
>> <{}
>>     <{
>>         <{ }>
>>      } аргументы>
> Я не могу это прочитать. Сначала надо лезть в середину. У нас
> текст для людей принято читать слева направо, сверху вниз. Двоеточие как
> раз и решает этот вопрос:

это же вложенные вызовы, их всегда сложно читать в математическом стиле a(b(), c(d(), e))
Поэтому это лучше записывать через промежуточный результат:

d = d()
c = c(d, e)
b = b()
a = a(b, c)


> Я лучше буду ковырять машинный код, чем разбирать
> нагромождение вложенностей <> больше 2-х.

От такой a(b(), c(d(), e)) записи избавиться не возможно, она ведь допустима.

>[оверквотинг удален]
>>> Разве что, формально, ; среди аргументов не может быть.
>> ; они ввели в виду того, что for (инит; луп-кондишене; инкремент) отделить
>> явно условие выхода из цикла и икнремент, так как в такой
>> записи:
>> for (arg1, arg2, arg3, ..., )
>> невозможно определить какой из аргументов за что отвечает. Либо ограничить for (arg1,
>> arg2, arg3)
>> и запись for (i = 0, j = 0;;) будет невалидной.
> Дак при вызове обычной функции запятую использовать нельзя (только в дополнительных скобках).
> Надо было там аргументы разделять ;.)

ну да, вот бычное определение функции цикла

for (...)

то есть for (arg1, arg2, arg3, ..., ) принимает сколь-угодно много аргументов, и как тут понять какие из аргументов должны быть использованы на этапы инициализации, какие на этапе проверки условия и какие во время каждой итерации? Как определить этот порядок? у нас по факту три группы аргументов (переменных, выражений) и нам необходимо их четко разделять, какое правило применить?

Ну вот в С додумались, давайте сделаем не стандартно и введем новый разделитель в виде ;

Хотя этот for (arg1, arg2, arg3, ..., ) можно было по модулю 3 определить (три группы).

for (arg1, arg2, arg3, arg4, arg5, arg6, ..., )

arg1, arg4, argN mod 3 = 1 -> аргументы инициализации, всякие i = 0, j = 0, k = 0 .....
arg2, arg5, argN mod 3 = 2 -> условие выхода из цикла, проверка через AND истинности аргументов
arg3, arg6, argN mod 3 = 0 -> аргументы инкремента, i++, j++, k++

Короче, ересь :)


> Потому что берётся первый попавшийся спецсимвол, в лучшем случае по аналогии с
> чем-то, вот и всё.)

Ну вот дело вкуса. Но логика выбора должна быть описана в книгах, как минимум, написанных самими авторами ЯП.


> Есть ещё такая функция Mu, которая не очень вписывается в программу, если
> её писать русскими словами. Она вызывает функцию по имени (используется в
> Map и т.п.):
> <функция аргументы>
> <Mu функция аргументы>
> <Mu "функция" аргументы>
> Ей хочется дать псевдоним из спецсимвола, м.б. заодно
> <{функция} аргументы>
> <{"функция"} аргументы>
> но на первый взгляд кажется как-то притянуто, и слишком много кнопок нажимать.

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

> Имел ввиду, когда {} определено вне <> и именованных функций.

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

Ответить | Правка | К родителю #272 | Наверх | Cообщить модератору

279. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 22-Июн-24, 17:24 
>[оверквотинг удален]
>>> <{ <{} аргументы> } аргументы>
>> Здесь сначала вызовется (пустой?) блок во внутренних скобках, результат разместится вместо
>> них, следом произойдёт вызов блока во внешних скобках. Пустой блок не
>> является вычислимой функцией, т.е. первый вызов остановит программу. Если бы пустой,
>> то получается, что результат вызова формирует тело внешнего блока, т.е. генерирует
>> ф. во время исполнения -- это кажется довольно мощной штукой, но
>> пока не ясно, как к этому подойти. Мысль использовать {} как
>> псевдоним для текущей функции м.б. стоящая, но не в такой записи.
> <{} аргументы> - это не пустой блок (анонимная функция) имелся ввиду, это
> псевдоним на родительский блок (анонимную функцию).

Это я понял, дочитав сообщение. Воспринимается {} именно как пустой блок. Для меня такая запись оказалась неинтуитивна.

> Запишем иначе рекурсивный пример анонимного блока:
> <{ ...Некоторые предложения...И рекурсия...=<_ аргументы2> } аргументы1>
> На этапе трансляции определяется по <{ - что это анонимный блок, парсится
> и внутри по <_ определяется рекурсия на родителя.

По <_ определять не надо, это делается проще: как только начинается определение функции (в т.ч. анонимной) идентификатору _ присваивается ссылка на эту функцию. Так псевдоним можно будет использовать не только рядом с <, но и как угодно: сохранить в ящик, передать в <Prout _> (распечатает настоящее имя, если есть). Пока нет отладчика, гораздо проще вставлять одинаковый код для трассировки, а позже его удалять поиском.

> <{
> <_
> <Имя-функции
> Вот эти три конструкции вызова функции определяются на этапе трансляции, ибо константны
> и однозначны.

Ну с вызовом анонимной ф. (блока) нет вопросов. Некоторая сложность есть с генерацией кода, в Рефал-5-Лямбда строится замыкание, захватываются переменные - всё это не хочется. Это позволительно, если возвращать такую функцию в качестве результата.

> А вот если меня функции это выражение или переменная
> <arg1
> то в рантайме.

Если программист хочет перенести в рантайм, значит пусть явно пишет Mu.

>> Потому на деле всё немного иначе:
>> аргументы : { образец = результат } // "сахар" для <{ образец
>> = результат } аргументы >
>> но вторая запись позволена в любом месте выражения-результата, а первая только после
>> него.
>> Запись со скобками <> в Рефал-5-Лямбда используют, передавая блок аргументом в Map
>> и подобные функции -- они и обеспечивают вызов блока в цикле.
> А рекурсия у блоков в Рефал-5-Лямбда есть?

Нет. Зачем бы я тогда выдумывал, как это записывать. :)

>[оверквотинг удален]
> Это {} не пустой блок имелся ввиду.
>> Блок состоит из предложении и принимает аргумент, когда вызывается. Запись {аргумент} для
>> меня не ясна.
> {arg} - тут arg имелось ввиду содержимое блока (тело), сорри, условно написано,
> как и в случае с {}.
>>> <{}> - вот вызов анонимной (блока). Семантика за <> сохраняется - вызвать.
>> Да, вот так вызывается в Рефал-5-Лямбда:
>> <{} arg> // arg м.б. пустым
> Да, <{...Тело Блока...}> плюс неявный =; если явно не переопределен, и по
> факту в безаргументном он должен быть и переопределен.

Неявно =; определяется только в "блоках" из одного предложения и без скобочек (когда написал {}, то недолго и =; написать). Такие в <> не передать. А рекурсия на них нужна, как раз потому что неявное =; без неё потеряет смысл. :)

> <{ = какой-то результат; }> - вот так должен выглядеть безаргументный вызов
> анонимной функции (блока).

Да, так и выглядит в Рефал-5-Лямбда.

>[оверквотинг удален]
>> Я не могу это прочитать. Сначала надо лезть в середину. У нас
>> текст для людей принято читать слева направо, сверху вниз. Двоеточие как
>> раз и решает этот вопрос:
> это же вложенные вызовы, их всегда сложно читать в математическом стиле a(b(),
> c(d(), e))
> Поэтому это лучше записывать через промежуточный результат:
> d = d()
> c = c(d, e)
> b = b()
> a = a(b, c)

В Рефал нет промежуточного результата, он же "функциональный". Так что через :

>> Я лучше буду ковырять машинный код, чем разбирать
>> нагромождение вложенностей <> больше 2-х.
> От такой a(b(), c(d(), e)) записи избавиться не возможно, она ведь допустима.

Здесь всего 2 уровня, потому вполне читается.

>[оверквотинг удален]
>> Map и т.п.):
>> <функция аргументы>
>> <Mu функция аргументы>
>> <Mu "функция" аргументы>
>> Ей хочется дать псевдоним из спецсимвола, м.б. заодно
>> <{функция} аргументы>
>> <{"функция"} аргументы>
>> но на первый взгляд кажется как-то притянуто, и слишком много кнопок нажимать.
> В ней я думаю вообще нет необходимости, если реальзовать нормальный оператор "вызова
> функции".

Он как раз сейчас нормальный, времени трансляции, а Mu это динамическая "рефлексия".

>> Имел ввиду, когда {} определено вне <> и именованных функций.
> Ну можно подобие неймспейсов сделать, чтобы быстрее искать имена функций и т.д.
> изоляция.

Сейчас модули и выполняют роль "пространств имён", но иерархии нет, т.е. все имена модулей доступны из "глобального" неймспейса.

Ответить | Правка | К родителю #275 | Наверх | Cообщить модератору

282. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 23-Июн-24, 16:33 
> Ну с вызовом анонимной ф. (блока) нет вопросов. Некоторая сложность есть с
> генерацией кода, в Рефал-5-Лямбда строится замыкание, захватываются переменные - всё это
> не хочется. Это позволительно, если возвращать такую функцию в качестве результата.

надо тогда думать как сделать иначе, и возможно ли это не "стандартным" методом.

> Если программист хочет перенести в рантайм, значит пусть явно пишет Mu.

Если Mu это отдельный опкод callMu (условно), то думаю надо определить другой оператор вызова (отказаться от записи <Mu >)


> Нет. Зачем бы я тогда выдумывал, как это записывать. :)

Всё ясно, эт называется прочел базисный и забил на расширенный :) Кстати, странно блок чейнинга нет (труба), напрашивается.

Вот пример из книги: поиск подстроки a....z

Sub-a-z {
  e.1'a'e.2, e.2 :
           { e.3'z'e.4 = (e.1)'a'e.3'z'(e.4);
              e.3 = <Prout 'No substring a-z'>;
           };
  e.1 = <Prout "No 'a' found">;  
}


Это вот под-функция, которая должна была быть определена отдельно, как вспомогательная.

{
  e.3'z'e.4 = (e.1)'a'e.3'z'(e.4);
  e.3 = <Prout 'No substring a-z'>;
};


А теперь представим, что надо найти a...j...z получается цепочка (труба) - найди а | найди j | найди z.

И если мы скажем, что "найди а И найди j" потом "найди j И найди z", то это уже две функции:

Sub-a-j и Sub-j-z

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

Ответить | Правка | К родителю #279 | Наверх | Cообщить модератору

283. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 24-Июн-24, 18:54 
>> Ну с вызовом анонимной ф. (блока) нет вопросов. Некоторая сложность есть с
>> генерацией кода, в Рефал-5-Лямбда строится замыкание, захватываются переменные - всё это
>> не хочется. Это позволительно, если возвращать такую функцию в качестве результата.
> надо тогда думать как сделать иначе, и возможно ли это не "стандартным"
> методом.

Вернуть опкоды (или ссылку на них) сгенерированой функции не проблема. Проблема в том, что такие функции предполагаются для работы (в частности) с файлами. Захватываться в замыкание будет описатель файла (хендл), и его надо закрывать. Либо как-то запретить копирование хендла (на этапе трансляции), либо счётчик ссылок/сборщик мусора.

>> Если программист хочет перенести в рантайм, значит пусть явно пишет Mu.
> Если Mu это отдельный опкод callMu (условно), то думаю надо определить другой
> оператор вызова (отказаться от записи <Mu >)

Опкод один на вызов любых функций. "Адрес" вызова разный, у Mu он 0. Для вызова функций пока нет другой нотации, кроме <>. Заменить (точнее, ввести псевдоним для Mu) давно хочется, м.б. <# >. Этот же идентификатор заодно пригодится и для ящика, куда данные будут "сохраняться" как в /dev/null

>> Нет. Зачем бы я тогда выдумывал, как это записывать. :)
> Всё ясно, эт называется прочел базисный и забил на расширенный :) Кстати,
> странно блок чейнинга нет (труба), напрашивается.
> Вот пример из книги: поиск подстроки a....z

Исходный пример там какой-то странный:

<Sub-a-z e1 'a'eX'z' e2> = (e1) 'a'eX'z' (e2)

Переписал его так:

sub-a-z e.1 "a" e.x "z" e.2 = "a"e.x"Z";

go = <sub-a-z 'abababababababababababababababababababaababab'>;

Турчин пишет, что на таких данных квадратичная сложность:

«Тогда машина выделяет первое 'a', терпит неудачу в поиске 'z', удлиняет e1, вновь терпит неудачу в
поиске 'z', вновь удлиняет e1, и т.д.: наблюдается квадратичная зависимость количества операций от
длины выражения вместо линейной.»

В моей реализации опкоды образца и ПЗ читаются параллельно, в одном цикле. Опкод "буква 'z'" при отсутствии равного в ПЗ приводит к ситуации "увеличить границы e.1" вместо "выбрать следующий опкод образца" и будет повторно исполняться (сравниваться) со следующей буквой из ПЗ. Т.е. сложность так и остаётся линейной. :)

Наверное, они там что-то перемудрили с опкодами (их вроде бы сотня, а у меня всего 15).

> Sub-a-z {
>   e.1'a'e.2, e.2 :
>            {
> e.3'z'e.4 = (e.1)'a'e.3'z'(e.4);
>            
>   e.3 = <Prout 'No substring a-z'>;
>            };
>   e.1 = <Prout "No 'a' found">;
> }
> Это вот под-функция, которая должна была быть определена отдельно, как вспомогательная.

Это убивает саму идею Рефала, как по мне. Есть простая запись образца, если она на каких-то данных начнёт работать медленно, значит надо ускорять алгоритм сопоставления (рассматривать ПЗ с конца, например), а не усложнять программу. Либо структурировать входные данные, добавить побольше скобочек.

> {
>   e.3'z'e.4 = (e.1)'a'e.3'z'(e.4);
>   e.3 = <Prout 'No substring a-z'>;
> };
> А теперь представим, что надо найти a...j...z получается цепочка (труба) - найди
> а | найди j | найди z.

Вот тут могут возникнуть лишние откаты на каких-то данных, где много "a...j" без "z". Даже с трубой.

> И если мы скажем, что "найди а И найди j" потом "найди
> j И найди z", то это уже две функции:
> Sub-a-j и Sub-j-z
> то есть мы ввели дополнительную функцию, а это противоречие, мы ведь ввели
> блоки для того, чтобы избавиться от отдельного определения вспомогательной функции.

Так в Рефал-5-Лямбда "труба" получатся реализуется через : { } : { } : { }. Но, по-моему, надо просто написать в образце:

e.1 "a" e.x1 "j" e.x2 "z" e.2 =

и ускорять исполнитель, если потребуется.

Ответить | Правка | К родителю #282 | Наверх | Cообщить модератору

285. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 26-Июн-24, 16:45 
>[оверквотинг удален]
> <Sub-a-z e1 'a'eX'z' e2> = (e1) 'a'eX'z' (e2)
> Переписал его так:
> sub-a-z e.1 "a" e.x "z" e.2 = "a"e.x"Z";
> go = <sub-a-z 'abababababababababababababababababababaababab'>;
> Турчин пишет, что на таких данных квадратичная сложность:
> «Тогда машина выделяет первое 'a', терпит неудачу в поиске 'z', удлиняет e1,
> вновь терпит неудачу в
> поиске 'z', вновь удлиняет e1, и т.д.: наблюдается квадратичная зависимость количества
> операций от
> длины выражения вместо линейной.»

'abababababababababababababababababababaababab' почему на этом квадратичная сложность? Там же после N сравнений - z не найдено.

> Это убивает саму идею Рефала, как по мне. Есть простая запись образца,
> если она на каких-то данных начнёт работать медленно, значит надо ускорять
> алгоритм сопоставления (рассматривать ПЗ с конца, например), а не усложнять программу.
> Либо структурировать входные данные, добавить побольше скобочек.

Ну это природа алгоритмов такая, лучший, средний, худший случай. И поиск подстроки в строке не обделен этим, как не обделены всякие алгоритмы сортировки, которые зависят от входных данных.


> Вот тут могут возникнуть лишние откаты на каких-то данных, где много "a...j"
> без "z". Даже с трубой.

тут пример не строгий если говорить "найди а(все что угодно)j(все что угодно)z" и если после первого найденного "а" не найдется вообще "j", то и блок поиска "z" исполнять незачем.
ции.

> Так в Рефал-5-Лямбда "труба" получатся реализуется через : { } : {
> } : { }. Но, по-моему, надо просто написать в образце:
> e.1 "a" e.x1 "j" e.x2 "z" e.2 =
> и ускорять исполнитель, если потребуется.

ну вот труба в данном конкретном примере плохо применима.

Ответить | Правка | К родителю #283 | Наверх | Cообщить модератору

286. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 27-Июн-24, 12:24 
>[оверквотинг удален]
>> sub-a-z e.1 "a" e.x "z" e.2 = "a"e.x"Z";
>> go = <sub-a-z 'abababababababababababababababababababaababab'>;
>> Турчин пишет, что на таких данных квадратичная сложность:
>> «Тогда машина выделяет первое 'a', терпит неудачу в поиске 'z', удлиняет e1,
>> вновь терпит неудачу в
>> поиске 'z', вновь удлиняет e1, и т.д.: наблюдается квадратичная зависимость количества
>> операций от
>> длины выражения вместо линейной.»
> 'abababababababababababababababababababaababab' почему на этом квадратичная сложность?
> Там же после N сравнений - z не найдено.

Выше всё объяснение Турчина. Наверное, связано с форматом RASL, где 66 опкодов. Если в случае e-переменной из них генерируется какой-то цикл, получится квадратичная сложность. Разбираться с этим и проверять гипотезу не очень хочется, пока у меня занимает меньше строк и даёт линейную сложность.

>> Это убивает саму идею Рефала, как по мне. Есть простая запись образца,
>> если она на каких-то данных начнёт работать медленно, значит надо ускорять
>> алгоритм сопоставления (рассматривать ПЗ с конца, например), а не усложнять программу.
>> Либо структурировать входные данные, добавить побольше скобочек.
> Ну это природа алгоритмов такая, лучший, средний, худший случай. И поиск подстроки
> в строке не обделен этим, как не обделены всякие алгоритмы сортировки,
> которые зависят от входных данных.

Именно такой алгоритм приведён в книге, что бы проще понять, как всё это работает. Не обязательно его повторять 1 в 1. Вероятно, автор просто нашёл повод показать простейший пример, для чего нужны условия. Акцент на квадратичной сложности оказался не очень удачен: всё больше убеждает меня, что в моей реализации условия не нужны.

Ответить | Правка | К родителю #285 | Наверх | Cообщить модератору

287. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 27-Июн-24, 16:07 
> Выше всё объяснение Турчина. Наверное, связано с форматом RASL, где 66 опкодов.
> Если в случае e-переменной из них генерируется какой-то цикл, получится квадратичная
> сложность. Разбираться с этим и проверять гипотезу не очень хочется, пока
> у меня занимает меньше строк и даёт линейную сложность.

Непонимание возможно из-за того, что я мыслю "регульными выражениями", а тут на самом деле получается так:

e.1 "a" e.x "z" e.2 - читает так,

Удлиняй e.1 пока не натолконешся на "a", натолкнувшись на "a" - удлиняй e.x пока не натолкнешся на "z", ненатолкнувшись на "z", вернись и удлиняй e.1. И так получается квадратичная сложность (цикл в цикле), но зачем не натолкнувшись на "z" при первом столкновении с "a", происходит не остановка метчинга всего, а идет возврат в начальный цикл удлинения e.1? Где логика?.

> Именно такой алгоритм приведён в книге, что бы проще понять, как всё
> это работает. Не обязательно его повторять 1 в 1. Вероятно, автор
> просто нашёл повод показать простейший пример, для чего нужны условия. Акцент
> на квадратичной сложности оказался не очень удачен: всё больше убеждает меня,
> что в моей реализации условия не нужны.

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

Ответить | Правка | К родителю #286 | Наверх | Cообщить модератору

288. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 27-Июн-24, 16:53 
>[оверквотинг удален]
>> у меня занимает меньше строк и даёт линейную сложность.
> Непонимание возможно из-за того, что я мыслю "регульными выражениями", а тут на
> самом деле получается так:
> e.1 "a" e.x "z" e.2 - читает так,
> Удлиняй e.1 пока не натолконешся на "a", натолкнувшись на "a" - удлиняй
> e.x пока не натолкнешся на "z", ненатолкнувшись на "z", вернись и
> удлиняй e.1. И так получается квадратичная сложность (цикл в цикле), но
> зачем не натолкнувшись на "z" при первом столкновении с "a", происходит
> не остановка метчинга всего, а идет возврат в начальный цикл удлинения
> e.1? Где логика?.

Вопрос в том, как релизовано "удлиняй". В моей реализации это +1 к границе, грубо говоря. Если же под этим понимать "присвой e. символы от n до m", тогда получается цикл на каждом шаге. :)

Ответить | Правка | К родителю #287 | Наверх | Cообщить модератору

289. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 27-Июн-24, 17:34 
>[оверквотинг удален]
>> e.1 "a" e.x "z" e.2 - читает так,
>> Удлиняй e.1 пока не натолконешся на "a", натолкнувшись на "a" - удлиняй
>> e.x пока не натолкнешся на "z", ненатолкнувшись на "z", вернись и
>> удлиняй e.1. И так получается квадратичная сложность (цикл в цикле), но
>> зачем не натолкнувшись на "z" при первом столкновении с "a", происходит
>> не остановка метчинга всего, а идет возврат в начальный цикл удлинения
>> e.1? Где логика?.
> Вопрос в том, как релизовано "удлиняй". В моей реализации это +1 к
> границе, грубо говоря. Если же под этим понимать "присвой e. символы
> от n до m", тогда получается цикл на каждом шаге. :)

таким макаром ...a...j...z... - три вложенных цикла и с ростом е-переменных растет и сложность? Когда там сложность в худшем случае должна быть O(H*n), где H (haystack)- длина строки (где ищем) в символах, n (needle) - длина подстроки (что ищем) в символах.

И такую конструкцию ...a...j...z... (поиск нечеткой подстроки), можно разбить на четкие подстроки и пареллельно искать с помощью КМП за О(2*H) в худшем случае.

Ответить | Правка | К родителю #288 | Наверх | Cообщить модератору

271. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 20-Июн-24, 15:41 
> Если вызывать так:
>  <arg1 arg2 arg3> // (1)
> то есть нюансы. Сейчас в Рефал-М имя функции не обязательно идёт первым,
> можно
>  <х1 прибавить х2>
> и x2 (но не x1) в свою очередь может быть именем вычислимой
> функции и как-то вызываться в ф. прибавить. Тогда придётся запретить в
> (1) аргументами вычислимые функции - а это не дело, лучше использовать
> псевдоним _ или другой.

а в чем проблема?

<Имя-функции1 Имя-функции2 Имя-функции3>

нету разницы с

<arg1 arg2 arg3>

Эт как в шелле $0 имя скрипта первым аргументом при запуске, а тут имя функции первым аргументом.
И какая может быть проблема в том, что Имя-функции2 будет принимать в качестве аргумента Имя-функции3.

Имя-функции1
{
   A = <Имя-функции1 <Имя-функции2 Имя-функции3>> // вот тут можно подставить псевдоним для Имя-функции1, как "сахар"
}

<Имя-функции1 x> - оператор вызова функции по имени, как () в математике f(x).


Тут <arg1 arg2 arg3> если arg1 не равен "родительской функции", тогда - внешний вызов, иначе - рекурсивный. И arg2 и arg3 всегда будут считаться именами функций только в контексте вызова, то есть в <arg2 arg3> - тут вызывается именно arg2 как функция, так как идет первым в списке аргументов оператора "вызов функции по имени" - <>.

Как быть с анонимными функциями (безымянными)?

Определение:

Нет-имени
{

}

Как вызвать если нет имени? Как такое передать в оператор "вызов функции по имени" - <>.
А передадим на прямую.

<{...A...} Имя-функции2 Имя-функции3>

Тогда как такую рекурсивно вызвать? А вот тут уже НЕОБХОДИМ псевдоним, потому-что получается вот так:


<{
    A = <{ВОТ ТУТ Я ДОЛЖЕН ПРОДУБЛИРОВАТЬ КОД, КОТОРЫЙ ТАКЖЕ РЕКУРСИВНО ДОЛЖЕН ПРОДУБЛИРОВАТь.............} arg1 arg2>  // получается абсурдно


} Имя-функции2 Имя-функции3>

А по идее должно быть так:

<{
    A = <{@} arg1 arg2>


} Имя-функции2 Имя-функции3>

Тут {@} это псевдоним родителя для оператора "вызов функции по имени" - <>.


пс: выбранный псевдоним - условный, может быть на любой вкус :)

Ответить | Правка | К родителю #269 | Наверх | Cообщить модератору

273. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 20-Июн-24, 21:23 
>[оверквотинг удален]
>> можно
>>  <х1 прибавить х2>
>> и x2 (но не x1) в свою очередь может быть именем вычислимой
>> функции и как-то вызываться в ф. прибавить. Тогда придётся запретить в
>> (1) аргументами вычислимые функции - а это не дело, лучше использовать
>> псевдоним _ или другой.
> а в чем проблема?
> <Имя-функции1 Имя-функции2 Имя-функции3>
> нету разницы с
> <arg1 arg2 arg3>

Разница в том, что arg1 - это хоть что, а Имя-функции1 - только то, что может быть исполнено. Скобочка < в Рефал-5 вообще была обязана писаться слитно с именем функции. В Рефал-М не обязана, но вызывается первое, что может быть исполнено. Если arg1 может быть исполн, то и будет.

> Эт как в шелле $0 имя скрипта первым аргументом при запуске, а
> тут имя функции первым аргументом.
> И какая может быть проблема в том, что Имя-функции2 будет принимать в
> качестве аргумента Имя-функции3.

В <х1 прибавить х2> имя функции (прибавить) 2-м "аргументом".

> Имя-функции1
> {
>    A = <Имя-функции1 <Имя-функции2 Имя-функции3>> // вот тут можно
> подставить псевдоним для Имя-функции1, как "сахар"
> }

Так вычисления не ленивые.

> <Имя-функции1 x> - оператор вызова функции по имени, как () в математике
> f(x).

В Рефал функция Mu вызывает по имени. И поэтому она может отказать при исполнении, а <> связываются с вызываемым и проверяются на момент трансляции.

>[оверквотинг удален]
> КОТОРЫЙ ТАКЖЕ РЕКУРСИВНО ДОЛЖЕН ПРОДУБЛИРОВАТь.............} arg1 arg2>  // получается
> абсурдно
> } Имя-функции2 Имя-функции3>
> А по идее должно быть так:
> <{
>     A = <{@} arg1 arg2>
> } Имя-функции2 Имя-функции3>
> Тут {@} это псевдоним родителя для оператора "вызов функции по имени" -
> <>.
> пс: выбранный псевдоним - условный, может быть на любой вкус :)

Тут уже @ предлагается, а я из прошлого сообщения понял, что {} может служить псевдонимом. :)

Ответить | Правка | К родителю #271 | Наверх | Cообщить модератору

274. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 21-Июн-24, 15:04 
> Разница в том, что arg1 - это хоть что, а Имя-функции1 -
> только то, что может быть исполнено.

Ну да, иначе "undefined function" на уровне разбора исходного текста (если константное имя, не выражение), либо в рантайме.

Функция Mu ровно тоже самое и делает, и первый аргумент у нее это имя функции, которое может динамически вычислиться.

"""

<Mu s.F-name e.Expr> , или <Mu (e.String) e.Expr>

отыскивает функцию, имеющую имя s.F-name или <Implode e.String>

(когда оно задано в форме символьной строки) и применяет ее к выражению e.Expr , то есть замещается на <s.F-name e.Expr> . Если ни одна такая функция  не является  видимой   из вызова функции Mu , возникает ошибка.

"""

<arg1 arg2 arg3> - все три arg могут быть имена функций, но оператор <> берет первый аргумент как имя функции, которую надо вызвать.


> В <х1 прибавить х2> имя функции (прибавить) 2-м "аргументом".

А, ясно, типа <a + b>, за место польской нотации <+ a b>.
Думаю первый вариант "неудобный" в случае с большим количеством аргументов.

>> Имя-функции1
>> {
>>    A = <Имя-функции1 <Имя-функции2 Имя-функции3>> // вот тут можно
>> подставить псевдоним для Имя-функции1, как "сахар"
>> }
> Так вычисления не ленивые.

А где здесь "ленивость"?

> В Рефал функция Mu вызывает по имени. И поэтому она может отказать
> при исполнении, а <> связываются с вызываемым и проверяются на момент
> трансляции.

Ну да, а в чем проблема для оператора <> делать тоже самое, что и Mu? Зачем нужна вообще Mu?
Всегда на этапе трансляции можно определить какие функции с константными именами, а какие будут с вычисленными именами в рантайме. Мы же индентификаторы от выражений и переменных ведь отличаем, во время парсинга.


>> пс: выбранный псевдоним - условный, может быть на любой вкус :)
> Тут уже @ предлагается, а я из прошлого сообщения понял, что {}
> может служить псевдонимом. :)

Я же в "пс" написал - условный, можно и в один символ <_ arg2 arg3> - где _ - имя родительской функции, в контексте которой совершается данный вызов (рекурсивный). :)
И этот псевдоним родительской функции используется как для именных, так и для безымянных функций.

_ - это Я.

Ответить | Правка | К родителю #273 | Наверх | Cообщить модератору

277. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 22-Июн-24, 16:31 
>> Разница в том, что arg1 - это хоть что, а Имя-функции1 -
>> только то, что может быть исполнено.
> Ну да, иначе "undefined function" на уровне разбора исходного текста (если константное
> имя, не выражение), либо в рантайме.
> Функция Mu ровно тоже самое и делает, и первый аргумент у нее
> это имя функции, которое может динамически вычислиться.

В Рефал-5 Турчина скобочка < связывается с вызываемой функцией во время трансляции, а Mu определяет, что надо вызвать, во время исполнения.

> """
> <Mu s.F-name e.Expr> , или <Mu (e.String) e.Expr>
> отыскивает функцию, имеющую имя s.F-name или <Implode e.String>
> (когда оно задано в форме символьной строки) и применяет ее к выражению
> e.Expr , то есть замещается на <s.F-name e.Expr> . Если ни
> одна такая функция  не является  видимой   из
> вызова функции Mu , возникает ошибка.
> """

В Рефал-5-Лямбда < работает как Mu, т.е. во время исполнения ищет.

> <arg1 arg2 arg3> - все три arg могут быть имена функций, но
> оператор <> берет первый аргумент как имя функции, которую надо вызвать.

Да, и в Рефал-5 arg1 обязательно должен быть именем функции, иначе это ошибка.

>> В <х1 прибавить х2> имя функции (прибавить) 2-м "аргументом".
> А, ясно, типа <a + b>, за место польской нотации <+ a
> b>.
> Думаю первый вариант "неудобный" в случае с большим количеством аргументов.

<a + b> позволено в Рефал-М для удобства, например с функциями ⊕ и т.п. И если в Рефал-5 Mu это библиотечная функция, которая вызывается и что-то делает (что она вызывает другую функцию - это детали), то в Рефал-М это часть исполнителя опкодов: Mu никак не определена, интерпретатор видит её как "0-ю" функцию и вместо останова по ошибке ищет, что можно вызвать.

>>> Имя-функции1
>>> {
>>>    A = <Имя-функции1 <Имя-функции2 Имя-функции3>> // вот тут можно
>>> подставить псевдоним для Имя-функции1, как "сахар"
>>> }
>> Так вычисления не ленивые.
> А где здесь "ленивость"?

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

>> В Рефал функция Mu вызывает по имени. И поэтому она может отказать
>> при исполнении, а <> связываются с вызываемым и проверяются на момент
>> трансляции.
> Ну да, а в чем проблема для оператора <> делать тоже самое,
> что и Mu? Зачем нужна вообще Mu?
> Всегда на этапе трансляции можно определить какие функции с константными именами, а
> какие будут с вычисленными именами в рантайме. Мы же индентификаторы от
> выражений и переменных ведь отличаем, во время парсинга.

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

>>> пс: выбранный псевдоним - условный, может быть на любой вкус :)
>> Тут уже @ предлагается, а я из прошлого сообщения понял, что {}
>> может служить псевдонимом. :)
> Я же в "пс" написал - условный, можно и в один символ
> <_ arg2 arg3> - где _ - имя родительской функции, в
> контексте которой совершается данный вызов (рекурсивный). :)
> И этот псевдоним родительской функции используется как для именных, так и для
> безымянных функций.
> _ - это Я.

_ выглядит интересно, поскольку запись |_ похожа на сокращение от "Lаmbda". :) А вот среди скобочек <> не факт, что хорошо смотрится.

Ответить | Правка | К родителю #274 | Наверх | Cообщить модератору

280. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 23-Июн-24, 14:22 
> В Рефал-5 Турчина скобочка < связывается с вызываемой функцией во время трансляции,
> а Mu определяет, что надо вызвать, во время исполнения.
> В Рефал-5-Лямбда < работает как Mu, т.е. во время исполнения ищет.

Для меня всякие builtin-ы вроде Mu, всегда считались контр-интуитивными. Функция Mu ведь не на Рефале написана. И формальное представление в ввиде обычной вызываемой функции <Mu > не верно. Надо было отдельным оператором оформить.

>> <arg1 arg2 arg3> - все три arg могут быть имена функций, но
>> оператор <> берет первый аргумент как имя функции, которую надо вызвать.
> Да, и в Рефал-5 arg1 обязательно должен быть именем функции, иначе это
> ошибка.

На этапе трансляции - константное имя.

> <a + b> позволено в Рефал-М для удобства, например с функциями ⊕
> и т.п.

А как это однозначно парсится с <Имя-функции арг1 арг2> ? Аргументом функции может быть и имя другой функции.

<+ a b> или <b a +> что в таких случаях? Какое правило определения аргумента как имени вызываемой функции?


> И если в Рефал-5 Mu это библиотечная функция, которая
> вызывается и что-то делает (что она вызывает другую функцию - это
> детали), то в Рефал-М это часть исполнителя опкодов: Mu никак не
> определена, интерпретатор видит её как "0-ю" функцию и вместо останова по
> ошибке ищет, что можно вызвать.

Не библиотечная функция, а часть языка (builtin функция), и вызов Mu происходит через стандартный опкод call (условно), вызывая напрямую по указателю Mu. Если в Рефал-М на уровне отдельного опкода реализована Mu, то это равносильно новому оператору языка, про который я указал выше.


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

ну, своего рода RPC?

> _ выглядит интересно, поскольку запись |_ похожа на сокращение от "Lаmbda". :)
> А вот среди скобочек <> не факт, что хорошо смотрится.

Тут просто надо произвести "эргономический анализ" и выбрать символ :)
Учитывая рекурсивность языка, частота использования данного символа будет высока, поэтому должно быть максимально эргономический выбор с точки зрения клавиатуры (с учетом раскладок).

Ответить | Правка | К родителю #277 | Наверх | Cообщить модератору

284. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 24-Июн-24, 19:46 
>> В Рефал-5 Турчина скобочка < связывается с вызываемой функцией во время трансляции,
>> а Mu определяет, что надо вызвать, во время исполнения.
>> В Рефал-5-Лямбда < работает как Mu, т.е. во время исполнения ищет.
> Для меня всякие builtin-ы вроде Mu, всегда считались контр-интуитивными. Функция Mu ведь
> не на Рефале написана. И формальное представление в ввиде обычной вызываемой
> функции <Mu > не верно. Надо было отдельным оператором оформить.

Так было устроено при Турчине, Add и Sub так же не на Рефал написаны. "Операторы" сейчас получаются  = : и <>. Плюс , которую не очень хочу делать: придётся обязательно копировать данные для возможности отката и усложнять исполнитель, после чего начинаются странные идеи, а не разрешить ли заодно <> в образце.

В Рефал-М можно определить идентификатор , или ^, который внешне будет похож на оператор, можно думать о синониме.

>>> <arg1 arg2 arg3> - все три arg могут быть имена функций, но
>>> оператор <> берет первый аргумент как имя функции, которую надо вызвать.
>> Да, и в Рефал-5 arg1 обязательно должен быть именем функции, иначе это
>> ошибка.
> На этапе трансляции - константное имя.

enum;   // константное имя, может быть аргументом функции в <>
ящик 1; // константное имя, может быть аргументом функции в <>
функция =; // вычислимая, подходит как имя функции в <>

>> <a + b> позволено в Рефал-М для удобства, например с функциями ⊕
>> и т.п.
> А как это однозначно парсится с <Имя-функции арг1 арг2> ? Аргументом функции
> может быть и имя другой функции.

Первая вычислимая функция однозначно связывается со скобками (опкоду закрывающей > присваивается ссылка на опкоды вызываемой ф.). Транслятор в этом месте вообще "деревянный", размещает опкоды  условно вот так:

< арг1 арг2 >+Имя-функции

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

> <+ a b> или <b a +> что в таких случаях? Какое
> правило определения аргумента как имени вызываемой функции?

Во втором случае зависит от a и b. Если a функция, значит остальное - аргументы. Если нет, то правило применяется дальше.

>> И если в Рефал-5 Mu это библиотечная функция, которая
>> вызывается и что-то делает (что она вызывает другую функцию - это
>> детали), то в Рефал-М это часть исполнителя опкодов: Mu никак не
>> определена, интерпретатор видит её как "0-ю" функцию и вместо останова по
>> ошибке ищет, что можно вызвать.
> Не библиотечная функция, а часть языка (builtin функция), и вызов Mu происходит
> через стандартный опкод call (условно), вызывая напрямую по указателю Mu. Если
> в Рефал-М на уровне отдельного опкода реализована Mu, то это равносильно
> новому оператору языка, про который я указал выше.

Библиотечные функции реализованы так, что библиотека требует подключения, если используется. Можно другую библиотеку подключить (точнее, нужно будет сделать новую, а имеющуюся оставить как вариант для совместимости). Возможность вызвать исполнитель из библиотечной функции принципиально отсутствует, то есть Mu в библиотеке реализовать нельзя, можно только дать имя.

Опкод для неё точно такой как и для вызова других функций, что написанных на Рефал, что библиотечных. В этом вся хитрость. Это как с инструкцией IA32 call 0 - она вроде есть, но процессор словит исключение, поскольку по тому адресу нет памяти. Исполнитель такое же исключение и обрабатывает.

>> Mu может принять аргументом прочитанный из внешнего файла текст. Плюс, структура опкодов
>> такова, что гипотетически можно передать их по сокету и исполнять Mu.
> ну, своего рода RPC?

Если передавать не имена методов, а опкоды - может получиться и X12 или X13, например. :)

>> _ выглядит интересно, поскольку запись |_ похожа на сокращение от "Lаmbda". :)
>> А вот среди скобочек <> не факт, что хорошо смотрится.
> Тут просто надо произвести "эргономический анализ" и выбрать символ :)
> Учитывая рекурсивность языка, частота использования данного символа будет высока, поэтому
> должно быть максимально эргономический выбор с точки зрения клавиатуры (с учетом
> раскладок).

Пока получается, что самый эргономичный - это пустой блок :: или :; для хвостового вызова.

Ответить | Правка | К родителю #280 | Наверх | Cообщить модератору

276. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 22-Июн-24, 00:23 
>Зачем нужна вообще Mu?

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

Ответить | Правка | К родителю #273 | Наверх | Cообщить модератору

278. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 22-Июн-24, 16:42 
>>Зачем нужна вообще Mu?
> Mu функция ведь не подобие eval функции. Динамически ведь нельзя сконструировать функцию,
> чтобы потом ее исполнить. Полезность Mu была бы именно в случае
> eval, куда передается исходный текст функции сгенерированный в рантайме.

Mu это "рефлексия". Сейчас eval можно обеспечить вызовом <System "refal" ...>. Если же делать функцию Evil, создавать инстанс транслятора и передавать в него исходный текст, то первый вопрос - зачем это вообще нужно. В реализации Турчина есть функции для работы с "метакодом" Dn и Up. Мне технически проще сгенерировать в поле зрения опкоды и их исполнить: все обрабатываемые данные и так являются опкодами; часть проверок (скобочки) будет выполняться на этапе трансляции. Не очень понятно пока, как это записывать. М.б. задействовать [].

Ответить | Правка | К родителю #276 | Наверх | Cообщить модератору

281. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 23-Июн-24, 15:20 
> Mu это "рефлексия". Сейчас eval можно обеспечить вызовом <System "refal" ...>. Если
> же делать функцию Evil, создавать инстанс транслятора и передавать в него
> исходный текст, то первый вопрос - зачем это вообще нужно. В
> реализации Турчина есть функции для работы с "метакодом" Dn и Up.

"""
http://www.refal.net/chap6_r5.html#6.2.%20МЕТАКОД

Для того, чтобы записывать РЕФАЛ-программы, которые оперируют с РЕФАЛ-программами

"""

Можно на одном диалекте интерпретировать другой диалект :)

Ответить | Правка | К родителю #278 | Наверх | Cообщить модератору

244. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 03-Июн-24, 20:18 
> Существуют диалекты Рефала

http://www.refal.net/~arklimov/refal6/

Вот такой еще есть :)

Ответить | Правка | К родителю #241 | Наверх | Cообщить модератору

246. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 04-Июн-24, 10:33 
>> Существуют диалекты Рефала
> http://www.refal.net/~arklimov/refal6/
> Вот такой еще есть :)

"появился в Переславле-Залесском (ИПС РАН)"

https://github.com/Mazdaywik/direct-link/blob/master/refal-c...

Для меня такая запись не вполне очевидна, без изучения особенностей синтаксиса:

e.2 = <WriteLn 'Hello'> = <WriteLn 'World'>;

Посередине - это правое выражение или левое?

e.2 = <WriteLn 'Hello'>, <WriteLn 'World'>;

Вот так бы делал я, по аналогии с запятой из Си (это один из немногих действительно императивных операторов в Си, который мало кто знает). В Рефал-5 достаточно завернуть 1-ю WriteLn в вызов функции, отбрасывающей результат.

e.2 = <Ignore <WriteLn 'Hello'>> <WriteLn 'World'>;

Ответить | Правка | К родителю #244 | Наверх | Cообщить модератору

247. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 04-Июн-24, 10:56 
> Для меня такая запись не вполне очевидна, без изучения особенностей синтаксиса:

Ну вот и я не могу понять, такой синтаксис создают, чтобы людям легче было читать или машинам?

Ответить | Правка | К родителю #246 | Наверх | Cообщить модератору

249. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 04-Июн-24, 12:20 
>> Для меня такая запись не вполне очевидна, без изучения особенностей синтаксиса:
> Ну вот и я не могу понять, такой синтаксис создают, чтобы людям
> легче было читать или машинам?

А что ждать от одного из первых ЯП? В LISP вообще сплошные однотипные скобочки, и "всех устраивает", но из курса CS MIT убрали.

Для сравнения Рефал-2:


$ cat Fibonacci.ref
    entry go
    extrn first, last, lengw
    extrn add, sub, mul, div, dr
    extrn repeat(multe)
    extrn inc(p1), dec(m1), textToNumber(cvb), numberToText(cvd)
go = '\n'<MakeResult<Fibonacci /555/>>
Fibonacci
    /0/   (v(N)a) v(N)b =
    s(N)k (v(N)a) v(N)b = (va)<Fibonacci<dec sk>(vb)<add(va)vb>>
    s(N)k               = <Fibonacci sk(/0/)/1/>
JustLength
    w1e2 = <inc<JustLength e2>>
         = /0/
PadTextLeft s(O)ps(N)le(O)t = <repeat<sub(sl)<JustLength et>>sp>et
MakeResult
    s(N)ws(N)k =
    s(N)ws(N)k(v(N)x)e1 =+
        <PadTextLeft ' 'sw<numberToText sk>>'| '<numberToText vx>'\n'+
        <MakeResult sw<inc sk>e1>
    v(B)1 = <MakeResult<inc<JustLength<numberToText<JustLength v1>>>>/1/v1>

И развивал язык кто и с какими целями? Математик сидит два часа и думает над теоремой, потом хлопает себя по лбу и пишет "очевидно, что..." :)

Мне не нравятся угловые скобки, хочется какой-то сахар, например:

= arg1 "arg2" | fun1 0 | fun2; // = <fun2 <fun1 arg1 "arg2"> 0>;

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

Ответить | Правка | К родителю #247 | Наверх | Cообщить модератору

251. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 05-Июн-24, 14:34 
> М.б. удастся задействовать двоеточие, поскольку и так используется в Расширенном Рефале. Раньше времени не хочется занимать лишние спец.символы, сейчас можно свободные определять как функции.

Думаю, во всем виноват Гильберт со своим формализмом. И естественный язык должен описывать всея и все, и формализм излишен (он для машин). Мне легче страницу текста Канта прочитать, где одно предложение на целый лист, и ясно уловить заложенную мысль, чем Расселовский один параграф из Принципии Математики. Я что машина (вычислитель, распознаватель), чтобы интерпретировать формальные символы? Тут порочный круг, для формализма нужен вычислитель (распознаватель), а для вычислителя - формализм (определитель). Естественный язык - такой же формализм (но не полный по тьюрингу). И вычислитель его - человек, который легко с этой задачей справляется. А вот символьный формализм - для машин. Открываешь на архив.орг любую статью по математике - читать невозможно, один формализм (формулы и символы). А потом удивляются, там ошибка, тут ошибка, короче ересь.

пс: = arg1 "arg2" | fun1 0 | fun2; // = <fun2 <fun1 arg1 "arg2"> 0>;

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

Ответить | Правка | К родителю #249 | Наверх | Cообщить модератору

252. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 05-Июн-24, 16:10 
>[оверквотинг удален]
> легче страницу текста Канта прочитать, где одно предложение на целый лист,
> и ясно уловить заложенную мысль, чем Расселовский один параграф из Принципии
> Математики. Я что машина (вычислитель, распознаватель), чтобы интерпретировать формальные
> символы? Тут порочный круг, для формализма нужен вычислитель (распознаватель), а для
> вычислителя - формализм (определитель). Естественный язык - такой же формализм (но
> не полный по тьюрингу). И вычислитель его - человек, который легко
> с этой задачей справляется. А вот символьный формализм - для машин.
> Открываешь на архив.орг любую статью по математике - читать невозможно, один
> формализм (формулы и символы). А потом удивляются, там ошибка, тут ошибка,
> короче ересь.

Есть такие ЯП, где описывается всё словами. Они читаются хуже даже "птичьих" ЯП (где всё из комбинаций спецсимволов). Первоочередная задача ЯП не сделать программу понятной для каждого человека (её всё равно никто не понимает досконально, поскольку все детали в голове не удержать одновременно), а позволить как можно быстрее сориентироваться в коде, найти нужное место. Потому придуманы все эти комментарии с разметкой, форматирование, стили написания кода.

Я пишу вот так в некоторых случаях:

if (!(n < size))

специально, что бы глаз цеплялся за такую "неоптимальную" запись.

> пс: = arg1 "arg2" | fun1 0 | fun2; // = <fun2
> <fun1 arg1 "arg2"> 0>;
> чтобы понять это, я должен прочитать документацию на естественном языке,

Это обычная "труба" из командной строки. Если ЯП применяется в Linux, то такой синтаксис "всем известен".

> зачем это жонглирование из одной формальной системы в другую?

Что бы читать слева-направо. В некоторых случаях это удобнее, поскольку соответствует порядку исполнения. М.б. стрелочка там была бы нагляднее, или |>, но скобочки <> уже заняты.

Ответить | Правка | К родителю #251 | Наверх | Cообщить модератору

254. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 05-Июн-24, 17:46 
> (её всё равно никто не понимает
> досконально, поскольку все детали в голове не удержать одновременно)

Но и "Войну и мир" никто досконально не знает.

"""
В романе выведено более 550 персонажей, как вымышленных, так и исторических.
"""

Он разве заранее все это в голове держал (весь сценарий), а потом взялся и написал?


"""
В наброске предисловия к «Войне и миру» Толстой писал, что в 1856 году начал писать повесть, «герой которой должен был быть декабрист, возвращающийся с семейством в Россию. Невольно от настоящего я перешёл к 1825 году… Но и в 1825 году герой мой был уже возмужалым, семейным человеком. Чтобы понять его, мне нужно было перенестись к его молодости, и молодость его совпала с … эпохой 1812 года… Ежели причина нашего торжества была не случайна, но лежала в сущности характера русского народа и войска, то характер этот должен был выразиться ещё ярче в эпоху неудач и поражений…». Так Лев Николаевич постепенно пришёл к необходимости начать повествование с 1805 года.
"""

> Я пишу вот так в некоторых случаях:
> if (!(n < size))
> специально, что бы глаз цеплялся за такую "неоптимальную" запись.

А оптимальность во все этом формализме - это вообще отдельная тема. Порядок тех же образцов в Рефале влияет на оптимальность? Кстате, что там с параллельным сопоставлением образцов? Возможно ли такое?

> Что бы читать слева-направо. В некоторых случаях это удобнее, поскольку соответствует порядку
> исполнения. М.б. стрелочка там была бы нагляднее, или |>, но скобочки
> <> уже заняты.

Если человеку надо понять, что делает код, ему просто надо прочитать описание (документацию), зачем читать символьный код, если описать его до любого уровня мелочей можно на естественном языке. Человек не код должен читать. Код должен быть исполнен вычислителем, а результат сравнен с ожидаемым от него значением.

А когда дело доходит до документации, сразу приходит ясность двойной работы. И поэтому болт на документацию, я уже напрограммировал код. Промолчу про челеджи на самый нечитаемый код, театр абсурда. Давайте мериться в собственной дурости. Самодурство!!!

Ответить | Правка | К родителю #252 | Наверх | Cообщить модератору

257. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 06-Июн-24, 12:50 
>[оверквотинг удален]
> году начал писать повесть, «герой которой должен был быть декабрист, возвращающийся
> с семейством в Россию. Невольно от настоящего я перешёл к 1825
> году… Но и в 1825 году герой мой был уже возмужалым,
> семейным человеком. Чтобы понять его, мне нужно было перенестись к его
> молодости, и молодость его совпала с … эпохой 1812 года… Ежели
> причина нашего торжества была не случайна, но лежала в сущности характера
> русского народа и войска, то характер этот должен был выразиться ещё
> ярче в эпоху неудач и поражений…». Так Лев Николаевич постепенно пришёл
> к необходимости начать повествование с 1805 года.
> """

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

>> Я пишу вот так в некоторых случаях:
>> if (!(n < size))
>> специально, что бы глаз цеплялся за такую "неоптимальную" запись.
> А оптимальность во все этом формализме - это вообще отдельная тема. Порядок
> тех же образцов в Рефале влияет на оптимальность? Кстате, что там
> с параллельным сопоставлением образцов? Возможно ли такое?

В смысле, сравнивать сразу несколько предложений и откидывать неподходящие? Возможно даже, что если компилировать Рефал в Си, такое проделает транслятор под Эльбрус, но под рукой нет, что бы проверить. Если исполнять в несколько потоков, то не факт, что оно того стоит, учитывая накладные расходы на синхронизацию.

Очевидно, если начала у образцов совпадают, можно оптимизировать, даже преобразовать в изоморфную Рефал-программу (скорее всего, Рефал-5-Лямбда так делает). Наверняка можно развить идеи КМП-алгоритма, или компилировать в какой-то КА, но пока не время.

>> Что бы читать слева-направо. В некоторых случаях это удобнее, поскольку соответствует порядку
>> исполнения. М.б. стрелочка там была бы нагляднее, или |>, но скобочки
>> <> уже заняты.
> Если человеку надо понять, что делает код, ему просто надо прочитать описание
> (документацию), зачем читать символьный код, если описать его до любого уровня
> мелочей можно на естественном языке. Человек не код должен читать. Код
> должен быть исполнен вычислителем, а результат сравнен с ожидаемым от него
> значением.

Я не знаю, что надо человеку, но почти весь код, какой мне приходилось видеть, документация не сопровождает. И далеко не весь код легко и просто описать естественным языком, когда дело доходит до деталей. В Рефале возможно добавлять в код незначащие (для машины) слова, что бы человеку проще его читать. При этом все эти скобочки Рефала отходят на второй план, это как пунктуация в обычном тексте - читаем же, когда с запятыми проблемы. :) Вот пример Рефала, когда документация к функции не имеет смысла https://vk.com/video-667081_456239155?t=2h39m40s

> А когда дело доходит до документации, сразу приходит ясность двойной работы. И
> поэтому болт на документацию, я уже напрограммировал код. Промолчу про челеджи
> на самый нечитаемый код, театр абсурда. Давайте мериться в собственной дурости.
> Самодурство!!!

Документация обычно описывает, что делает код, зачем и почему, а не как он это делает.

Ответить | Правка | К родителю #254 | Наверх | Cообщить модератору

258. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 07-Июн-24, 14:15 
> Документация обычно описывает, что делает код, зачем и почему, а не как
> он это делает.

если чтение исходного кода программы превращается в своего рода реверсинг (обратная инженерия), то это не нормальный ЯП.

Ответить | Правка | К родителю #257 | Наверх | Cообщить модератору

261. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 07-Июн-24, 15:56 
>> Документация обычно описывает, что делает код, зачем и почему, а не как
>> он это делает.
> если чтение исходного кода программы превращается в своего рода реверсинг (обратная инженерия),
> то это не нормальный ЯП.

Я пока других ЯП не видел. Программист пишет, пишет, доходит до предела Чейтина, потом начинает часто болеть, у него умирают три бабушки, случается пожар, после чего зовут реверсера разобраться. При избыточном финансировании этот момент оттягивается вливанием свежих сил, скруглением углов и прочими активностями. Кто поумнее, те заранее начинают проектировать следующую версию.

Ответить | Правка | К родителю #258 | Наверх | Cообщить модератору

156. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 29-Май-24, 19:17 
придумал новый термин для ЯП - синтаксический диабет :)

пс: 33331

Ответить | Правка | К родителю #147 | Наверх | Cообщить модератору

162. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 30-Май-24, 07:02 
Вот тут https://youtu.be/YkltHXngryg?t=395 как раз в Переславле-Залесском выступает Андрей Петрович Немытых, а рядом надпись "Refal-5 Version ПЗ". И его спрашивают: а что за странное версионирование, а что вообще означает "ПЗ"... По-моему, "ПЗ" применительно к вопросу означает "слово из 6-ти букв, вторая "И" (фиаско семантики конференций).
Ответить | Правка | Наверх | Cообщить модератору

181. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Sw00p aka Jerom (?), 30-Май-24, 17:28 
> Вот тут https://youtu.be/YkltHXngryg?t=395 как раз в Переславле-Залесском выступает
> Андрей Петрович Немытых, а рядом надпись "Refal-5 Version ПЗ". И его
> спрашивают: а что за странное версионирование, а что вообще означает "ПЗ"...
> По-моему, "ПЗ" применительно к вопросу означает "слово из 6-ти букв, вторая
> "И" (фиаско семантики конференций).

:))))))) я так громко давно не смеялся, эт что за самодурство такое?

"""
- Если я завтра скомпилирую исходники это уже новая версия?
- Да - новая версия. Ну как так она традиция такая возникла в 90-ых давно.
"""

Убило :)) Нестандартно, еще бы, открываем сайт http://refal.botik.ru/ , а там:

«Не стоит прогибаться под изменчивый мир,
Пусть лучше он прогнется под нас ... »
                        Андрей Макаревич

ч. т. д.

Ответить | Правка | Наверх | Cообщить модератору

193. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 31-Май-24, 10:32 
>[оверквотинг удален]
>> Андрей Петрович Немытых, а рядом надпись "Refal-5 Version ПЗ". И его
>> спрашивают: а что за странное версионирование, а что вообще означает "ПЗ"...
>> По-моему, "ПЗ" применительно к вопросу означает "слово из 6-ти букв, вторая
>> "И" (фиаско семантики конференций).
> :))))))) я так громко давно не смеялся, эт что за самодурство такое?
> """
> - Если я завтра скомпилирую исходники это уже новая версия?
> - Да - новая версия. Ну как так она традиция такая возникла
> в 90-ых давно.
> """

Небось влепили макрос __DATE__ в исходники, в 90-х наверное нормой было такое, пока не придумали именовать rar архив датой. :) Так то номер билда и сейчас некоторые икрементируют безусловно - мало ли какие зависимости или опции сборки поменялись.

Другое дело, что с тех 90-х исходники никто и не трогал. Вот, нашёлся один смелый (я не рискнул) и добавил поддержку Юникода. Тоже традиция. Зато пакетная база - собственная. Есть чем гордиться и заодно дедов поучить.

> Убило :)) Нестандартно, еще бы, открываем сайт http://refal.botik.ru/ , а там:
> «Не стоит прогибаться под изменчивый мир,
> Пусть лучше он прогнется под нас ... »
>            
>            
>  Андрей Макаревич
> ч. т. д.

Если программирование - раздел математики, то это обычный Даннинг и Крюгер. Мир ни под кого не прогибается, а вычисляется по формуле полной вероятности. Если хватит мощностей учесть каждый атом.

Ответить | Правка | Наверх | Cообщить модератору

188. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от Аноним (190), 30-Май-24, 20:39 
О! Рефал :)) Нам его один дедок в инсте очень немного преподавал (и вроде бы даже он был автором!). Но когда я послушал суть языка, махнул рукой на это "чудо" и никогда не касался.
Ответить | Правка | К родителю #147 | Наверх | Cообщить модератору

194. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 31-Май-24, 10:35 
Вряд ли автором - тот преподавал в инстах США со времён СССР. Соавтор, наверное. Ну в общем-то верный выбор, я бы студентом тоже так сделал. Теперь Переславль-Залесский славится не Рефалом, а Свободой ПО, не всем ясно, от чего или кого.
Ответить | Правка | Наверх | Cообщить модератору

73. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +1 +/–
Сообщение от Аноним (73), 28-Май-24, 13:08 
А ты хочешь ее продавать? Ну продавай, может и купит кто. Не покупают?

Ты же хочешь программку выложить на гитхаб под открытой лицензией, но так, чтобы тебе за нее деньги платили. Правильно все понимаю?

Ответить | Правка | К родителю #34 | Наверх | Cообщить модератору

94. "В июне в Переславле-Залесском состоится конференция СПО в вы..."  +/–
Сообщение от n00by (ok), 28-Май-24, 14:43 
Понимаешь неправильно.
Ответить | Правка | Наверх | Cообщить модератору

Архив | Удалить

Рекомендовать для помещения в FAQ | Индекс форумов | Темы | Пред. тема | След. тема




Партнёры:
PostgresPro
Inferno Solutions
Hosting by Hoster.ru
Хостинг:

Закладки на сайте
Проследить за страницей 		Created 1996-2024 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру