proxy_functions.hpp

// This file is distributed under the BSD License.
// See "license.txt" for details.
// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
// Copyright 2009-2018, Jason Turner (jason@emptycrate.com)
// http://www.chaiscript.com

// This is an open source non-commercial project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com

#ifndef CHAISCRIPT_PROXY_FUNCTIONS_HPP_
#define CHAISCRIPT_PROXY_FUNCTIONS_HPP_

#include <cassert>
#include <functional>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>

#include "../chaiscript_defines.hpp"
#include "boxed_cast.hpp"
#include "boxed_value.hpp"
#include "dynamic_object.hpp"
#include "function_params.hpp"
#include "proxy_functions_detail.hpp"
#include "type_info.hpp"

namespace chaiscript {
  class Type_Conversions;
  namespace exception {
    class bad_boxed_cast;
    struct arity_error;
  } // namespace exception
} // namespace chaiscript

namespace chaiscript {
  class Boxed_Number;
  struct AST_Node;

  using AST_NodePtr = std::unique_ptr<AST_Node>;

  namespace dispatch {
    template<typename FunctionType>
    std::function<FunctionType> functor(std::shared_ptr<const Proxy_Function_Base> func, const Type_Conversions_State *t_conversions);

    class Param_Types {
    public:
      Param_Types()
          : m_has_types(false) {
      }

      explicit Param_Types(std::vector<std::pair<std::string, Type_Info>> t_types)
          : m_types(std::move(t_types))
          , m_has_types(false) {
        update_has_types();
      }

      void push_front(std::string t_name, Type_Info t_ti) {
        m_types.emplace(m_types.begin(), std::move(t_name), t_ti);
        update_has_types();
      }

      bool operator==(const Param_Types &t_rhs) const noexcept { return m_types == t_rhs.m_types; }

      std::vector<Boxed_Value> convert(Function_Params t_params, const Type_Conversions_State &t_conversions) const {
        auto vals = t_params.to_vector();
        const auto dynamic_object_type_info = user_type<Dynamic_Object>();
        for (size_t i = 0; i < vals.size(); ++i) {
          const auto &name = m_types[i].first;
          if (!name.empty()) {
            const auto &bv = vals[i];

            if (!bv.get_type_info().bare_equal(dynamic_object_type_info)) {
              const auto &ti = m_types[i].second;
              if (!ti.is_undef()) {
                if (!bv.get_type_info().bare_equal(ti)) {
                  if (t_conversions->converts(ti, bv.get_type_info())) {
                    try {
                      // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
                      // either way, we are not responsible if it doesn't work
                      vals[i] = t_conversions->boxed_type_conversion(m_types[i].second, t_conversions.saves(), vals[i]);
                    } catch (...) {
                      try {
                        // try going the other way
                        vals[i] = t_conversions->boxed_type_down_conversion(m_types[i].second, t_conversions.saves(), vals[i]);
                      } catch (const chaiscript::detail::exception::bad_any_cast &) {
                        throw exception::bad_boxed_cast(bv.get_type_info(), *m_types[i].second.bare_type_info());
                      }
                    }
                  }
                }
              }
            }
          }
        }

        return vals;
      }

      // first result: is a match
      // second result: needs conversions
      std::pair<bool, bool> match(const Function_Params &vals, const Type_Conversions_State &t_conversions) const noexcept {
        const auto dynamic_object_type_info = user_type<Dynamic_Object>();
        bool needs_conversion = false;

        if (!m_has_types) {
          return std::make_pair(true, needs_conversion);
        }
        if (vals.size() != m_types.size()) {
          return std::make_pair(false, needs_conversion);
        }

        for (size_t i = 0; i < vals.size(); ++i) {
          const auto &name = m_types[i].first;
          if (!name.empty()) {
            const auto &bv = vals[i];

            if (bv.get_type_info().bare_equal(dynamic_object_type_info)) {
              try {
                const Dynamic_Object &d = boxed_cast<const Dynamic_Object &>(bv, &t_conversions);
                if (!(name == "Dynamic_Object" || d.get_type_name() == name)) {
                  return std::make_pair(false, false);
                }
              } catch (const std::bad_cast &) {
                return std::make_pair(false, false);
              }
            } else {
              const auto &ti = m_types[i].second;
              if (!ti.is_undef()) {
                if (!bv.get_type_info().bare_equal(ti)) {
                  if (!t_conversions->converts(ti, bv.get_type_info())) {
                    return std::make_pair(false, false);
                  } else {
                    needs_conversion = true;
                  }
                }
              } else {
                return std::make_pair(false, false);
              }
            }
          }
        }

        return std::make_pair(true, needs_conversion);
      }

