minor changes to compile/ir

fix a couple bugs w/ pointers + like half of index assignment

first pass at pointers. they do work! mostly!

update readme slightly

a couple random c tweaks

shorter / better solution for PE#7

delete the now-unused old reference module

vars-as-objects system actually working! :O

vm/compiler changes for this (still doesn't work)

split concept of variables vs values. compiler not working yet though

rename hV to hVal; remove unused functions

minor syntax tweaks

fix clang warnings

experimenting with writing a nontrivial amount of code

substring, int parsing, project euler #8

range indexing a[b..c] (i reserve the right to change this syntax)

bound methods for intrinsic types

method dispatch cleanup + 'properties' (builtin methods w/o ())

project euler #0 (which exposed a bug in my bigint promotion code!)

add reduce, max, project euler #7, some other euler updates

catch weird syntax errors with non-expr after binary op

I had a cool idea for method call semantics. voila, custom methods!

more additions to the tree-walker

block pipe in situations where it is buggy for now. how to fix?

fix list-spill, also make pipe a bit more elegant

implicit calling of functions on right side of | operator

project euler #6

add | operator between expressions; project euler #6

list::iota, fix vm bug, project euler #5

fix <~

add concept of sentinel values for unique message names

we can now do multiple print properly

flip calling convention: evaluate right to left

minor tweaks to get_param

fix clang warnings

retain/release for integers; don't retain on stack push

project euler #3

fix some math bugs

bigint improvements + printing, float types, math library

initial very basic support of bigints.

(the parsing is very memory inefficient. i will rethink the general
 memory management strategy of this stuff, i promise!)

99 bottles of beer on the wall

add printing to samples; fix a couple bugs that got overturned

add hello-world to readme

finally, global modules! we can print at long, sweet last

allow values also in lib tables (to add global modules)

some general cleanup / restructuring of a bunch of method code

resolve methods with hash table

project euler #4, fix bugs

i need to add garbage collecting and print / global stuff for real

methods for integer + string, more list methods

I need to restructure how methods are resolved, right now it is bad

evaluate repeat..while/until condition inside block scope

project euler 02

%% operator

project euler #1 (eventually i will add more convenience methods here)

"any?" and "all?" methods for lists

map and filter methods for lists

Update README.md

plain 'return' + postfix 'if'/'unless'

boolean literals + mod operator

fix another VM instruction bug

add a couple more methods to lists

fix a few small bugs

better/more consistent VM model

add README

fix a couple errant oversights, squash a few memory leaks

more portable printing; callbacks from native code to script

initial stab at method calls; *almost* works, but not quite

"un-splatting" function params. + start reworking assignment in general

list splatting

temporal dead zone

split out ir printing; mutual + recursive function calling

LEXICAL CLOSURES

hash literals!! + read indexing

LISTS in code!! wow!! so cool!!!

list data module

whoops, forgot to initialize pointers here

factor out 'allocation pool' code from string + hash table

basic constant folding

make debug flags turn on and off with a compiler switch

we can have negative numbers now

fix a couple bytecode compiler bugs

forward jumps! now if and while work

we can actually run (very simple) programs! AMAZING

janky beginnings of emitting bytecode

better error reporting + a few variable scope fixes

consolidate variable slots, track variable function scopes

simple label jump optimization

function definitions as chunks + function calls in IR

update comments

fix minor parser bug, IR can do multi-assignment now

(janky) lexical variable scoping + assignment in IR

Basic framework for IR code generation

conditional jumps and such in VM

very basic VM/bytecode functionality! it works! we can add numbers!

some initial supports for bytecode VM

clean up imports a bit

actually the <~( ... ) should work like this

<~ syntax was weird to parse, so use invisible () to clarify

forgot about this syntax

this currently won't work on something like a.[b], because the layer-2
lexer doesn't know to put () there. i'm not sure if this syntax is a
good idea anyway though, it seems confusing

i think this is all the basic syntax i had in mind

(except @declarations, but those are just syntax sugar, we'll come back
to those!)

more parser stuff + much more friendly syntax error reporting