Method implement_single_binding

src/plan/hector.rs:343–402

(
        &self,
        nested: &mut Iterative<'b, S, u64>,
        _local_arrangements: &VariableMap<Iterative<'b, S, u64>>,
        context: &mut I,
    )

    // @TODO make these static and take variables as well?

    fn implement_single_binding<'b, T, I, S>(
        &self,
        nested: &mut Iterative<'b, S, u64>,
        _local_arrangements: &VariableMap<Iterative<'b, S, u64>>,
        context: &mut I,
    ) -> (Implemented<'b, S>, ShutdownHandle)
    where
        T: Timestamp + Lattice,
        I: ImplContext<T>,
        S: Scope<Timestamp = T>,
    {
        // With only a single binding given, we don't want to do
        // anything fancy (provided the binding is sourceable).

        match self.bindings.first().unwrap() {
            Binding::Attribute(binding) => {
                match context.forward_propose(&binding.source_attribute) {
                    None => panic!("Unknown attribute {}", &binding.source_attribute),
                    Some(forward_trace) => {
                        let frontier: Vec<T> = forward_trace.advance_frontier().to_vec();
                        let (forward, shutdown_forward) = forward_trace.import_core(
                            &nested.parent,
                            &format!("Propose({})", &binding.source_attribute),
                        );

                        let prefix = binding.variables();
                        let target_variables = self.variables.clone();
                        let tuples = forward
                            .enter_at(nested, move |_, _, time| {
                                let mut forwarded = time.clone();
                                forwarded.advance_by(&frontier);
                                Product::new(forwarded, 0)
                            })
                            .as_collection(move |e, v| {
                                let tuple = (e, v);
                                target_variables
                                    .iter()
                                    .flat_map(|x| {
                                        Some(tuple.index(AsBinding::binds(&prefix, *x).unwrap()))
                                    })
                                    .collect()
                            });

                        let relation = CollectionRelation {
                            variables: self.variables.clone(),
                            tuples,
                        };

                        (
                            Implemented::Collection(relation),
                            ShutdownHandle::from_button(shutdown_forward),
                        )
                    }
                }
            }
            _ => {
                panic!("Passed a single, non-sourceable binding.");
            }