rustpython-vm 0.1.0

Rust Python virtual machine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
use crate::vm::VirtualMachine; // Required for arg_check! to use isinstance

use super::objbool;
use super::objiter;
use crate::obj::objtype::PyClassRef;

pub type PyFilterRef = PyRef<PyFilter>;

/// filter(function or None, iterable) --> filter object
///
/// Return an iterator yielding those items of iterable for which function(item)
/// is true. If function is None, return the items that are true.
#[pyclass]
#[derive(Debug)]
pub struct PyFilter {
    predicate: PyObjectRef,
    iterator: PyObjectRef,
}

impl PyValue for PyFilter {
    fn class(vm: &VirtualMachine) -> PyClassRef {
        vm.ctx.filter_type()
    }
}

fn filter_new(
    cls: PyClassRef,
    function: PyObjectRef,
    iterable: PyObjectRef,
    vm: &VirtualMachine,
) -> PyResult<PyFilterRef> {
    let iterator = objiter::get_iter(vm, &iterable)?;

    PyFilter {
        predicate: function.clone(),
        iterator,
    }
    .into_ref_with_type(vm, cls)
}

#[pyimpl]
impl PyFilter {
    #[pymethod(name = "__next__")]
    fn next(&self, vm: &VirtualMachine) -> PyResult {
        let predicate = &self.predicate;
        let iterator = &self.iterator;
        loop {
            let next_obj = objiter::call_next(vm, iterator)?;
            let predicate_value = if predicate.is(&vm.get_none()) {
                next_obj.clone()
            } else {
                // the predicate itself can raise StopIteration which does stop the filter
                // iteration
                vm.invoke(predicate.clone(), vec![next_obj.clone()])?
            };
            if objbool::boolval(vm, predicate_value)? {
                return Ok(next_obj);
            }
        }
    }

    #[pymethod(name = "__iter__")]
    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
        zelf
    }
}

pub fn init(context: &PyContext) {
    PyFilter::extend_class(context, &context.filter_type);
    extend_class!(context, &context.filter_type, {
        "__new__" => context.new_rustfunc(filter_new),
    });
}