      const std::vector<std::pair<std::string, Type_Info>> &types() const noexcept { return m_types; }

    private:
      void update_has_types() {
        for (const auto &type : m_types) {
          if (!type.first.empty()) {
            m_has_types = true;
            return;
          }
        }

        m_has_types = false;
      }

      std::vector<std::pair<std::string, Type_Info>> m_types;
      bool m_has_types;
    };

    class Proxy_Function_Base {
    public:
      virtual ~Proxy_Function_Base() = default;

      Boxed_Value operator()(const Function_Params &params, const chaiscript::Type_Conversions_State &t_conversions) const {
        if (m_arity < 0 || size_t(m_arity) == params.size()) {
          return do_call(params, t_conversions);
        } else {
          throw exception::arity_error(static_cast<int>(params.size()), m_arity);
        }
      }

      const std::vector<Type_Info> &get_param_types() const noexcept { return m_types; }

      virtual bool operator==(const Proxy_Function_Base &) const noexcept = 0;
      virtual bool call_match(const Function_Params &vals, const Type_Conversions_State &t_conversions) const = 0;

      virtual bool is_attribute_function() const noexcept { return false; }

      bool has_arithmetic_param() const noexcept { return m_has_arithmetic_param; }

      virtual std::vector<std::shared_ptr<const Proxy_Function_Base>> get_contained_functions() const {
        return std::vector<std::shared_ptr<const Proxy_Function_Base>>();
      }

      bool filter(const Function_Params &vals, const Type_Conversions_State &t_conversions) const noexcept {
        assert(m_arity == -1 || (m_arity > 0 && static_cast<int>(vals.size()) == m_arity));

        if (m_arity < 0) {
          return true;
        } else if (m_arity > 1) {
          return compare_type_to_param(m_types[1], vals[0], t_conversions) && compare_type_to_param(m_types[2], vals[1], t_conversions);
        } else {
          return compare_type_to_param(m_types[1], vals[0], t_conversions);
        }
      }

      int get_arity() const noexcept { return m_arity; }

      static bool compare_type_to_param(const Type_Info &ti, const Boxed_Value &bv, const Type_Conversions_State &t_conversions) noexcept {
        const auto boxed_value_ti = user_type<Boxed_Value>();
        const auto boxed_number_ti = user_type<Boxed_Number>();
        const auto function_ti = user_type<std::shared_ptr<const Proxy_Function_Base>>();

        if (ti.is_undef() || ti.bare_equal(boxed_value_ti)
            || (!bv.get_type_info().is_undef()
                && ((ti.bare_equal(boxed_number_ti) && bv.get_type_info().is_arithmetic()) || ti.bare_equal(bv.get_type_info())
                    || bv.get_type_info().bare_equal(function_ti) || t_conversions->converts(ti, bv.get_type_info())))) {
          return true;
        } else {
          return false;
        }
      }

      virtual bool compare_first_type(const Boxed_Value &bv, const Type_Conversions_State &t_conversions) const noexcept {
        return compare_type_to_param(m_types[1], bv, t_conversions);
      }

    protected:
      virtual Boxed_Value do_call(const Function_Params &params, const Type_Conversions_State &t_conversions) const = 0;

      Proxy_Function_Base(std::vector<Type_Info> t_types, int t_arity)
          : m_types(std::move(t_types))
          , m_arity(t_arity)
          , m_has_arithmetic_param(false) {
        for (size_t i = 1; i < m_types.size(); ++i) {
          if (m_types[i].is_arithmetic()) {
            m_has_arithmetic_param = true;
            return;
          }
        }
      }

