Может ли конкатенационный язык использовать префиксную нотацию?

Question

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

Итак, возможно ли иметь префиксную нотацию? Если это так, какие будут компромиссы?

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

5 dup *                             ! Multiply 5 by itself
3 2 -                               ! Subtract 2 from 3
(1, 2, 3, 4, 5) [2 >] filter length ! Get the number of integers from 1 to 5
                                    ! that are greater than 2

Выражения оцениваются слева направо: в первом примере 5 помещается в стек, затем dup дублирует верхнее значение в стеке, затем * умножает два верхних значения в стеке. Функции извлекают свой последний аргумент первым из стека: во втором примере, когда - называется, 2 находится на вершине стека, но это последний аргумент.

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

* dup 5
- 3 2
length filter (1, 2, 3, 4, 5) [< 2]

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

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

Answer 1

Ну, конечно, если ваши слова все еще с фиксированной арностью, то это просто вопрос выполнения токенов справа налево.

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

Answer 2

Я пишу такой язык прямо сейчас, как это происходит, и пока мне нравятся некоторые побочные эффекты использования префиксной нотации. Семантика основана на Радости:

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

Вот факториальная функция, например:

def 'fact [cond [* fact - 1 dup] [1 drop] dup]

Мне также легче рассуждать о коде, когда я пишу его, но у меня нет достаточного опыта работы с конкатенационными языками. Вот мой (вероятно, наивный) вывод функции карты над списками. Функция 'nb' отбрасывает что-то и используется для комментариев. 'stash [f]' входит в темп, запускает 'f' в остальной части стека, а затем возвращает темп обратно.

def 'map [q [cons map stash [head swap i] dup stash [tail dup]] [nb] is_cons nip]
nb [map [f] (cons x y) -> cons map [f] x f y
    stash [tail dup]    [f] (cons x y)       = [f] y (cons x y)
    dup                 [f] y (cons x y)     = [f] [f] y (cons x y)
    stash [head swap i] [f] [f] y (cons x y) = [f] x (f y)
    cons map            [f] x (f y)          = cons map [f] x f y

    map [f] [] -> []]

Answer 3

Я только что прочитал о языке Ом

Кажется, о чем ты говоришь. Из его описания (акцент мой):

Ом язык:

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

В нем также говорится, что он еще не закончен и еще многое изменит.

Тем не менее, это, кажется, работает, и действительно интересно как доказательство концепции.

Answer 4

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