reverted removing overloaded_rec

Author: tomoyanonymous

src/basic/type.hpp

@@ -281,7 +281,7 @@ template <typename T>
 constexpr bool is_primitive_type = std::is_base_of_v<PrimitiveType, std::decay_t<T>>;
 
 inline bool isPrimitive(const Value& v) {
-  return std::visit(overloaded{[](auto&& a) { return is_primitive_type<decltype(a)>; },
+  return std::visit(overloaded_rec{[](auto&& a) { return is_primitive_type<decltype(a)>; },
                                [](Alias const& a) { return isPrimitive(a.target); }},
                     v);
 }

src/basic/variant_visitor_helper.hpp

@@ -14,6 +14,7 @@ struct overloaded : Ts... {
 template <class... Ts>
 overloaded(Ts...) -> overloaded<Ts...>;
 
+
 namespace mimium {
 // recursive variant
 
@@ -44,6 +45,31 @@ bool operator!=(const Box<T>& t1, const Box<T>& t2) {
   return !(t1 == t2);
 }
 
+template <class T>
+constexpr bool isBoxed(T /*v*/) {
+  return false;
+}
+template <class T>
+constexpr bool isBoxed(Box<T> /*v*/) {
+  return true;
+}
+template <typename T>
+using boxenabler = std::enable_if_t<isBoxed(T())>;
+
+template <class... Ts>
+struct overloaded_rec : Ts... {
+  using Ts::operator()...;
+  template <typename T>
+  decltype(auto) operator()(Box<T> a) {
+    return (*this)(a.getraw());
+  }
+  template <typename T, boxenabler<T>>
+  decltype(auto) operator()(T&& a) {
+    return (*this)(std::forward<decltype(a)>(a.getraw()));
+  }
+};
+template <class... Ts>
+overloaded_rec(Ts...) -> overloaded_rec<Ts...>;
 
 namespace rv {
 

src/compiler/mirgenerator.hpp

@@ -16,7 +16,7 @@ namespace mir {
 
 inline types::Value lowerType(types::Value const& t) {
   return std::visit(
-      overloaded{
+      overloaded_rec{
           [](auto const& i) {
             assert(types::is_primitive_type<decltype(i)>);
             return types::Value{i};