Re: [stack] EWD 28: Djikstra's sort-of-concatenative language

see section 6, "Names", in www.nsl.com/k/f/f.htm.

! is f's equivalent of joy's i, and ' is the quotation operator, so
'+! leaves + on the stack, just as you suggest.

in f, 2 3 + leaves 5 on the stack, as you would expect, but 2 3 plus,
where plus is [+] leaves 2 3 [+] on the stack, so to evaluate, you 
must say 2 3 plus!.

'x takes x and pushes [x] onto the stack.  [X]! takes X and prepends
it to the queue (whence elements of X are serially evaluated.)

it's interesting (but not surprising) to learn that djikstra was
there first.

also, see van oormerssen's language 'false': http://wouter.fov120.com/false/index.html

----- Original Message ----- 
From: "kuwabatake" <[email protected]>
To: <[email protected]>
Sent: Monday, July 30, 2007 6:33 PM
Subject: [stack] EWD 28: Djikstra's sort-of-concatenative language


> I find Djikstra's writings very interesting, and I stumbled on this:
> 
> http://www.cs.utexas.edu/users/EWD/transcriptions/EWD00xx/EWD28.html
> 
> In the (short) paper, Djikstra describes a stack-based arithmetic
> language. At first, he has two types of ``words'' that can be
> concatenated: number words and operator words. When a number word is
> encountered, the number is pushed onto the stack; when an operator
> word is encountered, the operation is performed on the top of the
> stack and the result pushed. So far, so good; we could think of this
> language in the Joy-like way by reframing all words as functions stack
> -> stack.
> 
> The really interesting part comes in the middle of the paper: Djikstra
> proposes to make operator words behave just like number words, simply
> pushing the operator onto the stack. He then introduces the special
> word `E'(for evaluate) which, if there is an operator on top of the
> stack, makes the operator perform its action. In this language,
> pushing 1 2 + would give the stack 
> 
> 1 2 + 
> 
> but then pushing an E would give the stack 
> 
> 3
> 
> The result is that operators can sit on the stack just like numbers
> and `literals'. Djikstra goes on to introduce an environment of bound
> variables, but that doesn't interest me as much. To me, the
> introduction of E is a really significant idea. In Joy, popping + out
> of a list with
> 
> [+] first
> 
> is sort of messy; a meaningless token is now floating on the stack,
> needing a new quotation to be part of before it can be used in a
> meaningful way and muddying the expression-oriented way of looking at
> Joy. If Joy's + was instead defined as
> 
> + == '+ i
> 
> where '+ is primitive, then the single symbol '+ could be treated as a
> quotation, executable by combinators. The ambiguous symbol + is now
> just an ordinary definition. A language whose primitives are all like
> this would be somewhat Floy-like, where '+ replaces [+] (sort of...
> the analogy is a little complicated.)
> 
> In short: how about a language in which every word puts itself onto
> the stack, except for the `special' word i, which executes the
> function on top of the stack?
> 
> Whew, long post. Thoughts?
> 
> ~Daniel
> 
>