On 7 Apr 2022, at 12:00, tom2 <tom@tomflux.xyz> wrote:
I have heard of an AST, and, against my better judgement, thought they were to
complex for my needs and decided to represent the instructions as one long
list, that gets edited by loops/conditionals.
I see the error of my ways now, but I am too close to the deadline of this
project for me to go back and change it now...
Here is a functional style outline in terms of C++:
First a base class with a virtual function evaluate(), say:
class unit {
ref<unit> evaluate(ref<unit>) { return {}; }
};
where ref<X> is say the C++ reference counting class std::shared_ptr<X>.
Then
class function_application : public virtual unit {
object f_, a_; // Function and arguments.
ref<unit> evaluate(ref<unit> x) { return f_(a_(x)); }
};
In addition, classes for functions and tuples.
When constructed, this will delay any action until applies 'evaluate' to the
object.
For an if-then-else conditional, it might have an boolean argument b, and an
argument to evaluate if true t and false f_
class if_then_else {
object b_, t_, f_;
ref<unit> evaluate(ref<unit> x) { if (b_(x)) return t_(x) else return
f_(x); }
};
For loops, it is possible in C++ to implement break and continue objects that
throw exceptions to achieve the appropriate effect. This is not particularly
efficient, but easy to write.
There are more expanded and efficient ways to do this, but the underlying idea
would be the same.