M>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>Я то считаю что могу объяснить.

Вы невероятно заблуждаетесь.

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

Здравствуйте, Temoto, Вы писали:

M>>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>>Я то считаю что могу объяснить.

T>Вы невероятно заблуждаетесь.

T>Ну, или можете, но не используете этих возможностей в документах описания языка и на данном форуме.
Что именно не понятно из прочитанного? Задайте вопрос. Отвечу. Исправлю. Для того и выложил что б обсудить.

M>>>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>>>Я то считаю что могу объяснить.

T>>Вы невероятно заблуждаетесь.

T>>Ну, или можете, но не используете этих возможностей в документах описания языка и на данном форуме.
B>Что именно не понятно из прочитанного? Задайте вопрос. Отвечу. Исправлю. Для того и выложил что б обсудить.

Я вам написал что не так ещё в марте. http://www.rsdn.ru/forum/philosophy/3944143.aspx

Автор: batu
Дата: 02.09.10

Прошло уже почти 4 месяца. Вы ничего не ответили и ничего не исправили.

Выложили чтобы обсудить — вы это получили, вне всяких сомнений. Только всё обсуждение проходит на всё том же никому непонятном языке, а документация к проекту не меняется.

Здравствуйте, Temoto, Вы писали:

M>>>>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>>>>Я то считаю что могу объяснить.

T>>>Вы невероятно заблуждаетесь.

T>>>Ну, или можете, но не используете этих возможностей в документах описания языка и на данном форуме.
B>>Что именно не понятно из прочитанного? Задайте вопрос. Отвечу. Исправлю. Для того и выложил что б обсудить.

T>Я вам написал что не так ещё в марте. http://www.rsdn.ru/forum/philosophy/3944143.aspx

Автор: batu
Дата: 02.09.10

T>Прошло уже почти 4 месяца. Вы ничего не ответили и ничего не исправили.

T>Выложили чтобы обсудить — вы это получили, вне всяких сомнений. Только всё обсуждение проходит на всё том же никому непонятном языке, а документация к проекту не меняется.
За отсутствие новой версии документа виноват конечно. Я переписываю демку. В ходе общения здесь и в ходе собственно программирования возникли новые мысли. Это еще раз повлияло на синтакис. Потому примеры и кое что еще прийдется заново переписывать. Я решил как задышит транслятор, так уже и займусь вылизыванием документа. Будет издевательством предлагать новую версию зная что она уже старая. Например, было две разных операции присвоения. Я придумал как можно обойтись одной. Хотя суть их по прежнему будет разной. А знак теперь будет один. И т.п.
А насчет того что вы предложили на двух страницах введение сделать так я сделал. Если пропустить правила описания грамматики которые применяются у меня (ну, а где ж их еще писать если не в начале?) как раз за ними и идут основные концепции.

Здравствуйте, batu, Вы писали:

B>Спасибо. Я действительно плохо объясняю. Внутри себя в голове есть и там все понятно..

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

Здравствуйте, Temoto, Вы писали:

T>Примерно так же, как использование декларативных сканнеров, например lex, лучше чем

Если тебе хочется декларации, то есть, к примеру, Rx.

T>>Примерно так же, как использование декларативных сканнеров, например lex, лучше чем

AVK>Если тебе хочется декларации, то есть, к примеру, Rx.

Это что, надо поправить фразу что-ли? Хорошо.

"Примерно так же, как использование декларативных сканнеров, например lex или Rx, лучше чем"...

остальной смысл сообщения не изменился.

Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, batu, Вы писали:

B>>Спасибо. Я действительно плохо объясняю. Внутри себя в голове есть и там все понятно..

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

Здравствуйте, batu, Вы писали:

B>Здравствуйте, Mamut, Вы писали:

M>>>>Ну так и делается Никто не требует, чтобы все было внутри цикла И никто не собирается писать цикл длинной 10 000 строчек.

M>>>>Когда занимаешься отладкой программы, можно не уследить за логикой или нечаянно удалить это событие. Могут возникнуть проблемы. Оформив это циклом, мы четко и явно прописываем, что именно мы делаем
B>>>Видимо у меня не получается объяснить. Можешь представить что тебе нужно написать программу моделирующую деятельность предприятия или управление государством? Вот если кто-то уволится, то кем, за что..по каким законам и приказам. Какие действия после увольнения. Кто уполномочен и какие процедуры при найме нового человека.. И так по всей деятельности предпрития. Задолбаешься в лоб писать. А потом могут поменяться инструкции и за ним появится новая схема управления. А если разбить на события, то писать прогу, и апгретить будет значительно легче. События сами позацепляются за что нужно, да еще и можно протестить на полноту и прочую дребдень.

