auto walk = [&](int i, int c, auto &&walk) {
        ...
        walk(input[i], c, walk);
    };

#define sptr std::shared_ptr

void foo(std::any input) {
  if (typeid(input) == typeid(CURL*)) {
    ...
  }
}

#define def auto

def sum(int a, int b) -> int {
    return a+b;
}

def sum(any a, any b) -> any {
    return a+b;
}

def main() -> int {
    cout << sum((char *)"123", 456) << endl;
    cout << sum(123, 456) << endl;
}

$ g++ test.cpp -o test
$ ./test 
123456
579

macro_rules! unbracket {
    (_ [$($tt1:tt)*]) => { $($tt1)* };
    (() [$($tt1:tt)*]) => { ($($tt1)*) };
    ([] [$($tt1:tt)*]) => { [$($tt1)*] };
    ({} [$($tt1:tt)*]) => { {$($tt1)*} };
    ($tt0:tt [$($tt1:tt)*] @unbracket ($($tt2:tt)*) $($tt3:tt)*) => { unbracket!{ $tt0 [$($tt1)* $($tt2)*] $($tt3)*} };
    ($tt0:tt [$($tt1:tt)*] @unbracket [$($tt2:tt)*] $($tt3:tt)*) => { unbracket!{ $tt0 [$($tt1)* $($tt2)*] $($tt3)*} };
    ($tt0:tt [$($tt1:tt)*] @unbracket {$($tt2:tt)*} $($tt3:tt)*) => { unbracket!{ $tt0 [$($tt1)* $($tt2)*] $($tt3)*} };
    ($tt0:tt [$($tt1:tt)*] $tt2:tt $($tt3:tt)*) => { unbracket!{$tt0 [$($tt1)* $tt2] $($tt3)*} };
}

template<typename... Ts>
struct Enum: std::variant<Ts...> {
  using std::variant<Ts...>::variant;
  template<typename... Fs>
  decltype(auto) match(this auto&& self, Fs&&... fs) {
    struct Visitor: Fs... { using Fs::operator()...; };
    return std::visit(Visitor{ std::forward<Fs>(fs)... }, self);
  }
};

std::string foo(Enum<int, void*, long, double> e) {
  return e.match(
    [] (int i) { return std::format("Got int {}", i); },
    [] (double d) { return std::format("Got double {}", d); },
    [] (auto&&) { return std::string("Got something else"); }
  );
}

int arr[4];
arr[
  [] { return 0; } ()
] = 1;

int arr[1];
[](){return 0;}()[arr] = 1;

switch(i) {
case 0: [
  [fallthrough]
];
case 1:;
}

template <ObjectLike O, ClassLike C, typename... Args>
[[nodiscard]] util::Ptr<O> UnsafeNew(util::Ptr<C> object_class, Args&&... args) {
    if constexpr (std::is_same_v<O, Struct>) {
        auto new_object = util::MakePtr<Struct>(object_class);
        auto it = util::As<StructClass>(object_class)->GetFields().begin();
        (
            [&it, &args, &new_object] {
                auto class_ = *it++;
                if (util::Is<StructClass>(class_)) {
                    new_object->AddFieldValue(
                        UnsafeNew<Struct>(util::As<StructClass>(class_), args));
                } else if (util::Is<StringClass>(class_)) {
                    if constexpr (std::is_convertible_v<decltype(args), std::string_view>) {
                        new_object->AddFieldValue(
                            UnsafeNew<String>(util::As<StringClass>(class_), args));
                    }
                } else {
                    if constexpr (!std::is_convertible_v<std::remove_reference_t<decltype(args)>,
                                                         std::string_view>) {
#define DDB_ADD_PRIMITIVE(P)                                                     \
    else if (util::Is<PrimitiveClass<P>>(class_)) {                              \
        new_object->AddFieldValue(                                               \
            UnsafeNew<Primitive<P>>(util::As<PrimitiveClass<P>>(class_), args)); \
    }

                        if (false) {
                        }
                        DDB_PRIMITIVE_GENERATOR(DDB_ADD_PRIMITIVE)
#undef DDB_ADD_PRIMITIVE
                    }
                }
            }(),
            ...);
        return new_object;
    } else if constexpr (std::is_same_v<O, String>) {
        return util::MakePtr<String>(object_class, std::move(std::get<0>(std::tuple(args...))));
    } else {
        return util::MakePtr<O>(object_class, std::get<0>(std::tuple(args...)));
    }
    throw error::TypeError("Can't create object");
}