up

src/__stl__.h

@@ -20,7 +20,7 @@
 #include <queue>
 #include <iomanip>
 #include <memory>
-// #include <functional>
+#include <functional>
 
 #include <atomic>
 #include <iostream>

src/main.cpp

@@ -3,7 +3,7 @@
 
 #include "pocketpy.h"
 
-//#define PK_DEBUG_TIME
+#define PK_DEBUG_TIME
 
 struct Timer{
     const char* title;

src/obj.h

@@ -7,10 +7,19 @@ struct BaseRef;
 class VM;
 class Frame;
 
-typedef PyVar (*_CppFunc)(VM*, const pkpy::ArgList&);
+typedef PyVar (*_CppFuncRaw)(VM*, const pkpy::ArgList&);
 //typedef std::function<PyVar(VM*, const pkpy::ArgList&)> _CppFunc;
 typedef pkpy::shared_ptr<CodeObject> _Code;
 
+struct _CppFunc {
+    _CppFuncRaw f;
+    int argc;       // DONOT include self
+    bool method;
+    
+    _CppFunc(_CppFuncRaw f, int argc, bool method) : f(f), argc(argc), method(method) {}
+    inline PyVar operator()(VM* vm, const pkpy::ArgList& args) const;
+};
+
 struct Function {
     _Str name;
     _Code code;

src/pocketpy.h

@@ -16,7 +16,7 @@ _Code VM::compile(_Str source, _Str filename, CompileMode mode) {
 }
 
 #define BIND_NUM_ARITH_OPT(name, op)                                                                    \
-    _vm->bindMethodMulti({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){                 \
+    _vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){                 \
         if(!vm->is_int_or_float(args[0], args[1]))                                                         \
             vm->typeError("unsupported operand type(s) for " #op );                                     \
         if(args._index(0)->is_type(vm->_tp_int) && args._index(1)->is_type(vm->_tp_int)){                 \
@@ -27,7 +27,7 @@ _Code VM::compile(_Str source, _Str filename, CompileMode mode) {
     });
 
 #define BIND_NUM_LOGICAL_OPT(name, op, is_eq)                                                           \
-    _vm->bindMethodMulti({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){                 \
+    _vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){                 \
         if(!vm->is_int_or_float(args[0], args[1])){                                                        \
             if constexpr(is_eq) return vm->PyBool(args[0] == args[1]);                                  \
             vm->typeError("unsupported operand type(s) for " #op );                                     \
@@ -50,57 +50,48 @@ void __initializeBuiltinFunctions(VM* _vm) {
 #undef BIND_NUM_ARITH_OPT
 #undef BIND_NUM_LOGICAL_OPT
 
-    _vm->bindBuiltinFunc("__sys_stdout_write", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("__sys_stdout_write", [](VM* vm, const pkpy::ArgList& args) {
         (*vm->_stdout) << vm->PyStr_AS_C(args[0]);
         return vm->None;
     });
 
-    _vm->bindBuiltinFunc("super", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 0);
+    _vm->bindBuiltinFunc<0>("super", [](VM* vm, const pkpy::ArgList& args) {
         auto it = vm->top_frame()->f_locals.find(m_self);
         if(it == vm->top_frame()->f_locals.end()) vm->typeError("super() can only be called in a class method");
         return vm->new_object(vm->_tp_super, it->second);
     });
 
-    _vm->bindBuiltinFunc("eval", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("eval", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& expr = vm->PyStr_AS_C(args[0]);
         _Code code = vm->compile(expr, "<eval>", EVAL_MODE);
         return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->f_locals_copy());
     });
 
-    _vm->bindBuiltinFunc("repr", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("repr", [](VM* vm, const pkpy::ArgList& args) {
         return vm->asRepr(args[0]);
     });
 
-    _vm->bindBuiltinFunc("hash", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("hash", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyInt(vm->hash(args[0]));
     });
 
-    _vm->bindBuiltinFunc("len", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("len", [](VM* vm, const pkpy::ArgList& args) {
         return vm->call(args[0], __len__, pkpy::noArg());
     });
 
-    _vm->bindBuiltinFunc("chr", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("chr", [](VM* vm, const pkpy::ArgList& args) {
         i64 i = vm->PyInt_AS_C(args[0]);
         if (i < 0 || i > 128) vm->valueError("chr() arg not in range(128)");
         return vm->PyStr(std::string(1, (char)i));
     });
 
-    _vm->bindBuiltinFunc("ord", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("ord", [](VM* vm, const pkpy::ArgList& args) {
         _Str s = vm->PyStr_AS_C(args[0]);
         if (s.size() != 1) vm->typeError("ord() expected an ASCII character");
         return vm->PyInt((i64)s[0]);
     });
 
-    _vm->bindBuiltinFunc("globals", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 0);
+    _vm->bindBuiltinFunc<0>("globals", [](VM* vm, const pkpy::ArgList& args) {
         const auto& d = vm->top_frame()->f_globals();
         PyVar obj = vm->call(vm->builtins->attribs["dict"]);
         for (const auto& [k, v] : d) {
@@ -109,8 +100,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return obj;
     });
 
-    _vm->bindBuiltinFunc("locals", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 0);
+    _vm->bindBuiltinFunc<0>("locals", [](VM* vm, const pkpy::ArgList& args) {
         const auto& d = vm->top_frame()->f_locals;
         PyVar obj = vm->call(vm->builtins->attribs["dict"]);
         for (const auto& [k, v] : d) {
@@ -119,15 +109,13 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return obj;
     });
 
-    _vm->bindBuiltinFunc("hex", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("hex", [](VM* vm, const pkpy::ArgList& args) {
         std::stringstream ss;
         ss << std::hex << vm->PyInt_AS_C(args[0]);
         return vm->PyStr("0x" + ss.str());
     });
 
-    _vm->bindBuiltinFunc("dir", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindBuiltinFunc<1>("dir", [](VM* vm, const pkpy::ArgList& args) {
         std::vector<_Str> names;
         for (auto& [k, _] : args[0]->attribs) names.push_back(k);
         for (auto& [k, _] : args[0]->_type->attribs) {
@@ -142,7 +130,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyList(ret);
     });
 
-    _vm->bindMethod("object", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("object", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         PyVar _self = args[0];
         std::stringstream ss;
         ss << std::hex << (uintptr_t)_self.get();
@@ -150,17 +138,15 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyStr(s);
     });
 
-    _vm->bindMethod("type", "__new__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindStaticMethod<1>("type", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         return args[0]->_type;
     });
 
-    _vm->bindMethod("type", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2, true);
+    _vm->bindMethod<1>("type", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyBool(args[0] == args[1]);
     });
 
-    _vm->bindMethod("range", "__new__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindStaticMethod<-1>("range", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         _Range r;
         switch (args.size()) {
             case 1: r.stop = vm->PyInt_AS_C(args[0]); break;
@@ -171,26 +157,25 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyRange(r);
     });
 
-    _vm->bindMethod("range", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_type(args[0], vm->_tp_range);
+    _vm->bindMethod<0>("range", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyIter(
             pkpy::make_shared<BaseIterator, RangeIterator>(vm, args[0])
         );
     });
 
-    _vm->bindMethod("NoneType", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("NoneType", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyStr("None");
     });
 
-    _vm->bindMethod("NoneType", "__json__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("NoneType", "__json__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyStr("null");
     });
 
-    _vm->bindMethod("NoneType", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("NoneType", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyBool(args[0] == args[1]);
     });
 
-    _vm->bindMethodMulti({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethodMulti<1>({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::ArgList& args) {
         if(!vm->is_int_or_float(args[0], args[1]))
             vm->typeError("unsupported operand type(s) for " "/" );
         f64 rhs = vm->num_to_float(args[1]);
@@ -198,7 +183,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyFloat(vm->num_to_float(args[0]) / rhs);
     });
 
-    _vm->bindMethodMulti({"int", "float"}, "__pow__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethodMulti<1>({"int", "float"}, "__pow__", [](VM* vm, const pkpy::ArgList& args) {
         if(!vm->is_int_or_float(args[0], args[1]))
             vm->typeError("unsupported operand type(s) for " "**" );
         if(args[0]->is_type(vm->_tp_int) && args[1]->is_type(vm->_tp_int)){
@@ -209,9 +194,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
     });
 
     /************ PyInt ************/
-    _vm->bindMethod("int", "__new__", [](VM* vm, const pkpy::ArgList& args) {
-        if(args.size() == 0) return vm->PyInt(0);
-        vm->check_args_size(args, 1);
+    _vm->bindStaticMethod<1>("int", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         if (args[0]->is_type(vm->_tp_int)) return args[0];
         if (args[0]->is_type(vm->_tp_float)) return vm->PyInt((i64)vm->PyFloat_AS_C(args[0]));
         if (args[0]->is_type(vm->_tp_bool)) return vm->PyInt(vm->PyBool_AS_C(args[0]) ? 1 : 0);
@@ -230,7 +213,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->None;
     });
 
-    _vm->bindMethod("int", "__floordiv__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("int", "__floordiv__", [](VM* vm, const pkpy::ArgList& args) {
         if(!args[0]->is_type(vm->_tp_int) || !args[1]->is_type(vm->_tp_int))
             vm->typeError("unsupported operand type(s) for " "//" );
         i64 rhs = vm->PyInt_AS_C(args._index(1));
@@ -238,7 +221,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyInt(vm->PyInt_AS_C(args._index(0)) / rhs);
     });
 
-    _vm->bindMethod("int", "__mod__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("int", "__mod__", [](VM* vm, const pkpy::ArgList& args) {
         if(!args[0]->is_type(vm->_tp_int) || !args[1]->is_type(vm->_tp_int))
             vm->typeError("unsupported operand type(s) for " "%" );
         i64 rhs = vm->PyInt_AS_C(args._index(1));
@@ -246,17 +229,16 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyInt(vm->PyInt_AS_C(args._index(0)) % rhs);
     });
 
-    _vm->bindMethod("int", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("int", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])));
     });
 
-    _vm->bindMethod("int", "__json__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("int", "__json__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyStr(std::to_string((int)vm->PyInt_AS_C(args[0])));
     });
 
 #define __INT_BITWISE_OP(name,op) \
-    _vm->bindMethod("int", #name, [](VM* vm, const pkpy::ArgList& args) {                       \
-        vm->check_args_size(args, 2, true);                                                     \
+    _vm->bindMethod<1>("int", #name, [](VM* vm, const pkpy::ArgList& args) {                    \
         return vm->PyInt(vm->PyInt_AS_C(args._index(0)) op vm->PyInt_AS_C(args._index(1)));     \
     });
 
@@ -269,9 +251,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
 #undef __INT_BITWISE_OP
 
     /************ PyFloat ************/
-    _vm->bindMethod("float", "__new__", [](VM* vm, const pkpy::ArgList& args) {
-        if(args.size() == 0) return vm->PyFloat(0.0);
-        vm->check_args_size(args, 1);
+    _vm->bindStaticMethod<1>("float", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         if (args[0]->is_type(vm->_tp_int)) return vm->PyFloat((f64)vm->PyInt_AS_C(args[0]));
         if (args[0]->is_type(vm->_tp_float)) return args[0];
         if (args[0]->is_type(vm->_tp_bool)) return vm->PyFloat(vm->PyBool_AS_C(args[0]) ? 1.0 : 0.0);
@@ -290,7 +270,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->None;
     });
 
-    _vm->bindMethod("float", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("float", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         f64 val = vm->PyFloat_AS_C(args[0]);
         if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val));
         _StrStream ss;
@@ -300,60 +280,59 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyStr(s);
     });
 
-    _vm->bindMethod("float", "__json__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("float", "__json__", [](VM* vm, const pkpy::ArgList& args) {
         f64 val = vm->PyFloat_AS_C(args[0]);
         if(std::isinf(val) || std::isnan(val)) vm->valueError("cannot jsonify 'nan' or 'inf'");
         return vm->PyStr(std::to_string(val));
     });
 
     /************ PyString ************/
-    _vm->bindMethod("str", "__new__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindStaticMethod<1>("str", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->asStr(args._index(0));
     });
 
-    _vm->bindMethod("str", "__add__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("str", "__add__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& lhs = vm->PyStr_AS_C(args[0]);
         const _Str& rhs = vm->PyStr_AS_C(args[1]);
         return vm->PyStr(lhs + rhs);
     });
 
-    _vm->bindMethod("str", "__len__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("str", "__len__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         return vm->PyInt(_self.u8_length());
     });
 
-    _vm->bindMethod("str", "__contains__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("str", "__contains__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         const _Str& _other = vm->PyStr_AS_C(args[1]);
         return vm->PyBool(_self.find(_other) != _Str::npos);
     });
 
-    _vm->bindMethod("str", "__str__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("str", "__str__", [](VM* vm, const pkpy::ArgList& args) {
         return args[0]; // str is immutable
     });
 
-    _vm->bindMethod("str", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("str", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyIter(pkpy::make_shared<BaseIterator, StringIterator>(vm, args[0]));
     });
 
-    _vm->bindMethod("str", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("str", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         return vm->PyStr(_self.__escape(true));
     });
 
-    _vm->bindMethod("str", "__json__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("str", "__json__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         return vm->PyStr(_self.__escape(false));
     });
 
-    _vm->bindMethod("str", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("str", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
         if(args[0]->is_type(vm->_tp_str) && args[1]->is_type(vm->_tp_str))
             return vm->PyBool(vm->PyStr_AS_C(args[0]) == vm->PyStr_AS_C(args[1]));
         return vm->PyBool(args[0] == args[1]);      // fallback
     });
 
-    _vm->bindMethod("str", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("str", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self (vm->PyStr_AS_C(args[0]));
 
         if(args[1]->is_type(vm->_tp_slice)){
@@ -367,20 +346,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyStr(_self.u8_getitem(_index));
     });
 
-    _vm->bindMethod("str", "__gt__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("str", "__gt__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self (vm->PyStr_AS_C(args[0]));
         const _Str& _obj (vm->PyStr_AS_C(args[1]));
         return vm->PyBool(_self > _obj);
     });
 
-    _vm->bindMethod("str", "__lt__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("str", "__lt__", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self (vm->PyStr_AS_C(args[0]));
         const _Str& _obj (vm->PyStr_AS_C(args[1]));
         return vm->PyBool(_self < _obj);
     });
 
-    _vm->bindMethod("str", "replace", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 3, true);
+    _vm->bindMethod<2>("str", "replace", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         const _Str& _old = vm->PyStr_AS_C(args[1]);
         const _Str& _new = vm->PyStr_AS_C(args[2]);
@@ -394,22 +372,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyStr(_copy);
     });
 
-    _vm->bindMethod("str", "startswith", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2, true);
+    _vm->bindMethod<1>("str", "startswith", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         const _Str& _prefix = vm->PyStr_AS_C(args[1]);
         return vm->PyBool(_self.find(_prefix) == 0);
     });
 
-    _vm->bindMethod("str", "endswith", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2, true);
+    _vm->bindMethod<1>("str", "endswith", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         const _Str& _suffix = vm->PyStr_AS_C(args[1]);
         return vm->PyBool(_self.rfind(_suffix) == _self.length() - _suffix.length());
     });
 
