returns the heap node at address Addr ### Panics `get` panics if the address does not exist on the heap. To check if an address is on the heap, use

returns an iterator to the stack elements. NOTE:* top of the stack is returned first, bottom of the stack is returned last.

Expect the given token, returning a `ParseError` if the given token was not found.

return number of elements on the stack.

push an address on top of the stack.

pops the top of the stack. # Errors returns an error if the stack is empty

Peek at the current token. If a token exists, then return the token & its range. If a token does not exist, return the range of the last seen token an

rewrites the address `addr` with new heap node `node` ### Panics if the heap node at `addr` does not exist, this function will panic

extractor should return an error if a node cannot have data extracted from. It should return None 0: + 1: (+ a) 2: (+ a) b bottom-^

Consume a token, moving the cursor one token forward in the input stream. Returns the consumed token and its range if `consume()` succeeded. Returns

Allocate the HeapNode on the heap. returns the address at which the node was allocated.

returns whether the heap contains an element at address `addr`.

Tries to unwrap a heap node to an application node, fails if the heap node is not application. # Use Case unwrapping application nodes is a very comm

converts a boolean into a HeapNode for True and False

Return the Point corresponding to the current cursor location.

Get a heap node of the kind that handler wants to get, otherwise setup the heap so that unevaluated code is evaluated to get something of this type.

General function for top-down parsing of binary operators with one lookahead. `lhs_parse_fn` is first used to parse the left hand side of the binary

```haskell <expr> := <or_expr> | "Let" let_expr ```

peeks the top of the stack. NOTE:* does _not_ remove the element on the top of the stack.

Consumes from the character stream as long as `pred` returns true. `pred` is given the string consumed so far and the current character. It is expect

let bindings first bind to "phantom" addresses, after which they relink addresses to their correct locations. This lets us check if an address is phan

Return a [`Range`](struct.Range.html) starting from `start_point` till the current cursor location.

Add the supercombinator to the machine. This will allocate the supercombinator on the heap and create a binding in the environment to the name of the

convert the `Point` to a `Range` starting and ending at the same `Point`

returns whether the machine is in final state or not. ### Errors Returns `MachineError` if machine is in invalid state

Try to parse the given string as an integer. ### Use Case Integers are stored as strings in the tokenizer to prevent loss of precision during error r

Try to convert the given string to a [CoreProgram](../ir/type.CoreProgram.html)

Tokenize the given program string. Returns a vector of `(Range, CoreToken)` where `Range` represents the source code range of the token, and `CoreToke

Gives addresses pointed to in the heap node at address `addr`. This is recursive and produces a list of _all_ addresses by walking the graph of addres

given a supercombinator, realize it on the heap by recursively instantiating its body, with respect to the environment `env. The environment is used t

```haskell supercombinator := <name: Ident> (<args : Ident>)* "=" <expr> ```

pretty print the given stack `s`

setup the execution of a registered supercombinator with name sc_name.

inspect the top of the stack and take a step in interpretation if we are not in the final state

builds the initial heap and environment corresponding to the program given. This allocates heap nodes for supercombinators in `sc_defs` and primitive

Return whether the character can be part of an identifier.

edits the address recursively in the given heap node to replace the `fake_addr` with `new_addr` **at** `edit_addr` node. edited_addrs is a bookkeeping

Consumes the longest match from the input stream from `matches` if no match is found, returns a [`ParseError`](enum.ParseError.html)

dump the current stack into the dump, and create a fresh stack

Eats comments till the end of the line returns whether a comment was consumed or not this is used to restart tokenization for the next line if a comme

Eat whitespace from the input stream

this will return a node that the address is bound to on the heap. if there is no instantiation (which is possible in cases like) let y = x; x = y in 1

format a heap node, by pretty printing the node. If the node contains recursive structure, this will handle it and print `<<recursive_defn>>`

constructs the prelude program for the machine.

mapping between strings for primitives and the primitive operation