      static bool compare_types(const std::vector<Type_Info> &tis, const Function_Params &bvs, const Type_Conversions_State &t_conversions) noexcept {
        if (tis.size() - 1 != bvs.size()) {
          return false;
        } else {
          const size_t size = bvs.size();
          for (size_t i = 0; i < size; ++i) {
            if (!compare_type_to_param(tis[i + 1], bvs[i], t_conversions)) {
              return false;
            }
          }
        }
        return true;
      }

      std::vector<Type_Info> m_types;
      int m_arity;
      bool m_has_arithmetic_param;
    };
  } // namespace dispatch

  using Proxy_Function = std::shared_ptr<dispatch::Proxy_Function_Base>;

  using Const_Proxy_Function = std::shared_ptr<const dispatch::Proxy_Function_Base>;

  namespace exception {
    class guard_error : public std::runtime_error {
    public:
      guard_error() noexcept
          : std::runtime_error("Guard evaluation failed") {
      }

      guard_error(const guard_error &) = default;

      ~guard_error() noexcept override = default;
    };
  } // namespace exception

  namespace dispatch {
    class Dynamic_Proxy_Function : public Proxy_Function_Base {
    public:
      Dynamic_Proxy_Function(const int t_arity,
                             std::shared_ptr<AST_Node> t_parsenode,
                             Param_Types t_param_types = Param_Types(),
                             Proxy_Function t_guard = Proxy_Function())
          : Proxy_Function_Base(build_param_type_list(t_param_types), t_arity)
          , m_param_types(std::move(t_param_types))
          , m_guard(std::move(t_guard))
          , m_parsenode(std::move(t_parsenode)) {
        // assert(t_parsenode);
      }

      bool operator==(const Proxy_Function_Base &rhs) const noexcept override {
        const Dynamic_Proxy_Function *prhs = dynamic_cast<const Dynamic_Proxy_Function *>(&rhs);

        return this == &rhs
            || ((prhs != nullptr) && this->m_arity == prhs->m_arity && !this->m_guard && !prhs->m_guard
                && this->m_param_types == prhs->m_param_types);
      }

      bool call_match(const Function_Params &vals, const Type_Conversions_State &t_conversions) const override {
        return call_match_internal(vals, t_conversions).first;
      }

      bool has_guard() const noexcept { return bool(m_guard); }

      Proxy_Function get_guard() const noexcept { return m_guard; }

      bool has_parse_tree() const noexcept { return static_cast<bool>(m_parsenode); }

      const AST_Node &get_parse_tree() const {
        if (m_parsenode) {
          return *m_parsenode;
        } else {
          throw std::runtime_error("Dynamic_Proxy_Function does not have parse_tree");
        }
      }

    protected:
      bool test_guard(const Function_Params &params, const Type_Conversions_State &t_conversions) const {
        if (m_guard) {
          try {
            return boxed_cast<bool>((*m_guard)(params, t_conversions));
          } catch (const exception::arity_error &) {
            return false;
          } catch (const exception::bad_boxed_cast &) {
            return false;
          }
        } else {
          return true;
        }
      }

      // first result: is a match
      // second result: needs conversions
      std::pair<bool, bool> call_match_internal(const Function_Params &vals, const Type_Conversions_State &t_conversions) const {
        const auto comparison_result = [&]() {
          if (m_arity < 0) {
            return std::make_pair(true, false);
          } else if (vals.size() == size_t(m_arity)) {
            return m_param_types.match(vals, t_conversions);
          } else {
            return std::make_pair(false, false);
          }
        }();

        return std::make_pair(comparison_result.first && test_guard(vals, t_conversions), comparison_result.second);
      }

    private:
      static std::vector<Type_Info> build_param_type_list(const Param_Types &t_types) {
        // For the return type
        std::vector<Type_Info> types{chaiscript::detail::Get_Type_Info<Boxed_Value>::get()};

        for (const auto &t : t_types.types()) {
          if (t.second.is_undef()) {
            types.push_back(chaiscript::detail::Get_Type_Info<Boxed_Value>::get());
          } else {
            types.push_back(t.second);
          }
        }

        return types;
      }