-    _vm->bindMethod("str", "join", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2, true);
+    _vm->bindMethod<1>("str", "join", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& _self = vm->PyStr_AS_C(args[0]);
         PyVarList* _list;
         if(args[1]->is_type(vm->_tp_list)){
@@ -428,22 +403,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
     });
 
     /************ PyList ************/
-    _vm->bindMethod("list", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_type(args[0], vm->_tp_list);
+    _vm->bindMethod<0>("list", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyIter(
             pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0])
         );
     });
 
-    _vm->bindMethod("list", "append", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2, true);
+    _vm->bindMethod<1>("list", "append", [](VM* vm, const pkpy::ArgList& args) {
         PyVarList& _self = vm->PyList_AS_C(args[0]);
         _self.push_back(args._index(1));
         return vm->None;
     });
 
-    _vm->bindMethod("list", "insert", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 3, true);
+    _vm->bindMethod<2>("list", "insert", [](VM* vm, const pkpy::ArgList& args) {
         PyVarList& _self = vm->PyList_AS_C(args[0]);
         int _index = (int)vm->PyInt_AS_C(args[1]);
         if(_index < 0) _index += _self.size();
@@ -453,18 +425,16 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->None;
     });
 
-    _vm->bindMethod("list", "clear", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1, true);
+    _vm->bindMethod<0>("list", "clear", [](VM* vm, const pkpy::ArgList& args) {
         vm->PyList_AS_C(args[0]).clear();
         return vm->None;
     });
 
