hegel/generators/
deferred.rs

1use super::{BoxedGenerator, Generator};
2use crate::test_case::TestCase;
3use std::sync::{Arc, OnceLock};
4
5struct DeferredGenerator<T> {
6    inner: Arc<OnceLock<BoxedGenerator<'static, T>>>,
7}
8
9impl<T: Send + Sync> Generator<T> for DeferredGenerator<T> {
10    fn do_draw(&self, tc: &TestCase) -> T {
11        self.inner
12            .get()
13            .unwrap_or_else(|| panic!("DeferredGenerator has not been set"))
14            .do_draw(tc)
15    }
16}
17
18/// A deferred generator definition that can produce generator handles
19/// before its implementation is known.
20///
21/// Created by [`deferred()`]. Call [`generator()`](Self::generator) to get
22/// handles that can be passed to other generators, then call [`set()`](Self::set)
23/// to provide the actual implementation. `set` consumes the definition,
24/// ensuring it can only be called once.
25///
26/// # Panics
27///
28/// Drawing from a generator handle before [`set()`](Self::set) has been
29/// called will panic.
30///
31/// # Example
32///
33/// ```no_run
34/// use hegel::generators::{self as gs, Generator};
35///
36/// enum Tree {
37///     Leaf(i32),
38///     Branch(Box<Tree>, Box<Tree>),
39/// }
40///
41/// let tree = gs::deferred::<Tree>();
42/// let leaf = gs::integers::<i32>().map(Tree::Leaf);
43/// let branch = hegel::tuples!(tree.generator(), tree.generator())
44///     .map(|(l, r)| Tree::Branch(Box::new(l), Box::new(r)));
45/// tree.set(hegel::one_of!(leaf, branch));
46/// ```
47pub struct DeferredGeneratorDefinition<T> {
48    inner: Arc<OnceLock<BoxedGenerator<'static, T>>>,
49}
50
51impl<T: Send + Sync + 'static> DeferredGeneratorDefinition<T> {
52    /// Return a generator handle that will delegate to whatever is
53    /// eventually passed to [`set()`](Self::set).
54    ///
55    /// Can be called multiple times to produce independent handles
56    /// that all share the same underlying definition.
57    pub fn generator(&self) -> BoxedGenerator<'static, T> {
58        DeferredGenerator {
59            inner: Arc::clone(&self.inner),
60        }
61        .boxed()
62    }
63
64    /// Set the implementation for this deferred generator.
65    ///
66    /// All handles previously returned by [`generator()`](Self::generator)
67    /// will delegate to the provided generator. Consumes the definition,
68    /// so it can only be called once.
69    ///
70    /// # Panics
71    ///
72    /// Drawing from a handle before `set` is called will panic.
73    pub fn set(self, generator: impl Generator<T> + Send + Sync + 'static) {
74        let _ = self.inner.set(generator.boxed());
75    }
76}
77
78/// Create a deferred generator definition for forward references.
79///
80/// Returns a [`DeferredGeneratorDefinition`] that can produce generator
81/// handles before the implementation is known. This enables self-recursive
82/// and mutually recursive generator definitions.
83///
84/// # Example
85///
86/// ```no_run
87/// use hegel::generators::{self as gs, Generator};
88///
89/// enum Tree {
90///     Leaf(i32),
91///     Branch(Box<Tree>, Box<Tree>),
92/// }
93///
94/// let tree = gs::deferred::<Tree>();
95/// let leaf = gs::integers::<i32>().map(Tree::Leaf);
96/// let branch = hegel::tuples!(tree.generator(), tree.generator())
97///     .map(|(l, r)| Tree::Branch(Box::new(l), Box::new(r)));
98/// tree.set(hegel::one_of!(leaf, branch));
99/// ```
100pub fn deferred<T>() -> DeferredGeneratorDefinition<T> {
101    DeferredGeneratorDefinition {
102        inner: Arc::new(OnceLock::new()),
103    }
104}
hegel/generators/deferred.rs

hegel/generators/
deferred.rs