    protected:
      Param_Types m_param_types;

    private:
      Proxy_Function m_guard;
      std::shared_ptr<AST_Node> m_parsenode;
    };

    template<typename Callable>
    class Dynamic_Proxy_Function_Impl final : public Dynamic_Proxy_Function {
    public:
      Dynamic_Proxy_Function_Impl(Callable t_f,
                                  int t_arity = -1,
                                  std::shared_ptr<AST_Node> t_parsenode = AST_NodePtr(),
                                  Param_Types t_param_types = Param_Types(),
                                  Proxy_Function t_guard = Proxy_Function())
          : Dynamic_Proxy_Function(t_arity, std::move(t_parsenode), std::move(t_param_types), std::move(t_guard))
          , m_f(std::move(t_f)) {
      }

    protected:
      Boxed_Value do_call(const Function_Params &params, const Type_Conversions_State &t_conversions) const override {
        const auto [is_a_match, needs_conversions] = call_match_internal(params, t_conversions);
        if (is_a_match) {
          if (needs_conversions) {
            return m_f(Function_Params{m_param_types.convert(params, t_conversions)});
          } else {
            return m_f(params);
          }
        } else {
          throw exception::guard_error();
        }
      }

    private:
      Callable m_f;
    };

    template<typename Callable, typename... Arg>
    Proxy_Function make_dynamic_proxy_function(Callable &&c, Arg &&...a) {
      return chaiscript::make_shared<dispatch::Proxy_Function_Base, dispatch::Dynamic_Proxy_Function_Impl<Callable>>(std::forward<Callable>(c),
                                                                                                                     std::forward<Arg>(a)...);
    }

    struct Placeholder_Object {
    };

    class Bound_Function final : public Proxy_Function_Base {
    public:
      Bound_Function(const Const_Proxy_Function &t_f, const std::vector<Boxed_Value> &t_args)
          : Proxy_Function_Base(build_param_type_info(t_f, t_args),
                                (t_f->get_arity() < 0 ? -1 : static_cast<int>(build_param_type_info(t_f, t_args).size()) - 1))
          , m_f(t_f)
          , m_args(t_args) {
        assert(m_f->get_arity() < 0 || m_f->get_arity() == static_cast<int>(m_args.size()));
      }

      bool operator==(const Proxy_Function_Base &t_f) const noexcept override { return &t_f == this; }

      bool call_match(const Function_Params &vals, const Type_Conversions_State &t_conversions) const override {
        return m_f->call_match(Function_Params(build_param_list(vals)), t_conversions);
      }

      std::vector<Const_Proxy_Function> get_contained_functions() const override { return std::vector<Const_Proxy_Function>{m_f}; }

      std::vector<Boxed_Value> build_param_list(const Function_Params &params) const {
        auto parg = params.begin();
        auto barg = m_args.begin();

        std::vector<Boxed_Value> args;

        while (!(parg == params.end() && barg == m_args.end())) {
          while (barg != m_args.end() && !(barg->get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get())) {
            args.push_back(*barg);
            ++barg;
          }

          if (parg != params.end()) {
            args.push_back(*parg);
            ++parg;
          }

          if (barg != m_args.end() && barg->get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get()) {
            ++barg;
          }
        }
        return args;
      }

    protected:
      static std::vector<Type_Info> build_param_type_info(const Const_Proxy_Function &t_f, const std::vector<Boxed_Value> &t_args) {
        assert(t_f->get_arity() < 0 || t_f->get_arity() == static_cast<int>(t_args.size()));

        if (t_f->get_arity() < 0) {
          return std::vector<Type_Info>();
        }

        const auto types = t_f->get_param_types();
        assert(types.size() == t_args.size() + 1);

        // this analysis warning is invalid in MSVC12 and doesn't exist in MSVC14
        std::vector<Type_Info> retval{types[0]};

        for (size_t i = 0; i < types.size() - 1; ++i) {
          if (t_args[i].get_type_info() == chaiscript::detail::Get_Type_Info<Placeholder_Object>::get()) {
            retval.push_back(types[i + 1]);
          }
        }

        return retval;
      }

