notes.txt

true                            # pushable
[ consequent_1 consequent_2 ]   # pushable
[ alternative_1 alternative_2 ] # pushable
3                               # pushable
4                               # pushable
if                              # command
+                               # command

###### after if

# [ 3 4 consequent_block_result ]

######################### after +

# [ consequent_block_result 7 ]


3
1
2
"three"
qq # command

# [ [1 2 "three"] ]


3
4
"a"
qalloc

# [ 4 "a" [_ _ _] ]

"foo"
[ ...block ]
def # command
2
1
2
pack # or, since length is known statically: [ 1 2 ]
foo

# fnq: [ ["foo" [...block]] ]
# qq: [ foo ]

2       # num_args
1       # argv
2
"foo"   # fn_name
pack
call    # command

# qq: [ "foo" [1 2] ]
call

"foo bar"
to_a

# [ 7 "f" "o" ... ]

enq
deq


MVP:
* Numbers (pushable)
* Math operators (commands)

V1:
* Strings
* Code blocks
* Procedures Subqueues +

V2:
* Conditionals
* Loops

V3:
* Bootstrap?

true
not
# [ false ]

###

13                  # [ 13 ]
1                   # [ 13 1 ]
>=                  # [ true ]
[ "hello" print ]   # [ true `[ "hello" print ] ]
if                  # []

# prints "hello"
# queue is []

Block([            # intend to immediately evaluate
  Number("13"),
  Number("1"),
  Command(">="),
  Queue([]),
])

true  # [ true ]
14    # [ true 14 ]
if    # [ 14 ] or ERROR: cannot execute 14

true      # [ true ]
[ 14 ]    # [ true [ 14 ] ]
if        # [ 14 ]

14
] # end of pack
[ # pack

[ 1 2 [ 3 ] + ]   # [      [ 1 2 [3] + ]   6   7    ...       ]
6
7
...
                  # [ 6 7 ... 1 2 [ 3 ] ]
exec              # [ ... 1 2 [ 3 ] 13 ]

"get_name"
[ io_recv ]   # receives "Jeremy"
def           # register "func" as [ ... ]
"get_name"
[ 1 2 ]       # [ "get_name" [ 1 2 ] ]
call          # [ [ 1 2 "Jeremy" ] ] or [ 1 2 "Jeremy" ]

# It would be up to "get_name" to pop the first two elements.

get_name: [ pop pop io_recv ]
get_name: [ drain   io_recv ]

# If we wanted [ [ "Jeremy" ] ]

# [ [1 2 3] [4 5 6] ]
concat
# [ [1 2 3 4 5 6] ]

# [ [ 1 2 3 ] "a" ]
qpop
# [ "a" [ 2 3 ] ]

# [ [ 1 2 3 ] "a" ]
pop
# [ "a" ]

# [ "a" "b" ... ]
rot
# [ ... "b" "a" ]

## ASQ

instructions = Queue([
  Number("1"),
  Number("2"),
  String("abcdef"),
  Identifier("+"),
  Identifier("multiply_strings"),
  Block([Number("3"), Number("4"), ...]),
  Keyword("if"),
  Boolean("true"),
  Boolean("false"),
])

queue_frame = []
instructions.execute(queue_frame)

class Number:
    def __init__(self, flt):
        self.val = flt

    def execute(self, frame):
        frame.push(self)

class Plus:
    def execute(self, frame):
        l = frame.pop()
        r = frame.pop()
        frame.push(Number(l.val + r.val))

# 1 + 1 - 3
1
1
+
# [ 2 ]
3
# [ 2 3 ]
-
# [ -1 ]

1
1
3
# [ 1 1 3 ]
+
# [ 3 2 ]
-
# [ 1 ]
QQ # print the whole queue and crash

JK: parser
JW: + - * /
RG: QQ read_line read_num print