Add test script for bytearray

Author: windelbouwman

tests/snippets/basic_types.py

@@ -36,6 +36,9 @@
 except TypeError:
     pass
 
+a = bytearray([1, 2, 3])
+# assert a[1] == 2
+
 assert int() == 0
 
 a = complex(2, 4)

vm/src/obj/objbytearray.rs

@@ -65,6 +65,17 @@ fn bytearray_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_bool(result))
 }
 
+/*
+fn bytearray_getitem(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(obj, Some(vm.ctx.bytearray_type())), (needle, None)]
+    );
+    let elements = get_elements(obj);
+    get_item(vm, list, &, needle.clone())
+}
+*/
 /*
 fn set_value(obj: &PyObjectRef, value: Vec<u8>) {
     obj.borrow_mut().kind = PyObjectKind::Bytes { value };

vm/src/obj/objlist.rs

@@ -5,7 +5,6 @@ use super::super::pyobject::{
 use super::super::vm::VirtualMachine;
 use super::objbool;
 use super::objint;
-use super::objiter;
 use super::objsequence::{get_item, seq_equal, PySliceableSequence};
 use super::objstr;
 use super::objtype;

vm/src/pyobject.rs

@@ -45,7 +45,17 @@ The PyRef type implements
 https://doc.rust-lang.org/std/cell/index.html#introducing-mutability-inside-of-something-immutable
 */
 pub type PyRef<T> = Rc<RefCell<T>>;
+
+/// The `PyObjectRef` is one of the most used types. It is a reference to a
+/// python object. A single python object can have multiple references, and
+/// this reference counting is accounted for by this type. Use the `.clone()`
+/// method to create a new reference and increment the amount of references
+/// to the python object by 1.
 pub type PyObjectRef = PyRef<PyObject>;
+
+/// Use this type for function which return a python object or and exception.
+/// Both the python object and the python exception are `PyObjectRef` types
+/// since exceptions are also python objects.
 pub type PyResult = Result<PyObjectRef, PyObjectRef>; // A valid value, or an exception
 
 /*
@@ -407,6 +417,9 @@ impl PyContext {
     }
 }
 
+/// This is an actual python object. It consists of a `typ` which is the
+/// python class, and carries some rust payload optionally. This rust
+/// payload can be a rust float or rust int in case of float and int objects.
 pub struct PyObject {
     pub kind: PyObjectKind,
     pub typ: Option<PyObjectRef>,
@@ -594,6 +607,9 @@ impl fmt::Debug for PyObject {
     }
 }
 
+/// The `PyFuncArgs` struct is one of the most used structs then creating
+/// a rust function that can be called from python. It holds both positional
+/// arguments, as well as keyword arguments passed to the function.
 #[derive(Debug, Default, Clone)]
 pub struct PyFuncArgs {
     pub args: Vec<PyObjectRef>,
@@ -637,6 +653,10 @@ impl PyFuncArgs {
 
 type RustPyFunc = fn(vm: &mut VirtualMachine, PyFuncArgs) -> PyResult;
 
+/// Rather than determining the type of a python object, this enum is more
+/// a holder for the rust payload of a python object. It is more a carrier
+/// of rust data for a particular python object. Determine the python type
+/// by using for example the `.typ()` method on a python object.
 pub enum PyObjectKind {
     String {
         value: String,