      Boxed_Value do_call(const Function_Params &params, const Type_Conversions_State &t_conversions) const override {
        return (*m_f)(Function_Params{build_param_list(params)}, t_conversions);
      }

    private:
      Const_Proxy_Function m_f;
      std::vector<Boxed_Value> m_args;
    };

    class Proxy_Function_Impl_Base : public Proxy_Function_Base {
    public:
      explicit Proxy_Function_Impl_Base(const std::vector<Type_Info> &t_types)
          : Proxy_Function_Base(t_types, static_cast<int>(t_types.size()) - 1) {
      }

      bool call_match(const Function_Params &vals, const Type_Conversions_State &t_conversions) const noexcept override {
        return static_cast<int>(vals.size()) == get_arity()
            && (compare_types(m_types, vals, t_conversions) && compare_types_with_cast(vals, t_conversions));
      }

      virtual bool compare_types_with_cast(const Function_Params &vals, const Type_Conversions_State &t_conversions) const noexcept = 0;
    };

    template<typename Func, typename Callable>
    class Proxy_Function_Callable_Impl final : public Proxy_Function_Impl_Base {
    public:
      explicit Proxy_Function_Callable_Impl(Callable f)
          : Proxy_Function_Impl_Base(detail::build_param_type_list(static_cast<Func *>(nullptr)))
          , m_f(std::move(f)) {
      }

      bool compare_types_with_cast(const Function_Params &vals, const Type_Conversions_State &t_conversions) const noexcept override {
        return detail::compare_types_cast(static_cast<Func *>(nullptr), vals, t_conversions);
      }

      bool operator==(const Proxy_Function_Base &t_func) const noexcept override {
        return dynamic_cast<const Proxy_Function_Callable_Impl<Func, Callable> *>(&t_func) != nullptr;
      }

    protected:
      Boxed_Value do_call(const Function_Params &params, const Type_Conversions_State &t_conversions) const override {
        return detail::call_func(static_cast<Func *>(nullptr), m_f, params, t_conversions);
      }

    private:
      Callable m_f;
    };

    class Assignable_Proxy_Function : public Proxy_Function_Impl_Base {
    public:
      explicit Assignable_Proxy_Function(const std::vector<Type_Info> &t_types)
          : Proxy_Function_Impl_Base(t_types) {
      }

      virtual void assign(const std::shared_ptr<const Proxy_Function_Base> &t_rhs) = 0;
    };

    template<typename Func>
    class Assignable_Proxy_Function_Impl final : public Assignable_Proxy_Function {
    public:
      Assignable_Proxy_Function_Impl(std::reference_wrapper<std::function<Func>> t_f, std::shared_ptr<std::function<Func>> t_ptr)
          : Assignable_Proxy_Function(detail::build_param_type_list(static_cast<Func *>(nullptr)))
          , m_f(std::move(t_f))
          , m_shared_ptr_holder(std::move(t_ptr)) {
        assert(!m_shared_ptr_holder || m_shared_ptr_holder.get() == &m_f.get());
      }

      bool compare_types_with_cast(const Function_Params &vals, const Type_Conversions_State &t_conversions) const noexcept override {
        return detail::compare_types_cast(static_cast<Func *>(nullptr), vals, t_conversions);
      }

      bool operator==(const Proxy_Function_Base &t_func) const noexcept override {
        return dynamic_cast<const Assignable_Proxy_Function_Impl<Func> *>(&t_func) != nullptr;
      }

      std::function<Func> internal_function() const { return m_f.get(); }

      void assign(const std::shared_ptr<const Proxy_Function_Base> &t_rhs) override { m_f.get() = dispatch::functor<Func>(t_rhs, nullptr); }

    protected:
      Boxed_Value do_call(const Function_Params &params, const Type_Conversions_State &t_conversions) const override {
        return detail::call_func(static_cast<Func *>(nullptr), m_f.get(), params, t_conversions);
      }