-    _vm->bindMethod("list", "copy", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1, true);
+    _vm->bindMethod<0>("list", "copy", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyList(vm->PyList_AS_C(args[0]));
     });
 
-    _vm->bindMethod("list", "__add__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("list", "__add__", [](VM* vm, const pkpy::ArgList& args) {
         const PyVarList& _self = vm->PyList_AS_C(args[0]);
         const PyVarList& _obj = vm->PyList_AS_C(args[1]);
         PyVarList _new_list = _self;
@@ -472,12 +442,12 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->PyList(_new_list);
     });
 
-    _vm->bindMethod("list", "__len__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("list", "__len__", [](VM* vm, const pkpy::ArgList& args) {
         const PyVarList& _self = vm->PyList_AS_C(args[0]);
         return vm->PyInt(_self.size());
     });
 
-    _vm->bindMethod("list", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("list", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
         const PyVarList& _self = vm->PyList_AS_C(args[0]);
 
         if(args[1]->is_type(vm->_tp_slice)){
@@ -494,7 +464,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return _self[_index];
     });
 
-    _vm->bindMethod("list", "__setitem__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<2>("list", "__setitem__", [](VM* vm, const pkpy::ArgList& args) {
         PyVarList& _self = vm->PyList_AS_C(args[0]);
         int _index = (int)vm->PyInt_AS_C(args[1]);
         _index = vm->normalizedIndex(_index, _self.size());
@@ -502,7 +472,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
         return vm->None;
     });
 
