Introducing the Rabbit-vm
==================
Some time ago I made another attempt to lern stack-based, concatenative or tacit style of programming.
Joy has no define-primitive. I would like to use () instead of [].
Factor, with its 224MB-installation seems a lot more than i can chew.
So the Rabbit-vm came into existence.
I would like to introduce a few things i found on my way.
a teaspoon of syntactic sugar
==================
() (1 2 3) uncons (swons)dip
() (1 2 3) uncons swons^
This ^ as a shortcut for ()dip is, IMHO of great help for writing, and mutch more for reading code.
Rabbit has up to ^^^^, only for words, not for quotations. I think that works out very well.
(name)
`name
This is a small difference. The improvement is not in typing but in reading: `name is most of the time a name, passed to a function.
(name)first
,name
This is sometimes helpful, sometimes a small pitfall:
Construct a quotation that executes doc with name
(1) ,name (doc) cons i
(2) (name) first (doc) cons i
(3) name (doc) cons i
(4) (name doc) i
(5) name doc ---> name is not defined.
data == programm == stack / (1) define
=========================
This is the mantra of Scheme and Joy.
A definition in Rabbit-vm is like this:
(add) {a b -- c // add two numbers} (+) define
a teaspoon of sugar:
`add {a b -- c // add two numbers} (+) define
But i would like this:
add: +
Hmm??
[
add: {i i -- i // add two numbers} +
sub: -
mul: *
] define-from-list
With this as a start it evolved to:
BEGIN
add {i i -- i /add two numbers} +
sub {} -
mul {} *
END Letf.define
data == programm == stack / (2) recurse
==========================
From time to time i run into a pattern like this:
fac-2 doesn't work! Because copy+paste didn't change the name fac-1 into fac-2.
fac-1: ( 0 = )( zap 1 )( dup 1 - fac-1 * )if*
fac-2: dup 0 = ( zap 1 )( dup 1 - fac-1 * )if/
In the following 'loop' is just a symbol, that is going to be replaced by the name of the currently defined word. This saves typing and is an improvement on legibility.
fac-1: ( 0 = )( zap 1 )( dup 1 - loop * )if*
fac-2: dup 0 = ( zap 1 )( dup 1 - loop * )if/
data == programm == stack / (3) tests
=========================
`sample-tests {} BEGIN
*: 3 4 TX -> 12
+: 3 4 TX 5 6 TX -> 7 11
END define
data == programm == stack / (4) the pattern
============================
(a) write down, what you would like to write
(b) find a data-structure, you would like to work with
(c) write function foo: (a) -> (b)
stack and program-history or state-transition
===========================
The stack is an arbitrary complex data structur. Well, most of the time it looks like a stack and is unsed like a stack. The property arbitary-complex-data-structur includes arbitrary simple data structures like:
stack == 1
So, in order to liberate the stack from the burden of complexity and from the burden of state transition it is helpful to have an other data structur for:
state transition (== global varibles)
intermediate results (== local variables)
parameters (== function parameters)
This is what i call upstack, dmbarbour calls it a hand (i'm not sure if i know what he means.)
I think it's just context.
Rabbit-vm
======
W o r l d | r a b b i t - v m
|
hand/upstack/context (??? property-list)
|
|
( world of ) ------ parse --------->
( char strings ) <---- print ----------- VM <---> definitions (hashtable)
|
|
stack
(linked list)
Rabbit-vm does two things:
* parse: string of characters --> items
* execute as Joy does.
So, this is what i can contribute to the discussion.
I think there are lots of running implemetations of pure Joy somewhere in the internet, but the only ones i know about are Joy1 in scheme and C form John Cowan, njoy in OCaml from Christian Szegedy and Conca from Claude Marinier.
I don't know, is it a coincidence or did it just happen at the same time that Claude and i present the same idea within a few days.
The code is at sourceforge at Rabbit-vm. There is currently also a copy of this mail.
https://sourceforge.net/projects/rabbitvm/
Of course I would be happy about feedback.
Best regards
Heiko
> I would like to use () instead of [].Syntax design is hard. The argument for [] is that they’re non-shift
keys (on US keyboards) and they free up parentheses for their more
common meanings of grouping (mathematics) or comments (natural
language). I use {} for code quotations in Kitten because they give
you a syntax more resembling C, and that frees up [] for data
quotations (vectors).
> Factor, with its 224MB-installation seems a lot more than i can chew.I agree. :)
> () (1 2 3) uncons (swons)dipWe talked about this briefly on the Concatenative Programming G+
> () (1 2 3) uncons swons^
group[1], namely that higher-order functions are something like
adverbs, and seem to work well when they look syntactically like
inflections. You could make the combination of word+symbol invoke
“(word) symbol” and avoid a lot of nesting without making “^” special.
[1]: https://plus.google.com/103392068634106050064/posts/gEkDANFd7qp
> (name)I read those differently:
> `name
>
> This is a small difference. The improvement is not in typing but in reading: `name is most of the time a name, passed to a function.
(name) = “push a new quotation which calls ‘name’”
`name = “push the word ‘name’ itself”
Of course, they can have the same implementation.
> From time to time i run into a pattern like this:Forth implementations sometimes have a “recurse” word for this
> fac-2 doesn't work! Because copy+paste didn't change the name fac-1 into fac-2.
>
> fac-1: ( 0 = )( zap 1 )( dup 1 - fac-1 * )if*
>
> fac-2: dup 0 = ( zap 1 )( dup 1 - fac-1 * )if/
>
>
> In the following 'loop' is just a symbol, that is going to be replaced by the name of the currently defined word. This saves typing and is an improvement on legibility.
>
> fac-1: ( 0 = )( zap 1 )( dup 1 - loop * )if*
>
> fac-2: dup 0 = ( zap 1 )( dup 1 - loop * )if/
>
purpose. I prefer “recur” or “loop” because it lets you say cute
things like:
def repl: read evaluate print loop
> I think there are lots of running implemetations of pure Joy somewhere in the internet, but the only ones i know about are Joy1 in scheme and C form John Cowan, njoy in OCaml from Christian Szegedy and Conca from Claude Marinier.Do you want this to become the standard implementation of Joy? Joy
seems like the concatenative Scheme, in that it’s small and easy to
implement, so there are many incompatible implementations…
> I don't know, is it a coincidence or did it just happen at the same time that Claude and i present the same idea within a few days.That has a tendency to happen.
> The code is at sourceforge at Rabbit-vm.You should check it into the repo on SourceForge so that it can be
browsed under “Code” instead of by downloading the tarball. :)
Hi Jon,
thank you for your feedback.
() or []
In my opinion () is a little better to read than [].
((())) [[[]]] not much, just a little.
My app translates BEGIN begin [ ( ) ] end END to ( ( ( ( ) ) ) )
These four types of braces can be used interchangeable as long
as they match.>> () (1 2 3) uncons (swons)dip> We talked about this briefly on the Concatenative Programming G+
>> () (1 2 3) uncons swons^
> group[1], namely that higher-order functions are something like
> adverbs, and seem to work well when they look syntactically like
> inflections.
dip is the most commonly used word in Joy code i have written so far.
I don't know, if this is because of my way of coding.
> You could make the combination of word+symbol invoke
> “(word) symbol” and avoid a lot of nesting without making “^” special.
I'm not sure about this. Currently i have
`name -> (name)
,name -> (name)first
@name -> get definition of name
!name -> set definition of name
>name -> push TOS to name
<name -> pop from name and push to stack
~apply at name
For instance the following programm
`name {} () define
1 >name 2 >name 3 >name 4 >name
(swap)~name
@name
should push (3 4 2 1) to stack.
But i don't use it!
Instead i can't use >name just as name for a word.
I like
,name^^
as abbreviation for
((name)first)dip2
Currently this sugar is in the parser. Maybe i try to make primitives from it.
> Forth implementations sometimes have a “recurse” word for this
> purpose. I prefer “recur” or “loop” because it lets you say cute
> things like:
>
> def repl: read evaluate print loop
I didn't know this. Thank you.