perform an interpretation step by case analysis of the given heap node (which is the top of the stack)

Convert a raw identifier string to the correct token ### Use Case identifiers can also be tokens such as `let`, `pack`, `in`, etc. we use this to dis

instantiate let bindings This tricky case needs to be handled: ``` let y = x; x = 10 in y + y ``` here, if we instantiate `y`, then `x`, and then con

Returns whether the given character is a space ### Use Case The parser eats white space between tokens. This is used to detect white space

returns if the Heap node at address `addr` contains a cyclic definition or not.

Returns if the given token is the start of an atomic expression. ### Use Case Since our grammar is `LL(1)`, we require one lookahead to disambiguate

Make an environment for the execution of the Supercombinator. let f a b c = <body> if a function call of the form `(f x y z)` was made, the stack wil

```haskell <atomic> := <num> | <ident> | "(" <expr> ")" ```

```haskell <defn> := <ident> "=" <expr> ```

```haskell` <ident> := [a-z, A-Z]([a-Z, A-Z, 0-9, ?, -, _]*) ``` An identifier must start with a character, and can then contain any number of charac

```haskell <let> := "let" <bindings> "in" <expr>; <bindings> := <defn> | <defn> ";" <bindings> ```

```haskell <or_expr> := <and_expr> "|" <or_expr> | <or_expr> ```

```haskell <pack> := "Pack" "{" <tag : Int> "," <arity : Int> "}" ```

pretty print the machine

convert an integer data tag that is obtained from a [`CoreExpr::Pack.tag`](../ir/enum.CoreExpr.html) into a [`DataTag`](enum.DataTag.html)

IV stack: <rewritten complex expr> dump: if <rewritten complex expr> 1 2

Runs one step of the machine, and returns if machine has reached the final state or not.

Rule 2. (for Nil) 0: caseList 1: caseList $ (Nil) 2: caseList Nil $ <nil-handler> 3: caseList Nil $ <nil-handler> $ <cons-handler> on rewrite 3: <nil-

0: casePair 1: casePair $ (left, right) 2: casePair (left, right) $ <case_handler> on rewrite 2: (<case_handler> $ left) $ right

0: if 1: if $ <cond> <- if_ap_addr 2: if <cond> $ <then> 3: if <cond> <then> $ <else>

TODO: rewrite code to follow the new style of peeking all of them and then popping off all of them

Runs the given supercombinator by instantiating it on top of the stack.

Try to convert the given string to a [CoreExpr](../ir/enum.CoreExpr.html)

Try to convert the given string to a [SupercombDefn](../ir/struct.SupercombDefn.html)

Tokenize a symbol from the input stream

Format an address to be of the form `0xaddress_in_hex`. Used for pretty printing addresses

makes the heap tag bold

Helper to construct a `Err` with a [`ParseErrorKind::Generic`](enum.ParseErrorKind.html)

pretty print the line number string

try to access the heap node as a boolean returns an error if the heap node is not data with `TagTrue` or `TagFalse`.

try to access the heap node as list.

try to access the heap node as a number. returns an error if the heap node is not a `Num` node

try to access the heap node as a pair

returns the pretty-printed version of the final heap node on top of the stack. ### Errors Returns an error if the machine is not in the final state

Create a machine from `program`. Expects a `main` to be present in the given program. ###Errors returns an error if `main` was not found

Create a minimal machine that has the prelude and primitives instantiated, but with an empty stack.

```haskell <add_sub_expr> := <mul_div_expr> ("+" | "-") <add_sub_expr> ```

```haskell <and_expr> := <relop_expr> "&" <and_expr> | <relop_expr> ```

```haskell <aexpr> := <atomic> | Pack "{" <num> "," <num> "}"; <application> := <aexpr> | <aexpr>+ ``` Note that this parses either a standalone expr

```haskell <mul_div_expr> := <application_expr> ("*" | "/") <mul_div_expr> ```