## What is the purpose of the interpreter?
The interpreter aims to translate rust instructions into expressions read by the compiler.
Please note that this was a 1-person job over a bit more than a year, who is also working on the compiler, and doing work here and there. It is therefore much simpler than the rust compiler and only understads a small subset of rust.
## How much rust does the interpreter understand?
See [Rust-Support.md](Rust-Support.md).
## Why no type inference?
We would need to either reuse the one from the rust compiler, or recode our own.
And there are a lot of edge cases like https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=75e8b9c9fd236d7d7038c5e8651de40f
## Why no trait system in the `Interpreter`?
So far, we have been able to do without knowing whether a type was satisfying a trait.
We assume all types satisfy all traits, and the compiler will intervene when this is wrong.
## How do you handle `if`?
With literals, `if condition { literal_1 } else { literal_2 }` can be converted to `(condition as correct_numerical_type)*(literal_1 - literal_2) + literal_2`.
This is one of the building blocks of our conditional execution handling.
Simplified algorithm for `if condition { block_1 } else { block_2 }`:
1. Evaluate condition.
2. Clone the memory twice into memory_1 and memory_2.
3. run `block_1` on memory_1.
4. run `block_2` on memory_2.
5. Merge memory_1 and memory_2 where they differ using the building block above.
Our algorithm has been changed compared to the simplified algorithm:
* We use `MemoryLayer` to avoid the expensive clones of step 2.
* In step 5, we also merge references using our `ConditionalPointer` and functions using our `ConditionalFn`.
## Why is the code in [mock-library](src/mock-library) not compiled and invalid rust?
This code will be read and understood by the interpreter in addition to the code written by the user.
The interpreter has 4 sources of rust code.
* The `#[encrypted]` module written by our users.
* The [standard_library](../arcis/src/standard_library) that will be read by the rust compiler too.
* The [mock-library](src/mock-library) that will not be read by the rust compiler. It's there to make the interpreter understand things that the rust compiler will have understood elsewhere (rust standard library or arcis crate code that is not in the standard library folder).
* The arcis-libraries written by our users. A dependency using "arcis-library" in their keywords will have its lib.rs read.
## What tests are there?
We have negative tests (tests that the interpreter fails with the right error message) in [tests.rs](src/tests.rs).
We have integration tests in [arcis-interpreter-tests](../arcis-interpreter-tests).