-    _vm->bindMethod("list", "__delitem__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("list", "__delitem__", [](VM* vm, const pkpy::ArgList& args) {
         PyVarList& _self = vm->PyList_AS_C(args[0]);
         int _index = (int)vm->PyInt_AS_C(args[1]);
         _index = vm->normalizedIndex(_index, _self.size());
@@ -511,25 +481,21 @@ void __initializeBuiltinFunctions(VM* _vm) {
     });
 
     /************ PyTuple ************/
-    _vm->bindMethod("tuple", "__new__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindStaticMethod<1>("tuple", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         PyVarList _list = vm->PyList_AS_C(vm->call(vm->builtins->attribs["list"], args));
         return vm->PyTuple(_list);
     });
 
-    _vm->bindMethod("tuple", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_type(args[0], vm->_tp_tuple);
-        return vm->PyIter(
-            pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0])
-        );
+    _vm->bindMethod<0>("tuple", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
+        return vm->PyIter(pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0]));
     });
 
-    _vm->bindMethod("tuple", "__len__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("tuple", "__len__", [](VM* vm, const pkpy::ArgList& args) {
         const PyVarList& _self = vm->PyTuple_AS_C(args[0]);
         return vm->PyInt(_self.size());
     });
 
-    _vm->bindMethod("tuple", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("tuple", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
         const PyVarList& _self = vm->PyTuple_AS_C(args[0]);
         int _index = (int)vm->PyInt_AS_C(args[1]);
         _index = vm->normalizedIndex(_index, _self.size());
@@ -537,52 +503,33 @@ void __initializeBuiltinFunctions(VM* _vm) {
     });
 
     /************ PyBool ************/
-    _vm->bindMethod("bool", "__new__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    _vm->bindStaticMethod<1>("bool", "__new__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->asBool(args[0]);
     });
 