    private:
      std::reference_wrapper<std::function<Func>> m_f;
      std::shared_ptr<std::function<Func>> m_shared_ptr_holder;
    };

    template<typename T, typename Class>
    class Attribute_Access final : public Proxy_Function_Base {
    public:
      explicit Attribute_Access(T Class::*t_attr)
          : Proxy_Function_Base(param_types(), 1)
          , m_attr(t_attr) {
      }

      bool is_attribute_function() const noexcept override { return true; }

      bool operator==(const Proxy_Function_Base &t_func) const noexcept override {
        const Attribute_Access<T, Class> *aa = dynamic_cast<const Attribute_Access<T, Class> *>(&t_func);

        if (aa) {
          return m_attr == aa->m_attr;
        } else {
          return false;
        }
      }

      bool call_match(const Function_Params &vals, const Type_Conversions_State &) const noexcept override {
        if (vals.size() != 1) {
          return false;
        }
        const auto class_type_info = user_type<Class>();
        return vals[0].get_type_info().bare_equal(class_type_info);
      }

    protected:
      Boxed_Value do_call(const Function_Params &params, const Type_Conversions_State &t_conversions) const override {
        const Boxed_Value &bv = params[0];
        if (bv.is_const()) {
          const Class *o = boxed_cast<const Class *>(bv, &t_conversions);
          return do_call_impl<T>(o);
        } else {
          Class *o = boxed_cast<Class *>(bv, &t_conversions);
          return do_call_impl<T>(o);
        }
      }

    private:
      template<typename Type>
      auto do_call_impl(Class *o) const {
        if constexpr (std::is_pointer<Type>::value) {
          return detail::Handle_Return<Type>::handle(o->*m_attr);
        } else {
          return detail::Handle_Return<typename std::add_lvalue_reference<Type>::type>::handle(o->*m_attr);
        }
      }

      template<typename Type>
      auto do_call_impl(const Class *o) const {
        if constexpr (std::is_pointer<Type>::value) {
          return detail::Handle_Return<const Type>::handle(o->*m_attr);
        } else {
          return detail::Handle_Return<typename std::add_lvalue_reference<typename std::add_const<Type>::type>::type>::handle(o->*m_attr);
        }
      }

      static std::vector<Type_Info> param_types() { return {user_type<T>(), user_type<Class>()}; }

      std::vector<Type_Info> m_param_types{user_type<T>(), user_type<Class>()};
      T Class::*m_attr;
    };
  } // namespace dispatch

  namespace exception {
    class dispatch_error : public std::runtime_error {
    public:
      dispatch_error(const Function_Params &t_parameters, std::vector<Const_Proxy_Function> t_functions)
          : std::runtime_error("Error with function dispatch")
          , parameters(t_parameters.to_vector())
          , functions(std::move(t_functions)) {
      }

      dispatch_error(const Function_Params &t_parameters, std::vector<Const_Proxy_Function> t_functions, const std::string &t_desc)
          : std::runtime_error(t_desc)
          , parameters(t_parameters.to_vector())
          , functions(std::move(t_functions)) {
      }

      dispatch_error(const dispatch_error &) = default;
      ~dispatch_error() noexcept override = default;

      std::vector<Boxed_Value> parameters;
      std::vector<Const_Proxy_Function> functions;
    };
  } // namespace exception

  namespace dispatch {
    namespace detail {
      template<typename FuncType>
      bool types_match_except_for_arithmetic(const FuncType &t_func,
                                             const chaiscript::Function_Params &plist,
                                             const Type_Conversions_State &t_conversions) noexcept {
        const std::vector<Type_Info> &types = t_func->get_param_types();

        if (t_func->get_arity() == -1) {
          return false;
        }

        assert(plist.size() == types.size() - 1);

        return std::mismatch(plist.begin(),
                             plist.end(),
                             types.begin() + 1,
                             [&](const Boxed_Value &bv, const Type_Info &ti) {
                               return Proxy_Function_Base::compare_type_to_param(ti, bv, t_conversions)
                                   || (bv.get_type_info().is_arithmetic() && ti.is_arithmetic());
                             })
            == std::make_pair(plist.end(), types.end());
      }

