TODO

#DONE - If
#DONE - While
#DONE - Else
#DONE - else if
#DONE - Indexing array[expression]
#DONE - Scopes (var managers saving predecessors)
#DONE - Actually use the scopes in if while usw
#DONE - Function definitions
#DONE - Function args (define in scope)
#DONE - Function return (Return from execute as some msg kind maybe containing DayObject)
#DONE - Improve function declaration system, either use unsafe interior mutability or create 
        functions in parser the latter is better as you can use functions before they are defined
        if we even want that but in generall multiple definition has to be allowed without 
        defining multiple times
#DONE - Closures
#DONE - Scope recording Closures

#DONE - Iterators
        They have to return DayObjects, &'a DayObject doesn't really make sense
        at some point there will be references they are mut so it shouldn't 
        be the standard
#DONE - For
    NOTE - The For syntax might get changed (maybe two keywords are a lot)

#TODO - declarations in for loops dont work currently
    FIX this asap (clear of scope neccessary)

#TODO - Reimplement all the nodes, reimplement all the functions
    Optimisations can be done way way later.
    Even if it means more work at the end it also means more usability sooner 

#TODO - Work on c2
        Nodes can be 'static that would mean no JoinGuards but JoinHandles
        the only thing that could need a lifetime is a lifetime managed 
        memory arena for RustTypes, but that could also just be disallowed
        so that included RustTypes have to be 'static too

#TODO - Iterators in language (this might be hard)

#TODO - brk/continue


#DONE - Add apply function to improve functional programming
    #DONE - Add chain function and applicator

#TODO Benchmarks
    #TODO - Args as VecDequeue if it doesn't effect efficiency for that we would need benchmarks

#TODO - Errors, prevent panicking because of wrong args and check differently
        For this every args.remove has to be changed (VecDequeue)

#TODO - Change names (names fitting Crab)

#TODO - References (i don't know if its better to do this before or after Iterators)
    #TODO - pointers (referring to a variable in the var manager, 
        holds some kind of handle to the var manager variable (not the key) kinda unsafe)
    #TODO - raw pointers (referring to a block of pinned data, C like)
    #TODO - Garbage collected references (not that unsafe, never dangles, the only 
        reason to use gc references is for cyclic data)

#TODO - Add Bigint

#TODO - Threading with joinhandle similiar to lazy as language construct
    (thread, mutex, mpsc, rwlock) maybe as language construct or spawn function
    so let x = spawn(fn {mul(args[0], args[1], 100000)}, array(1000, 1000)) or
    let x = spawn mul(1000, 1000, 100000)
    function or keyword and if keyword spawn?

#TODO - Lazy variables and lazy statements

#TODO - Rust type inclusion
    #TODO - Managed types

#TODO - Add optimizer, for this the impl of node has to quite change, all nodes
    have to then be interior mutable/they need some kind of cell around them to be swapped out
    such that they are just the interior of another struct

#TODO - Define API
    #TODO - Define Outer Api: 
        Parser struct, how to let it execute code, how to let it run in the background,
        how to inspect data from it.
    #TODO - Define inner API: 
        Module Trait, Rust type inclusion trait, var manager trait to make it replacable usw.

#TODO - Modules (std is not imported by default, it can be by the caller, but 
    using its prelude a second time shouldn't matter then)

#TODO - Debug dropping (make sure it works and message some more in debug mode)

#TODO - Dictionaries
#TODO - Macros! functions taking Tokens instead of DayObjects
#TODO - Dict initializer macro (i wouldn't like them without, maybe as prototype without)

#TODO - Proper Errors
#TODO - Remove as much recursion as possible

#TODO - Benchmarks 
#TODO - Interactive Shell