piccolo 0.3.3

Stackless Lua VM implemented in pure Rust
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use gc_arena::{Collect, Gc, Mutation};

use crate::{
    BoxSequence, Callback, CallbackReturn, Closure, Context, Error, Execution, IntoMultiValue,
    Sequence, SequencePoll, Stack,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Collect)]
#[collect(no_drop)]
pub enum Function<'gc> {
    Closure(Closure<'gc>),
    Callback(Callback<'gc>),
}

impl<'gc> From<Closure<'gc>> for Function<'gc> {
    fn from(closure: Closure<'gc>) -> Self {
        Self::Closure(closure)
    }
}

impl<'gc> From<Callback<'gc>> for Function<'gc> {
    fn from(callback: Callback<'gc>) -> Self {
        Self::Callback(callback)
    }
}

impl<'gc> Function<'gc> {
    pub fn compose<I>(mc: &Mutation<'gc>, functions: I) -> Self
    where
        I: AsRef<[Function<'gc>]> + Collect + 'gc,
    {
        #[derive(Collect)]
        #[collect(no_drop)]
        struct Compose<'gc, I: 'gc>(Gc<'gc, I>, usize);

        impl<'gc, I> Sequence<'gc> for Compose<'gc, I>
        where
            I: AsRef<[Function<'gc>]> + Collect,
        {
            fn poll(
                &mut self,
                _: Context<'gc>,
                _: Execution<'gc, '_>,
                _: Stack<'gc, '_>,
            ) -> Result<SequencePoll<'gc>, Error<'gc>> {
                let fns = (*self.0).as_ref();
                let function = fns[self.1];
                self.1 += 1;
                let is_tail = self.1 == fns.len();
                Ok(SequencePoll::Call { function, is_tail })
            }
        }

        Self::Callback(Callback::from_fn_with(
            mc,
            Gc::new(mc, functions),
            |functions, ctx, _, _| {
                if (**functions).as_ref().is_empty() {
                    Ok(CallbackReturn::Return)
                } else {
                    Ok(CallbackReturn::Sequence(BoxSequence::new(
                        &ctx,
                        Compose(*functions, 0),
                    )))
                }
            },
        ))
    }

    pub fn bind<A>(self, mc: &Mutation<'gc>, args: A) -> Self
    where
        A: IntoMultiValue<'gc> + Collect + Clone + 'gc,
    {
        Self::Callback(Callback::from_fn_with(
            mc,
            (self, args),
            |(f, args), ctx, exec, mut stack| {
                stack.into_front(ctx, args.clone());
                match *f {
                    Function::Closure(c) => Ok(CallbackReturn::Call {
                        function: c.into(),
                        then: None,
                    }),
                    Function::Callback(c) => c.call(ctx, exec, stack),
                }
            },
        ))
    }
}