M>>Ничего мире не происходит автоматически. Аналогично и события никуда автоматически не привяжутся. Их привяжет программист. Забудет привязать — огребет все те же проблемы.
B>Я думаю прочитав подробнее ты поймешь механизм. С одной стороны подписки на инициирующие события. Затем условие запускающее событие и процедура обработки. Связь эта более динамична и не требует привязки где-то в самом тексте программы. Однако позволяет осуществить проверку наличия связей и процедур обработки, и отсутствие "висящих" событий.

Как это она не требует привязки??? Берем пример:

Dim Integer Len:                                              ' Длина текста
Dim Integer Ind                                                ' Индекс проверяемого символа
Exp Boolean EndE=(Len=Ind):                        ' Логическое выражение
New Event EndText                                         ' Формирование события
 {Condition=:EndE
   Connection.Add [|Ind.Chang, Len.Change]
      Event: =MsgBox(“Конец текста”)
 }

Событие EndText само появилось? Условие EndE само появилось? Связка Connection.Add сама появилась?

M>>Описанная схема напоминает механимз слоты/сигналы, что есть в Qt, но с дополнительными плюшками и сахаром. Согласен, похожая схема была бы интересна, как дополнение к существующим инструментам.
B>Спасибо! Сегодня какой-то удачный день. За пол года сегодня ты второй кто эту фишку понял. До этого было сплошное фи. Если так и дальше пойдет, то еще через полгода появятся въехавшие в гуппирование и в реализацию. Это уже будет перелом. Пока въехавших нет.

Ну если ты не можешь внятно объяснить, что это такое, то

Здравствуйте, batu, Вы писали:

B>Здравствуйте, Mamut, Вы писали:


M>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>Я то считаю что могу объяснить. Для этого надо просто заинтересованые слушатели.

Здесь все заинтересованные. Но за 100 сообщений флейма появился только один вменяемый пример. И то со второй-третьей попытки

B>А я и реализовываю потихоньку. Одному трудно. Хотя бы 4 человека было. И для критики и для работы. Оппонировать самому себе тяжело. Можно глупостей наделать. Да и может кто чего подскажет. А план есть. И как делать и что и для чего..

Для этого и нужно:
1. Выложить код на сайт типа GitHub, вместе с планом, описанием и т.п. Чтобы заинтересованные люди не искали, где сейчас последняя версия, а могли в любой момент ее централизованно скачать. А то и поучаствовать
2. Не разводить воду и делать пассы руками, а выложить хотя бы пять примеров по схеме:

1. Задача
2. Решение этой задачи на Lada
3. Чем это решение лучше, чем уже существующие

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

Здравствуйте, Temoto, Вы писали:

T>"Примерно так же, как использование декларативных сканнеров, например lex или Rx, лучше чем"...

Rx это не декларативный сканер.

T>>"Примерно так же, как использование декларативных сканнеров, например lex или Rx, лучше чем"...

AVK>Rx это не декларативный сканер.

То есть он не совсем к месту был упомянут?

Здравствуйте, Mamut, Вы писали:

M>Здравствуйте, batu, Вы писали:

B>>Здравствуйте, Mamut, Вы писали:


M>>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>>Я то считаю что могу объяснить. Для этого надо просто заинтересованые слушатели.

M>Здесь все заинтересованные. Но за 100 сообщений флейма появился только один вменяемый пример. И то со второй-третьей попытки

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

Sub Sort (A[]: Integer)
{
  Dim  Integer ( I,   J,  Count=Int(A.Lenght/2)-1,  NewCount )           ' Определение переменных
  Exp  Integer {  Next= J+1  Last= A.Lenght-J-1   Prev= A.Lenght-J-2}    ' Определение блоков  
  Block   {
       ChangUp      { If A[J]<A[Next] A[J] ОБМЕН A[Next]} 
       ChangDown { If A[Prev]<A[Last]  A[Prev] >< A[Last] }               ' Операция >< обмен значениями
              }
  If A.Lenght<2  Exit Sub Sort               ' Если есть что сортировать
  For I=0 To Count
    {
        NewCount:= A.Lenght-I-1
        For J=I To NewCount {ChangUp ChangDown}
    }
} ' Конец процедуры