-    _vm->bindMethod("bool", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("bool", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         bool val = vm->PyBool_AS_C(args[0]);
         return vm->PyStr(val ? "True" : "False");
     });
 
-    _vm->bindMethod("bool", "__json__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("bool", "__json__", [](VM* vm, const pkpy::ArgList& args) {
         bool val = vm->PyBool_AS_C(args[0]);
         return vm->PyStr(val ? "true" : "false");
     });
 
-    _vm->bindMethod("bool", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("bool", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyBool(args[0] == args[1]);
     });
 
-    _vm->bindMethod("bool", "__xor__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<1>("bool", "__xor__", [](VM* vm, const pkpy::ArgList& args) {
         bool _self = vm->PyBool_AS_C(args[0]);
         bool _obj = vm->PyBool_AS_C(args[1]);
         return vm->PyBool(_self ^ _obj);
     });
 
-    _vm->bindMethod("ellipsis", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
+    _vm->bindMethod<0>("ellipsis", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyStr("Ellipsis");
     });
-
-    _vm->bindMethod("_native_function", "__call__", [](VM* vm, const pkpy::ArgList& args) {
-        const _CppFunc& _self = vm->PyNativeFunction_AS_C(args[0]);
-        return _self(vm, args.subList(1));
-    });
-
-    _vm->bindMethod("function", "__call__", [](VM* vm, const pkpy::ArgList& args) {
-        return vm->call(args[0], args.subList(1));
-    });
-
-    _vm->bindMethod("_bounded_method", "__call__", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_type(args[0], vm->_tp_bounded_method);
-        const _BoundedMethod& _self = vm->PyBoundedMethod_AS_C(args[0]);
-        pkpy::ArgList newArgs(args.size());
-        newArgs[0] = _self.obj;
-        for(int i = 1; i < args.size(); i++) newArgs[i] = args[i];
-        return vm->call(_self.method, newArgs);
-    });
 }
 
 #include "builtins.h"
