Significant improvements to new function definition style

- PyRef<T> type for accepting references to payloads.
- Args<T> type for consuming remaining positional args
  (mirrors python `*args`).
- KwArgs<T> type for consuming remaining keyword args
  (mirrors python `*kwargs`).
- OptArg<T> type for consuming remaining keyword args
  (no python code equivalent, only possible in native functions like in cpython).
- PyIterable<T> for accepting an iterator over a sequence of Ts.
- Arity checking (but TypeError messages need work)

Author: OddCoincidence

vm/src/function.rs

@@ -0,0 +1,41 @@
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+use crate::obj::objtype;
+use crate::pyobject::{PyObjectPayload2, PyObjectRef, PyResult, TryFromObject};
+use crate::vm::VirtualMachine;
+
+// TODO: Move PyFuncArgs, FromArgs, etc. here
+
+pub struct PyRef<T> {
+    // invariant: this obj must always have payload of type T
+    obj: PyObjectRef,
+    _payload: PhantomData<T>,
+}
+
+impl<T> Deref for PyRef<T>
+where
+    T: PyObjectPayload2,
+{
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.obj.payload().expect("unexpected payload for type")
+    }
+}
+
+impl<T> TryFromObject for PyRef<T>
+where
+    T: PyObjectPayload2,
+{
+    fn try_from_object(vm: &mut VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        if objtype::isinstance(&obj, &T::required_type(&vm.ctx)) {
+            Ok(PyRef {
+                obj,
+                _payload: PhantomData,
+            })
+        } else {
+            Err(vm.new_type_error("wrong type".to_string())) // TODO: better message
+        }
+    }
+}

vm/src/lib.rs

@@ -38,6 +38,7 @@ pub mod eval;
 mod exceptions;
 pub mod format;
 mod frame;
+pub mod function;
 pub mod import;
 pub mod obj;
 pub mod pyobject;

vm/src/obj/objint.rs

@@ -4,7 +4,7 @@ use super::objtype;
 use crate::format::FormatSpec;
 use crate::pyobject::{
     FromPyObjectRef, IntoPyObject, PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef,
-    PyResult, TypeProtocol,
+    PyResult, TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_bigint::{BigInt, ToBigInt};
@@ -31,6 +31,26 @@ impl IntoPyObject for usize {
     }
 }
 
+impl TryFromObject for usize {
+    fn try_from_object(vm: &mut VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        // FIXME: don't use get_value
+        match get_value(&obj).to_usize() {
+            Some(value) => Ok(value),
+            None => Err(vm.new_overflow_error("Int value cannot fit into Rust usize".to_string())),
+        }
+    }
+}
+
+impl TryFromObject for isize {
+    fn try_from_object(vm: &mut VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        // FIXME: don't use get_value
+        match get_value(&obj).to_isize() {
+            Some(value) => Ok(value),
+            None => Err(vm.new_overflow_error("Int value cannot fit into Rust isize".to_string())),
+        }
+    }
+}
+
 fn int_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(int, Some(vm.ctx.int_type()))]);
     let v = get_value(int);

vm/src/obj/objrange.rs

@@ -4,8 +4,7 @@ use std::ops::Mul;
 use super::objint;
 use super::objtype;
 use crate::pyobject::{
-    FromPyObject, PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef, PyResult,
-    TypeProtocol,
+    PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef, PyResult, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_bigint::{BigInt, Sign};
@@ -21,18 +20,6 @@ pub struct RangeType {
     pub step: BigInt,
 }
 
-type PyRange = RangeType;
-
-impl FromPyObject for PyRange {
-    fn typ(ctx: &PyContext) -> Option<PyObjectRef> {
-        Some(ctx.range_type())
-    }
-
-    fn from_pyobject(obj: PyObjectRef) -> PyResult<Self> {
-        Ok(get_value(&obj))
-    }
-}
-
 impl RangeType {
     #[inline]
     pub fn try_len(&self) -> Option<usize> {
@@ -360,12 +347,22 @@ fn range_bool(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_bool(len > 0))
 }
 
-fn range_contains(vm: &mut VirtualMachine, zelf: PyRange, needle: PyObjectRef) -> bool {
-    if objtype::isinstance(&needle, &vm.ctx.int_type()) {
-        zelf.contains(&objint::get_value(&needle))
+fn range_contains(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(zelf, Some(vm.ctx.range_type())), (needle, None)]
+    );
+
+    let range = get_value(zelf);
+
+    let result = if objtype::isinstance(needle, &vm.ctx.int_type()) {
+        range.contains(&objint::get_value(needle))
     } else {
         false
-    }
+    };
+
+    Ok(vm.ctx.new_bool(result))
 }
 
 fn range_index(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objstr.rs

@@ -3,7 +3,7 @@ use super::objsequence::PySliceableSequence;
 use super::objtype;
 use crate::format::{FormatParseError, FormatPart, FormatString};
 use crate::pyobject::{
-    FromPyObject, PyContext, PyFuncArgs, PyObjectPayload, PyObjectRef, PyResult, TypeProtocol,
+    PyContext, PyFuncArgs, PyObjectPayload, PyObjectRef, PyResult, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 use num_traits::ToPrimitive;
@@ -16,16 +16,6 @@ extern crate unicode_segmentation;
 
 use self::unicode_segmentation::UnicodeSegmentation;
 
-impl FromPyObject for String {
-    fn typ(ctx: &PyContext) -> Option<PyObjectRef> {
-        Some(ctx.str_type())
-    }
-
-    fn from_pyobject(obj: PyObjectRef) -> PyResult<Self> {
-        Ok(get_value(&obj))
-    }
-}
-
 pub fn init(context: &PyContext) {
     let str_type = &context.str_type;
     context.set_attr(&str_type, "__add__", context.new_rustfunc(str_add));
@@ -477,8 +467,15 @@ fn str_rstrip(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_str(value))
 }
 
-fn str_endswith(_vm: &mut VirtualMachine, zelf: String, suffix: String) -> bool {
-    zelf.ends_with(&suffix)
+fn str_endswith(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(s, Some(vm.ctx.str_type())), (pat, Some(vm.ctx.str_type()))]
+    );
+    let value = get_value(&s);
+    let pat = get_value(&pat);
+    Ok(vm.ctx.new_bool(value.ends_with(pat.as_str())))
 }
 
 fn str_isidentifier(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {