expressions.h

#ifndef EXPRESSIONS_H
#define EXPRESSIONS_H

#include "tstrings.h"

#include <gsl/span>
#include <kblib/poly_obj.h>

#if 0
struct eval_context {
    argslist args;
};

struct Expr {
    std::vector<kblib::poly_obj<Expr, 64>> children;

    virtual arg_t operator()(const bytecode_machine& bm,
                             eval_context c) const final {
        return eval(bm, c);
    }

    virtual arg_t eval(const bytecode_machine& bm, eval_context c) const;

    Expr() noexcept = default;
    Expr(const Expr& e) = default;
    Expr(Expr&&) noexcept = default;
    Expr& operator=(const Expr&) = default;
    Expr& operator=(Expr&&) = default;
    virtual ~Expr() = default;
};

using ExprList = decltype(Expr::children);
using Expr_t = ExprList::value_type;

static_assert(std::is_copy_constructible_v<Expr>);

struct literal_expr : Expr {
    std::string text;
    literal_expr(std::string s) : text(std::move(s)) {}

    arg_t eval(const bytecode_machine&, eval_context) const override {
        return text;
    }
};

struct arg_expr : Expr {
    int arg;
    arg_expr(int a) noexcept : arg(a) {}

    arg_t eval(const bytecode_machine&, eval_context c) const override {
        return c.args.at(kblib::to_unsigned(arg));
    }
};

struct sarg_expr : Expr {
    std::string arg;
    sarg_expr(std::string a) noexcept : arg(std::move(a)) {}

    arg_t eval(const bytecode_machine& bm, eval_context c) const override {
        return c.args.at(kblib::to_unsigned(bm.special_argument(arg)));
    }
};

namespace helpers {

// move is_transformer here later

template <typename T>
using _l_h = std::is_convertible<decltype(std::declval<T>()(
                                     std::declval<ExprList>(),
                                     std::declval<const bytecode_machine&>(),
                                     std::declval<eval_context>())),
                                 arg_t>;

template <typename T, typename = std::void_t<>>
struct is_lazy_transformer :
    // can't find is_invocable
    // std::is_invocable<arg_t, T, argslist>
    public std::false_type {};

template <typename T>
struct is_lazy_transformer<T, std::void_t<_l_h<T>>> : public _l_h<T> {};

template <typename T>
constexpr bool is_lazy_transformer_v = is_lazy_transformer<T>::value;

}; // namespace helpers

template <typename Callable,
          typename std::enable_if_t<helpers::is_transformer_v<Callable>, int> =
              0>
class eager_transformer final : public Expr {
 public:
    eager_transformer(Callable _c) : c(std::move(_c)) {}
    [[nodiscard]] arg_t eval(const bytecode_machine& bm,
                             eval_context context) const override {
        return c(kblib::build<argslist>(
            children.begin(), children.end(),
            [&](const Expr_t& a) -> decltype(auto) { return a(bm, context); }));
    }

 private:
    Callable c;
};

template <typename Callable,
          typename std::enable_if_t<helpers::is_lazy_transformer_v<Callable>,
                                    int> = 0>
class lazy_transformer final : public Expr {
 public:
    lazy_transformer(Callable _c) : c(std::move(_c)) {}
    [[nodiscard]] arg_t eval(const bytecode_machine& bm,
                             eval_context context) const override {
        return c(children, bm, context);
    }

 private:
    Callable c;
};

template <typename Callable, typename... Ts>
[[nodiscard]] auto make_eager_expr(Callable&& c, Ts&&... ts)
    -> eager_transformer<std::decay_t<Callable>> {
    return {std::forward<Callable>(c), {std::forward<Ts>(ts)...}};
}

template <typename Callable, typename... Ts>
[[nodiscard]] auto make_lazy_expr(Callable&& c, Ts&&... ts)
    -> lazy_transformer<std::decay_t<Callable>> {
    return {std::forward<Callable>(c), {std::forward<Ts>(ts)...}};
}

using index_type = gsl::span<bytecode_op>::index_type;

auto do_lookup(std::string_view) -> Expr_t (*)();
#if 0
Expr_t parse_expr(gsl::span<bytecode_op> in, index_type& consumed) {
    assert(!in.empty());
    ++consumed;
    literal_expr l{std::get<std::string>(in[0].data)};
    switch (in[0].type) {
    case op::text:
        return Expr_t::make_aggregate<literal_expr>(
            std::get<std::string>(in[0].data));
    case op::argument:
        return Expr_t::make_aggregate<arg_expr>(std::get<int>(in[0].data));
    case op::ellipsis:
        return Expr_t::make_aggregate<sarg_expr>("...");
    case op::special_argument:
        return Expr_t::make_aggregate<sarg_expr>(
            std::get<std::string>(in[0].data));
    case op::push_func:;
        {
            Expr_t e = do_lookup(std::get<std::string>(in[0].data))();
            // Expr_t e = make_eager_expr(std::get<transformer*>(in[0].data));
            index_type skip = 1;

            while (skip != in.extent) {
                auto& code = in[skip];
                if (code.type == op::call_func) {
                    ++skip;
                    break;
                } else {
                    e->children.push_back(parse_expr(in.subspan(skip), skip));
                }
            }

            consumed += skip;
            return e;
        }
    case op::null:
    case op::call_func:
        std::abort();
    }
}

Expr_t parse_tokens(gsl::span<bytecode_op> in) {

    Expr_t e(std::in_place);

    index_type begin = 0;

    while (begin != in.extent) {
        e->children.push_back(parse_expr(in.subspan(begin), begin));
    }
    return e;
}
#endif
#endif

#endif // EXPRESSIONS_H