@@ -601,7 +548,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
 
 void __addModuleTime(VM* vm){
     PyVar mod = vm->newModule("time");
-    vm->bindFunc(mod, "time", [](VM* vm, const pkpy::ArgList& args) {
+    vm->bindFunc<0>(mod, "time", [](VM* vm, const pkpy::ArgList& args) {
         auto now = std::chrono::high_resolution_clock::now();
         return vm->PyFloat(std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count() / 1000000.0);
     });
@@ -609,18 +556,15 @@ void __addModuleTime(VM* vm){
 
 void __addModuleSys(VM* vm){
     PyVar mod = vm->newModule("sys");
-    vm->bindFunc(mod, "getrefcount", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "getrefcount", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyInt(args[0].use_count());
     });
 
-    vm->bindFunc(mod, "getrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 0);
+    vm->bindFunc<0>(mod, "getrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyInt(vm->maxRecursionDepth);
     });
 
-    vm->bindFunc(mod, "setrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "setrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
         vm->maxRecursionDepth = (int)vm->PyInt_AS_C(args[0]);
         return vm->None;
     });
@@ -630,15 +574,13 @@ void __addModuleSys(VM* vm){
 
 void __addModuleJson(VM* vm){
     PyVar mod = vm->newModule("json");
-    vm->bindFunc(mod, "loads", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "loads", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& expr = vm->PyStr_AS_C(args[0]);
         _Code code = vm->compile(expr, "<json>", JSON_MODE);
         return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->f_locals_copy());
     });
 
-    vm->bindFunc(mod, "dumps", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "dumps", [](VM* vm, const pkpy::ArgList& args) {
         return vm->asJson(args[0]);
     });
 }
@@ -648,63 +590,88 @@ void __addModuleMath(VM* vm){
     vm->setattr(mod, "pi", vm->PyFloat(3.1415926535897932384));
     vm->setattr(mod, "e" , vm->PyFloat(2.7182818284590452354));
 
-    vm->bindFunc(mod, "log", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "log", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyFloat(log(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "log10", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "log10", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyFloat(log10(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "log2", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "log2", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyFloat(log2(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "sin", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "sin", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyFloat(sin(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "cos", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "cos", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyFloat(cos(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "tan", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "tan", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyFloat(tan(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "isclose", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2);
+    vm->bindFunc<2>(mod, "isclose", [](VM* vm, const pkpy::ArgList& args) {
         f64 a = vm->num_to_float(args[0]);
         f64 b = vm->num_to_float(args[1]);
         return vm->PyBool(fabs(a - b) < 1e-9);
     });
 
-    vm->bindFunc(mod, "isnan", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "isnan", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyBool(std::isnan(vm->num_to_float(args[0])));
     });
 
-    vm->bindFunc(mod, "isinf", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1);
+    vm->bindFunc<1>(mod, "isinf", [](VM* vm, const pkpy::ArgList& args) {
         return vm->PyBool(std::isinf(vm->num_to_float(args[0])));
     });
 }
 
 
+#define PY_CLASS(mod, name) inline static PyVar _tp(VM* vm) { return vm->_modules[#mod]->attribs[#name]; }
+
 struct ReMatch {
+    PY_CLASS(re, Match)
+
     i64 start;
     i64 end;
     std::smatch m;
     ReMatch(i64 start, i64 end, std::smatch m) : start(start), end(end), m(m) {}
+
+    static PyVar _bind(VM* vm){
+        PyVar _tp_match = vm->new_user_type_object(vm->_modules["re"], "Match", vm->_tp_object);
+        vm->bindMethod<0>(_tp_match, "start", [](VM* vm, const pkpy::ArgList& args) {
+            return vm->PyInt(UNION_GET(ReMatch, args[0]).start);
+        });
+
+        vm->bindMethod<0>(_tp_match, "end", [](VM* vm, const pkpy::ArgList& args) {
+            return vm->PyInt(UNION_GET(ReMatch, args[0]).end);
+        });
+
+        vm->bindMethod<0>(_tp_match, "span", [](VM* vm, const pkpy::ArgList& args) {
+            auto& m = UNION_GET(ReMatch, args[0]);
+            PyVarList vec = { vm->PyInt(m.start), vm->PyInt(m.end) };
+            return vm->PyTuple(vec);
+        });
+
+        vm->bindMethod<1>(_tp_match, "group", [](VM* vm, const pkpy::ArgList& args) {
+            auto& m = UNION_GET(ReMatch, args[0]);
+            int index = (int)vm->PyInt_AS_C(args[1]);
+            vm->normalizedIndex(index, m.m.size());
+            return vm->PyStr(m.m[index].str());
+        });
+        return _tp_match;
+    }
 };
 
 
+// C绑定过程
+// 一个C原生类
+// static PyVar _tp(VM* vm); 实现从VM中获取该类的类型对象
+// static PyVar _bind(VM* vm); 实现初始化该类的绑定，在VM中注册该类的类型对象，并返回生成的类型对象
+
 PyVar __regex_search(const _Str& pattern, const _Str& string, bool fromStart, VM* vm){
     std::regex re(pattern);
     std::smatch m;
@@ -712,55 +679,28 @@ PyVar __regex_search(const _Str& pattern, const _Str& string, bool fromStart, VM
         if(fromStart && m.position() != 0) return vm->None;
         i64 start = string.__to_u8_index(m.position());
         i64 end = string.__to_u8_index(m.position() + m.length());
-        return vm->new_object(vm->_userTypes["re.Match"], ReMatch(start, end, m));
+        return vm->new_object_c<ReMatch>(start, end, m);
     }
     return vm->None;
 };
 
 void __addModuleRe(VM* vm){
     PyVar mod = vm->newModule("re");
-    PyVar _tp_match = vm->new_user_type_object(mod, "Match", vm->_tp_object);
-    vm->bindMethod("re.Match", "start", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1, true);
-        return vm->PyInt(UNION_GET(ReMatch, args[0]).start);
-    });
-
-    vm->bindMethod("re.Match", "end", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1, true);
-        return vm->PyInt(UNION_GET(ReMatch, args[0]).end);
-    });
-
-    vm->bindMethod("re.Match", "span", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 1, true);
-        auto& m = UNION_GET(ReMatch, args[0]);
-        PyVarList vec = { vm->PyInt(m.start), vm->PyInt(m.end) };
-        return vm->PyTuple(vec);
-    });
-
-    vm->bindMethod("re.Match", "group", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2, true);
-        auto& m = UNION_GET(ReMatch, args[0]);
-        int index = (int)vm->PyInt_AS_C(args[1]);
-        vm->normalizedIndex(index, m.m.size());
-        return vm->PyStr(m.m[index].str());
-    });
+    ReMatch::_bind(vm);
 
-    vm->bindFunc(mod, "match", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2);
+    vm->bindFunc<2>(mod, "match", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& pattern = vm->PyStr_AS_C(args[0]);
         const _Str& string = vm->PyStr_AS_C(args[1]);
         return __regex_search(pattern, string, true, vm);
     });
 
-    vm->bindFunc(mod, "search", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2);
+    vm->bindFunc<2>(mod, "search", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& pattern = vm->PyStr_AS_C(args[0]);
         const _Str& string = vm->PyStr_AS_C(args[1]);
         return __regex_search(pattern, string, false, vm);
     });
 
-    vm->bindFunc(mod, "sub", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 3);
+    vm->bindFunc<3>(mod, "sub", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& pattern = vm->PyStr_AS_C(args[0]);
         const _Str& repl = vm->PyStr_AS_C(args[1]);
         const _Str& string = vm->PyStr_AS_C(args[2]);
@@ -768,8 +708,7 @@ void __addModuleRe(VM* vm){
         return vm->PyStr(std::regex_replace(string, re, repl));
     });
 
-    vm->bindFunc(mod, "split", [](VM* vm, const pkpy::ArgList& args) {
-        vm->check_args_size(args, 2);
+    vm->bindFunc<2>(mod, "split", [](VM* vm, const pkpy::ArgList& args) {
         const _Str& pattern = vm->PyStr_AS_C(args[0]);
         const _Str& string = vm->PyStr_AS_C(args[1]);
         std::regex re(pattern);

src/vm.h

@@ -22,7 +22,6 @@
 
 class VM {
     std::vector<PyVar> _small_integers;             // [-5, 256]
-    PyVarDict _modules;                             // loaded modules
     emhash8::HashMap<_Str, _Str> _lazy_modules;     // lazy loaded modules
 protected:
     std::deque< std::unique_ptr<Frame> > callstack;
@@ -340,7 +339,7 @@ protected:
 
 public:
     PyVarDict _types;
-    PyVarDict _userTypes;
+    PyVarDict _modules;                             // loaded modules
     PyVar None, True, False, Ellipsis;
 
     bool use_stdio;
@@ -578,7 +577,6 @@ public:
         setattr(obj, __base__, base);
         _Str fullName = UNION_NAME(mod) + "." +name;
         setattr(obj, __name__, PyStr(fullName));
-        _userTypes[fullName] = obj;
         setattr(mod, name, obj);
         return obj;
     }
@@ -597,6 +595,11 @@ public:
         return pkpy::make_shared<PyObject, Py_<T>>(_value, type);
     }
 
+    template<typename T, typename... Args>
+    inline PyVar new_object_c(Args&&... args) {
+        return new_object(T::_tp(this), T(std::forward<Args>(args)...));
+    }
+
     PyVar newModule(_Str name) {
         PyVar obj = new_object(_tp_module, (i64)-2);
         setattr(obj, __name__, PyStr(name));
@@ -658,28 +661,35 @@ public:
         setattr(obj.get(), name, value);
     }
 
-    void bindMethod(_Str typeName, _Str funcName, _CppFunc fn) {
-        PyVar* type = _types.try_get(typeName);
-        if(type == nullptr) type = _userTypes.try_get(typeName);
-        if(type == nullptr) UNREACHABLE();
-        PyVar func = PyNativeFunction(fn);
-        setattr(*type, funcName, func);
+    template<int ARGC>
+    void bindMethod(PyVar obj, _Str funcName, _CppFuncRaw fn) {
+        check_type(obj, _tp_type);
+        setattr(obj, funcName, PyNativeFunction(_CppFunc(fn, ARGC, true)));
     }
 
-    void bindMethodMulti(std::vector<_Str> typeNames, _Str funcName, _CppFunc fn) {
-        for(auto& typeName : typeNames){
-            bindMethod(typeName, funcName, fn);
-        }
+    template<int ARGC>
+    void bindFunc(PyVar obj, _Str funcName, _CppFuncRaw fn) {
+        setattr(obj, funcName, PyNativeFunction(_CppFunc(fn, ARGC, false)));
+    }
+
+    template<int ARGC>
+    void bindMethod(_Str typeName, _Str funcName, _CppFuncRaw fn) {
+        bindMethod<ARGC>(_types[typeName], funcName, fn);
     }
 
-    void bindBuiltinFunc(_Str funcName, _CppFunc fn) {
-        bindFunc(builtins, funcName, fn);
+    template<int ARGC>
+    void bindStaticMethod(_Str typeName, _Str funcName, _CppFuncRaw fn) {
+        bindFunc<ARGC>(_types[typeName], funcName, fn);
     }
 
-    void bindFunc(PyVar module, _Str funcName, _CppFunc fn) {
-        check_type(module, _tp_module);
-        PyVar func = PyNativeFunction(fn);
-        setattr(module, funcName, func);
+    template<int ARGC>
+    void bindMethodMulti(std::vector<_Str> typeNames, _Str funcName, _CppFuncRaw fn) {
+        for(auto& typeName : typeNames) bindMethod<ARGC>(typeName, funcName, fn);
+    }
+
+    template<int ARGC>
+    void bindBuiltinFunc(_Str funcName, _CppFuncRaw fn) {
+        bindFunc<ARGC>(builtins, funcName, fn);
     }
 
     inline bool is_int_or_float(const PyVar& obj) const{
@@ -848,8 +858,8 @@ public:
         _tp_bounded_method = new_type_object("_bounded_method");
         _tp_super = new_type_object("super");
 
-        this->None = new_object(_types["NoneType"], (i64)0);
-        this->Ellipsis = new_object(_types["ellipsis"], (i64)0);
+        this->None = new_object(_types["NoneType"], DUMMY_VAL);
+        this->Ellipsis = new_object(_types["ellipsis"], DUMMY_VAL);
         this->True = new_object(_tp_bool, true);
         this->False = new_object(_tp_bool, false);
         this->builtins = newModule("builtins");
@@ -925,12 +935,6 @@ public:
         if(!obj->is_type(type)) typeError("expected '" + UNION_NAME(type) + "', but got '" + UNION_TP_NAME(obj) + "'");
     }
 
-    inline void check_args_size(const pkpy::ArgList& args, int size, bool method=false){
-        if(args.size() == size) return;
-        if(method) typeError(args.size()>size ? "too many arguments" : "too few arguments");
-        else typeError("expected " + std::to_string(size) + " arguments, but got " + std::to_string(args.size()));
-    }
-
     virtual ~VM() {
         if(!use_stdio){
             delete _stdout;
@@ -1058,4 +1062,12 @@ PyVar RangeIterator::next(){
 
 PyVar StringIterator::next(){
     return vm->PyStr(str.u8_getitem(index++));
+}
+
+PyVar _CppFunc::operator()(VM* vm, const pkpy::ArgList& args) const{
+    int args_size = args.size() - (int)method;  // remove self
+    if(argc != -1 && args_size != argc) {
+        vm->typeError("expected " + std::to_string(argc) + " arguments, but got " + std::to_string(args_size));
+    }
+    return f(vm, args);
 }