      template<typename InItr, typename Funcs>
      Boxed_Value dispatch_with_conversions(InItr begin,
                                            const InItr &end,
                                            const chaiscript::Function_Params &plist,
                                            const Type_Conversions_State &t_conversions,
                                            const Funcs &t_funcs) {
        InItr matching_func(end);

        while (begin != end) {
          if (types_match_except_for_arithmetic(begin->second, plist, t_conversions)) {
            if (matching_func == end) {
              matching_func = begin;
            } else {
              // handle const members vs non-const member, which is not really ambiguous
              const auto &mat_fun_param_types = matching_func->second->get_param_types();
              const auto &next_fun_param_types = begin->second->get_param_types();

              if (plist[0].is_const() && !mat_fun_param_types[1].is_const() && next_fun_param_types[1].is_const()) {
                matching_func = begin; // keep the new one, the const/non-const matchup is correct
              } else if (!plist[0].is_const() && !mat_fun_param_types[1].is_const() && next_fun_param_types[1].is_const()) {
                // keep the old one, it has a better const/non-const matchup
              } else {
                // ambiguous function call
                throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
              }
            }
          }

          ++begin;
        }

        if (matching_func == end) {
          // no appropriate function to attempt arithmetic type conversion on
          throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
        }

        std::vector<Boxed_Value> newplist;
        newplist.reserve(plist.size());

        const std::vector<Type_Info> &tis = matching_func->second->get_param_types();
        std::transform(tis.begin() + 1, tis.end(), plist.begin(), std::back_inserter(newplist), [](const Type_Info &ti, const Boxed_Value &param) -> Boxed_Value {
          if (ti.is_arithmetic() && param.get_type_info().is_arithmetic() && param.get_type_info() != ti) {
            return Boxed_Number(param).get_as(ti).bv;
          } else {
            return param;
          }
        });

        try {
          return (*(matching_func->second))(chaiscript::Function_Params{newplist}, t_conversions);
        } catch (const exception::bad_boxed_cast &) {
          // parameter failed to cast
        } catch (const exception::arity_error &) {
          // invalid num params
        } catch (const exception::guard_error &) {
          // guard failed to allow the function to execute
        }

        throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(t_funcs.begin(), t_funcs.end()));
      }
    } // namespace detail

    template<typename Funcs>
    Boxed_Value dispatch(const Funcs &funcs, const Function_Params &plist, const Type_Conversions_State &t_conversions) {
      std::vector<std::pair<size_t, const Proxy_Function_Base *>> ordered_funcs;
      ordered_funcs.reserve(funcs.size());

      for (const auto &func : funcs) {
        const auto arity = func->get_arity();

        if (arity == -1) {
          ordered_funcs.emplace_back(plist.size(), func.get());
        } else if (arity == static_cast<int>(plist.size())) {
          size_t numdiffs = 0;
          for (size_t i = 0; i < plist.size(); ++i) {
            if (!func->get_param_types()[i + 1].bare_equal(plist[i].get_type_info())) {
              ++numdiffs;
            }
          }
          ordered_funcs.emplace_back(numdiffs, func.get());
        }
      }

      for (size_t i = 0; i <= plist.size(); ++i) {
        for (const auto &func : ordered_funcs) {
          try {
            if (func.first == i && (i == 0 || func.second->filter(plist, t_conversions))) {
              return (*(func.second))(plist, t_conversions);
            }
          } catch (const exception::bad_boxed_cast &) {
            // parameter failed to cast, try again
          } catch (const exception::arity_error &) {
            // invalid num params, try again
          } catch (const exception::guard_error &) {
            // guard failed to allow the function to execute,
            // try again
          }
        }
      }

      return detail::dispatch_with_conversions(ordered_funcs.cbegin(), ordered_funcs.cend(), plist, t_conversions, funcs);
    }
  } // namespace dispatch
} // namespace chaiscript

#endif