next-gen 0.1.1

Safe generators on stable Rust.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use super::*;

/// Sugar for `Box::pin(GeneratorFn::empty()).tap_mut(|it| it.as_mut().init(…))`.
///
/// In other words,
///
/// ```rust
/// # #[cfg(any())] macro_rules! __ {
/// let gen = generator_fn.call_boxed((args, ...));
/// # }
/// ```
///
/// is the same as:
///
/// ```rust
/// # #[cfg(any())] macro_rules! __ {
/// mk_gen!(let gen = box generator_fn(args, ...));
/// # }
/// ```
///
/// ## Examples
///
/// ```rust
/// use ::next_gen::prelude::*;
/// # struct Param();
/// # struct ResumeArg();
/// # struct YieldedThing();
/// # struct ReturnValue;
/// # use ::core::mem::drop as stuff;
///
/// #[generator(yield(YieldedThing), resume(ResumeArg))]
/// fn generator_fn (param: Param)
///   -> ReturnValue
/// {
///     stuff(param);
///     let _: ResumeArg = yield_!(YieldedThing());
///     ReturnValue
/// }
///
/// let mut gen = generator_fn.call_boxed((Param(), ));
/// let _ = gen.as_mut().resume(ResumeArg());
/// ```
///
/// is thus equivalent to:
///
/// ```rust
/// use ::next_gen::prelude::*;
/// # struct Param();
/// # struct ResumeArg();
/// # struct YieldedThing();
/// # struct ReturnValue;
/// # use ::core::mem::drop as stuff;
///
/// #[generator(yield(YieldedThing), resume(ResumeArg))]
/// fn generator_fn (param: Param)
///   -> ReturnValue
/// {
///     stuff(param);
///     let _: ResumeArg = yield_!(YieldedThing());
///     ReturnValue
/// }
///
/// mk_gen!(let mut gen = box generator_fn(Param()));
/// let _ = gen.as_mut().resume(ResumeArg());
/// ```
#[cfg(feature = "alloc")]
pub trait CallBoxed<'yield_slot, YieldedItem, ResumeArg, Args> {
    ///
    type CallBoxed;

    ///
    fn call_boxed (
        self: Self,
        args: Args,
    ) -> Self::CallBoxed;
}


#[cfg(feature = "alloc")]
impl<'yield_slot, Args, Factory, F, YieldedItem, ResumeArg>
    CallBoxed<'yield_slot, YieldedItem, ResumeArg, Args>
for
    Factory
where
    YieldedItem : 'yield_slot,
    ResumeArg : 'yield_slot,
    Factory : FnOnce(YieldSlot<'yield_slot, YieldedItem, ResumeArg>, Args) -> F,
    F : Future,
{
    type CallBoxed = Pin<::alloc::boxed::Box<
        GeneratorFn<YieldedItem, F, ResumeArg>
    >>;

    fn call_boxed (
        self: Factory,
        args: Args,
    ) -> Pin<::alloc::boxed::Box<
            GeneratorFn<YieldedItem, F, ResumeArg>
        >>
    {
        let mut gen = ::alloc::boxed::Box::pin(GeneratorFn::empty());
        gen.as_mut().init(self, args);
        gen
    }
}