I've decided that my code is going to be interpreted using bytecode, which will be a lot faster than my previous plan of using Abstract Syntax Trees.

Here's a tentative feature:

Subfunctions:

function Main()

{

subfunction SetAto3()

{

a = 3;

}

SetAto3();

print(a);//prints '3'

}

Here's the basics of the keyword 'subfunction':

-It must be nested in a function or subfunction

-Subfunctions cannot be stored in variables like normal functions, because they are not called like regular functions (they instead share stack variables with their parent functions, they must know their parent functions at compile-time).

-Normal functions can be nested in functions and subfunctions. These can be stored in variables.

Generators:

A little bit the opposite of subfunctions, generates instead of sharing a stackframe create one completely for themselves.

Generators are very different compared to normal functions, calling them does nothing but return a value, and what they return is used as a function

generator GenerateMemoizer(function)(args){

a = {};

while (True){

if ( a[args] == Null )//if it isn't in the map

a[args] = Call(function, args);

yield a[args];//after the yield, args is updated by more input

}

}

The syntax here is a bit confusing. There are essentially two sets of arguments, one for the generator, and one for the array of arguments passed to the generated function. yield value; is like return except the generated function still exists after it. It merely waits till the next call.

One might use this with, for example:

generatedFunc = GenerateMemoizer(SomeFunction);

generatedFunc(arguments, we, would, pass, to, SomeFunction);//they are stored in an array called 'args' in the generated function

Finally, the Call function is a builtin that calls a function that allows for calling to functions by using an array as the argument list.