Method build_fallible

src/timely-util/src/builder_async.rs:685–712

Creates a fallible operator implementation from supplied logic constructor. If the `Future` resolves to an error it will be emitted in the returned error stream and then the operator will wait indefinitely until the shutdown button is pressed. # Capability handling Unlike [`OperatorBuilder::build`], this method does not give owned capabilities to the constructor. All initial capabilities are wra

(
        mut self,
        constructor: F,
    )

    /// }));
    /// ```
    pub fn build_fallible<E: 'static, F>(
        mut self,
        constructor: F,
    ) -> (Button, StreamVec<'scope, T, Rc<E>>)
    where
        F: for<'a> FnOnce(
                &'a mut [CapabilitySet<T>],
            ) -> Pin<Box<dyn Future<Output = Result<(), E>> + 'a>>
            + 'static,
    {
        // Create a new completely disconnected output
        let (error_output, error_stream) = self.new_output::<CapacityContainerBuilder<_>>();
        let button = self.build(|mut caps| async move {
            let error_cap = caps.pop().unwrap();
            let mut caps = caps
                .into_iter()
                .map(CapabilitySet::from_elem)
                .collect::<Vec<_>>();
            if let Err(err) = constructor(&mut *caps).await {
                error_output.give(&error_cap, Rc::new(err));
                drop(error_cap);
                // IMPORTANT: wedge this operator until the button is pressed. Returning would drop
                // the capabilities and could produce incorrect progress statements.
                std::future::pending().await
            }
        });
        (button, error_stream)
    }

    /// Creates operator info for the operator.
    pub fn operator_info(&self) -> OperatorInfo {