Вот пример вычисления NOD с помощью автоматов. Используя механизм событий. Сначала создаем класс автоматов NOD

Automation Nod ((I, J): Integer)
{
    Starter (More, Less)
    New  Event More{Condition=:I<J Connection.Add (| I.Chang, J.Change) Sub{J:=J-I}
    New  Event Less  {Condition=:I<J Connection.Add (| I.Chang, J.Change ) Sub{I:=I-J}
    Public Event Eq {Condition=:I=J Connection.Add (| I.Chang, J.Change ) Sub{Nod.Off}
}

Выполнение оператора Off влечет за собой одноименное событие. Автомат может выключить себя сам, а возможно это сделать и вне автомата методом Off. Такая схема позволяет запустить на выполнение несколько автоматов и синхронизировать их выполнение событиями. Данный автомат останавливается самостоятельно после вычисления. Кроме того внешнее событие Eq может послужить для информирования о готовности вычисления.

Синхронизация с событием Eq, и выключение автомата Nod.

Dim Integer (A=5, B=35)
New Nod AV (A, B)                         'Создание автомата Nod
AV.OnStart                                'Включение одновременно со стартером.
Event {Connection=:AV.Eq}                 'Оператор синхронизации. Здесь выполнение программы остановится ожидая события AV.Eq
Nod.Stop                                  'Выключение автомата Nod

И пример логического разбора. Интерпретации. Определим следующие предикаты.

Predicate 
  {
     Positive (X: Integer) {Positive=X>0} ' Предикат  Positive
     Четное (X: Integer) {Здесь проверка на четность. Знак операции И не проходит}
  }

Теперь определим множество, на котором будет выполняться интерпретация. В нашем случае это множества целых чисел и объекты-значения I и Y.
Dim Integer (I=-50000, Y=108)
Высказывание со знаком вопроса называется целевым высказыванием. Этот знак запускает не императивное вычисление, а осуществляет попытку логического разбора. Определим целевое высказывание.
If Positive (I ^ Y)?
Сейчас мы покажем как можно решить эту задачу без возведения в 108 степень. Для этого определим следующие высказывания на множестве Integer и Positiv.

Utterance
{
    ForAll (А: Integer, B: Positive) ‹Positive (A)  Positive (A^B) ›
    ForAll (А: Integer, B: Positive)‹Четное (B)  Positive (A^B) ›
}

Знак "следует" здесь не прошел. На его месте квадратик. Замечу, что в качестве параметров могут быть не только объекты классов или типов, но и объекты принадлежащие множеству или принадлежащие множеству определенному предикатом, как в нашем примере(Positive).
Интерпретация выполняется так.
На первом шаге резолюции ищутся высказывания относительно заданного целевого высказывания Positive (I ^ Y) на множестве функций "^", и находящееся в правой части после знака "следует" на предмет нельзя ли его упростить. Оказывается, у нас есть такое высказывание есть и не одно. Выбираем первое. Проверяем область действия (А: Integer: B: Positiv) и нас она нас устраивает. И, стало быть, мы можем смело полагаться на исследование высказывания в левой части от знака "следует". Это предикат Positive (A). Данный предикат уже упростить не возможно. Он вычисляется, (вместо А подставляем значение -5000) и дает отрицательный результат. При положительном результате вопрос был бы закрыт, но не все потеряно, у нас есть еще не проанализированное высказывание и область действия нас устраивает. Возвращаемся к нему. Проверяем предикат Четное (X: Integer) на истинность, подставляя в качестве параметра значение 108, и получаем положительный результат. Целевое высказывание определено без вычислений.


M>Для этого и нужно:
M>1. Выложить код на сайт типа GitHub, вместе с планом, описанием и т.п. Чтобы заинтересованные люди не искали, где сейчас последняя версия, а могли в любой момент ее централизованно скачать. А то и поучаствовать
M>2. Не разводить воду и делать пассы руками, а выложить хотя бы пять примеров по схеме:
M>

M>1. Задача
M>2. Решение этой задачи на Lada
M>3. Чем это решение лучше, чем уже существующие

Сори, я не знаю что это за сайт... Расскажи..Попробую.. Но вот чем решения на lade лучше это большй вопрос. В принципе все это где-то и в каком то виде есть в разных языках. Я предлагаю инструмент в котором есть выбор. Это не все любопытные примеры..Но так навскидку. Еще много интересного есть. Я принялся написать документ для быстрого входа чисто на примерах. Но, не так быстро дело идет. Думаю месяц у меняяя уйдет на это.

M>А то с одной стороны ты хочешь, чтобы хоть кто-то заинтересовался этим проектом, но с другой стороны не прикладываешь усилий для того, чтобы им заинтересовались
Еще раз сори. Я работаю один. Мне еще на хлеб надо зарабатывать. А работы много. Не успеваю. Хотя чуствую что дело идет к завершению.

Здравствуйте, Mamut, Вы писали:

M>А то с одной стороны ты хочешь, чтобы хоть кто-то заинтересовался этим проектом, но с другой стороны не прикладываешь усилий для того, чтобы им заинтересовались
Благодарю за участие.

Здравствуйте, batu, Вы писали:

B>Здравствуйте, Mamut, Вы писали:

B>Посмотрел Node. Не то совсем.. игрушка.. Я повторюсь что такое события у меня.

B>События определяются объектами класса Event. Класс Event имеет свойства Condition, Connection, Fire и Event. Свойство Condition это выражение, при истинности которого событие считается происшедшим и запускается процедура обработки события, если она определена (значние свойства Event). Отсутствие значения в свойстве Condition означает безусловное событие. Проверка свойства Condition происходит при выполнении событий определенных свойством Connection, которое связывает данное событие со списком внешних событий (подписаться на событие). Таким образом, свойство Connection представляет собой группу ссылок на события, к которым подписывается создаваемое событие. Так как свойство Connection представляет собой группу событий, то запуск проверки свойства Condition может происходить от срабатывания одного события из группы или от срабатывания всех событий группы. Группа событий в свойстве Connection называется комплектом. И соответственно комплекты бывают вида И/Или. Эти два вида комплектов отличаются методом объединения в группы. Режим Или определяется группой в квадратных скобках с вертикальной чертой. Остальные варианты группировки определяют режим И.
B>Свойство Event содержит группу операторов для выполнения, если процедура обработки события определена в самом событии или ссылку на процедуру или блок обработки события. По этой причине процедура обработки события самостоятельное понятие и не является обязательно процедурой. Это может быть и блок, перехватывающий события. Таким методом происходит перехват и обработка ошибок, которые тоже события.


Ок. Это понятно. В принципе, звучит толково.

Ждем дальше, глядишь, по чуть-чуть разберем остальные аспекты языка.

Здравствуйте, Temoto, Вы писали:

T>То есть он не совсем к месту был упомянут?

К месту. Просто это куда более универсальный инструмент.

Здравствуйте, Eugeny__, Вы писали:

E__>Ок. Это понятно. В принципе, звучит толково.

E__>Ждем дальше, глядишь, по чуть-чуть разберем остальные аспекты языка.
Спасибо. Смотрю так в диалоге лучше получается чем документ вывалить. Тогда я позволю о группах объяснится. Это принципиальная часть и касается работы виртуальной машины. К сожалению подстрочные и надстрочные знаки я не могу здесь проставить, но надеюсь будет понятно. Хотя лажа, конечно.

Обычно (и привычно) группирование объектов осуществляется скобками. Собственно для этого их и придумали. В системе используются круглые («)» и «(»), квадратные («[» и «]»),), фигурные («{» и «}»),), текстовые (««» и «»»),) и именные («"») скобки.
С назначением текстовых и именных скобок мы уже познакомились.
В системе Lada существует два вида применения скобок для группирования объектов и для предопределения групп. Группирование объектов это то, что мы делаем, объединяя скобками буквы, лексемы, операторы и вообще все объекты. Если скобки пустые (т.е. нет объектов в скобках) то это предопределение группы. Предопределение заключается в определении метода группирования объектов, которых еще нет, но есть необходимость объединить будущие объекты в группу с какими-то общими свойствами по методу доступа, обращения, способов добавления или удаления, фактически определяя класс (или метод) объединения будущих объектов. Или как мы будем называть, определяя организацию группы (Organization).

Группирование объектов. Правила выполнения групп.

Группирование объектов допускается двумя способами с последовательным выполнением группы и произвольным выполнением группы (классы Tape и Group). Поступая в виртуальную машину, каждый объект выполняется. Поступление объектов группы в виртуальную машину выполняется либо последовательно (класс Tape), либо в произвольном порядке (класс Group). Результат выполнения оператора или объекта в виртуальной машине завершается присвоением логического значения обязательному свойству для всех объектов Result. Если в результате исполнения в теговой машине объекта или оператора получим Result =True, то будем называть такое выполнение успешным выполнением объекта, или там где понятно, что речь идет об успешном выполнении просто выполнение. Если Result = False будем считать объект не выполненным или выполненным не успешно. Успешное выполнение группы зависит от успешного выполнения объектов содержащихся в группе (успешное выполнение содержимого группы), способа объединения в группу и свойств группы. Группы имеют свойства Min, Max и Extract.
Свойство Extract определяет количество успешно выполненных объектов в группе для того, что бы выполнение содержимого группы считалось успешным. По умолчанию значение свойства Extract=0, что означает обязательное успешное выполнение всех объектов группы. Значение свойства Extract по умолчанию можно изменить на часто применяемое Extract=1 знаком «.» сразу за открывающей скобкой, что означает успешное выполнение группы, если успешно выполнился точно один объект из группы. Любое значение свойства Extract можно определить значением после знака «.» следующего непосредственно без пробела за открывающейся скобкой.
Свойства Min и Max определяются соответственно подстрочным и надстрочным значением после закрывающей скобки и определяют минимальное и максимальное значение успешных выполнений содержимого группы для успешного выполнения группы. При успешном выполнении содержимого группы, если количество успешных выполнений меньше значения свойства Max выполнение группы продолжается. В противном случае выполнение группы прекращается.
Если после прекращение выполнения группы количество успешных выполнений больше или равно значению свойства Min, то выполнение группы считается успешным. В противном случае не успешным.
Значение свойства Min=0 допускает ни одного успешного выполнения группы. Значения свойств по умолчанию следующее Min=1, Max=1. Диапазон значений свойств Min и Max от 0 до 255 .
Значения свойств Min и Max можно определить не только подстрочным и надстрочным значением после закрывающей скобки, но и через точку после определения свойства Extract.


Группирование с последовательным выполнением. Класс Tape.

Группирование с последовательным выполнением определяется круглыми или фигурными скобками (объекты класса Tape) и допускает только последовательное выполнение объектов. При использовании группирования объектов круглыми скобками их необходимо разделять запятыми. Объекты, сгруппированные фигурными скобками нет необходимости разделять запятыми. Выбор применяемых скобок за программистом.

Пример 1. Присвоение свойствам группы Word значений Min=2 и Max=40

Word {Letter}2 40

Данная группа выполняется максимум 40 раз, но для ее успешного выполнения достаточно одного успешного выполнения группы.

Пример 2. Группирование операторов для многократного выполнения.

{
I:=J+ R-1
}225

Данная группа выполняется 25 раз, хотя для успешного ее выполнения достаточно выполниться 2 раза.

Группирование с произвольным выполнением. Класс Group

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

Пример 3. Группирование с произвольным доступом квадратными скобками.

If
[
X >0 {…}
X =0 {…}
X <0 {…}
]

В этом примере выполнение проверки трех условий может осуществляться одновременно.

Пример 4. Определение модификатора.

Determination Модификатор [. «Private» «Public» «Protected»]
Таким образом, мы определили модификатор как один из трех объектов «Private», «Protected» или «Public» содержащихся в квадратных скобках. Наличие прямого доступа здесь не принципиально.

Пример 5. Определение класса Group.

Public Class Group
{ Public Dim Integer Min=1
Public Dim Integer Max=1
Public Dim Integer Extract=0
}

Пример 6. Определение класса Group. Короткий вариант.

Public Class Group Public Dim Integer (Min=1, Max=1, Extract=0)

T>>То есть он не совсем к месту был упомянут?

AVK>К месту. Просто это куда более универсальный инструмент.

Отлично, тогда будет формулировка "Примерно так же, как использование декларативных сканнеров, например lex или куда-более-универсального-инструмента-Rx, лучше чем...". Надеюсь, вы теперь удовлетворены.

Но, на всякий случай, уточню: не было задачи, никто не искал инструмент. lex был упомянут для примера, чтобы показать что такой подход (а не lex или Rx или любой другой софт) лучше, чем миллионы if-ов.

M>>>>Нет, не вырулится. Если сам автор не может внятно объяснить, что он хочет, как могут понять сторонние люди? И вообще, если машина простая, может стоит начать ее реализовывать?
B>>>Я то считаю что могу объяснить. Для этого надо просто заинтересованые слушатели.

M>>Здесь все заинтересованные. Но за 100 сообщений флейма появился только один вменяемый пример. И то со второй-третьей попытки

B>Извини, в документе куча примеров.

Подавляющее большинство из которых выглядит так:

Пример 1.3. Именование объекта типа Integer присвоением значения Ширина свойству Name.

10 ‘ Name=: «Ширина» ’

операторы у меня тоже объекты и могут иметь имена и оператор, например Exit указывает имя объекта-оператора (а может и класса) из которого необходимо выйти. Получается например такая картина.
For i=0 to n
...
Exit I

То в операторе Exit I-это имя оператора For, а не имя переменной.

Что это за примеры? ЧТо это все значит? Какая практическая в них необходимость? Как их применять? На эти вопросы нет ни единого ответа.


B>Вот могу здесь варианты сортировки скинуть. Версия синтаксиса может и старая, но если где не тот знак это не принципиально.

B>

B>Sub Sort (A[]: Integer)
B>{
B>  Dim  Integer ( I,   J,  Count=Int(A.Lenght/2)-1,  NewCount )           ' Определение переменных
B>  Exp  Integer {  Next= J+1  Last= A.Lenght-J-1   Prev= A.Lenght-J-2}    ' Определение блоков  
B>  Block   {
B>       ChangUp      { If A[J]<A[Next] A[J] ОБМЕН A[Next]} 
B>       ChangDown { If A[Prev]<A[Last]  A[Prev] >< A[Last] }               ' Операция >< обмен значениями
B>              }
B>  If A.Lenght<2  Exit Sub Sort               ' Если есть что сортировать
B>  For I=0 To Count
B>    {
B>        NewCount:= A.Lenght-I-1
B>        For J=I To NewCount {ChangUp ChangDown}
B>    }
B>} ' Конец процедуры

B>

Переусложнение и загромождение на ровном месте. имхо.




B>Вот пример вычисления NOD с помощью автоматов. Используя механизм событий. Сначала создаем класс автоматов NOD

Что такое NOD?


B>

B>Automation Nod ((I, J): Integer)
B>{
B>    Starter (More, Less)
B>    New  Event More{Condition=:I<J Connection.Add (| I.Chang, J.Change) Sub{J:=J-I}
B>    New  Event Less  {Condition=:I<J Connection.Add (| I.Chang, J.Change ) Sub{I:=I-J}
B>    Public Event Eq {Condition=:I=J Connection.Add (| I.Chang, J.Change ) Sub{Nod.Off}
B>}
B>

B>Выполнение оператора Off влечет за собой одноименное событие. Автомат может выключить себя сам, а возможно это сделать и вне автомата методом Off. Такая схема позволяет запустить на выполнение несколько автоматов и синхронизировать их выполнение событиями.

Хотелось бы увидеть это на примере.


B>Данный автомат останавливается самостоятельно после вычисления. Кроме того внешнее событие Eq может послужить для информирования о готовности вычисления.

B>Синхронизация с событием Eq, и выключение автомата Nod.
B>

B>Dim Integer (A=5, B=35)
B>New Nod AV (A, B)                         'Создание автомата Nod
B>AV.OnStart                                'Включение одновременно со стартером.
B>Event {Connection=:AV.Eq}                 'Оператор синхронизации. Здесь выполнение программы остановится ожидая события AV.Eq
B>Nod.Stop                                  'Выключение автомата Nod
B>

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

B>И пример логического разбора. Интерпретации. Определим следующие предикаты.

B>

B>Predicate 
B>  {
B>     Positive (X: Integer) {Positive=X>0} ' Предикат  Positive
B>     Четное (X: Integer) {Здесь проверка на четность. Знак операции И не проходит}
B>  }
B>

B>Теперь определим множество, на котором будет выполняться интерпретация. В нашем случае это множества целых чисел и объекты-значения I и Y.
B>Dim Integer (I=-50000, Y=108)
B>Высказывание со знаком вопроса называется целевым высказыванием. Этот знак запускает не императивное вычисление, а осуществляет попытку логического разбора. Определим целевое высказывание.
B>If Positive (I ^ Y)?
B>Сейчас мы покажем как можно решить эту задачу без возведения в 108 степень. Для этого определим следующие высказывания на множестве Integer и Positiv.
B>

B>Utterance
B>{
B>    ForAll (А: Integer, B: Positive) ‹Positive (A)  Positive (A^B) ›
B>    ForAll (А: Integer, B: Positive)‹Четное (B)  Positive (A^B) ›
B>}
B>

B>Знак "следует" здесь не прошел. На его месте квадратик.

Естественно. Именно поэтому весь цивилизованный мир не использует странные символы в программах. Печальный опыт APL был не зря.

B>Замечу, что в качестве параметров могут быть не только объекты классов или типов, но и объекты принадлежащие множеству или принадлежащие множеству определенному предикатом, как в нашем примере(Positive).

Это называется, в частности, duck typing (утиная типизация).


B>Интерпретация выполняется так.
B>На первом шаге резолюции ищутся высказывания относительно заданного целевого высказывания Positive (I ^ Y) на множестве функций "^", и находящееся в правой части после знака "следует" на предмет нельзя ли его упростить. Оказывается, у нас есть такое высказывание есть и не одно. Выбираем первое. Проверяем область действия (А: Integer: B: Positiv) и нас она нас устраивает. И, стало быть, мы можем смело полагаться на исследование высказывания в левой части от знака "следует". Это предикат Positive (A). Данный предикат уже упростить не возможно. Он вычисляется, (вместо А подставляем значение -5000) и дает отрицательный результат. При положительном результате вопрос был бы закрыт, но не все потеряно, у нас есть еще не проанализированное высказывание и область действия нас устраивает. Возвращаемся к нему. Проверяем предикат Четное (X: Integer) на истинность, подставляя в качестве параметра значение 108, и получаем положительный результат. Целевое высказывание определено без вычислений.


Ну, это понятно. Prolog в качестве DSL'я для языка.



M>>Для этого и нужно:
M>>1. Выложить код на сайт типа GitHub, вместе с планом, описанием и т.п. Чтобы заинтересованные люди не искали, где сейчас последняя версия, а могли в любой момент ее централизованно скачать. А то и поучаствовать
M>>2. Не разводить воду и делать пассы руками, а выложить хотя бы пять примеров по схеме:
M>>

M>>1. Задача
M>>2. Решение этой задачи на Lada
M>>3. Чем это решение лучше, чем уже существующие

B>Сори, я не знаю что это за сайт... Расскажи..Попробую..

Тьфу, елки Даже ссылки приводил. Кратко: публичный онлайн репозиторий кода. Надеюсь, не надо объяснять, что такое репозиторий и контроль версий?

GitHub: git
Google Code: subversion/mercurial
Bitbucket: mercurial
Sourceforge: CVS/subversion/git
и т.п.

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

Просто выбор никого не интересует. Более тго, для этого есть Лисп Людей интересует именно «лучшесть». Насколько более эффективно новый язык позволит решать те или иные задачи.

B>Это не все любопытные примеры..Но так навскидку. Еще много интересного есть. Я принялся написать документ для быстрого входа чисто на примерах. Но, не так быстро дело идет. Думаю месяц у меняяя уйдет на это.

M>>А то с одной стороны ты хочешь, чтобы хоть кто-то заинтересовался этим проектом, но с другой стороны не прикладываешь усилий для того, чтобы им заинтересовались
B>Еще раз сори. Я работаю один. Мне еще на хлеб надо зарабатывать. А работы много. Не успеваю. Хотя чуствую что дело идет к завершению.

Для того, чтобы один раз выложить наработки на тот же GitHub требуется 2 минуты дествий (и еще 5, чтобы собственно установить git). Аналогично для любого другого онлайн-репозитория. Это если говорить про пункт 1 выше.