);

        cu.ips

            .port_info

            .owned

            .entry(cu.native_component_id)

            .or_default()

            .extend([o, i].iter().copied());

        log!(cu.logger, "Added port pair (out->in) {:?} -> {:?}", o, i);

        [o, i]

    }

    /// Instantiates a new component for the connector runtime to manage, and passing

    /// the given set of ports from the interface of the native component, to that of the

    /// newly created component (passing their ownership).

    /// # Errors

    /// Error is returned if the moved ports are not owned by the native component,

    /// if the given component name is not defined in the connector's protocol,

    /// the given sequence of ports contains a duplicate port,

    /// or if the component is unfit for instantiation with the given port sequence.

    /// # Panics

    /// This function panics if the connector's (large) component id space is exhausted.

    pub fn add_component(

        &mut self,

        identifier: &[u8],

        ports: &[PortId],

    ) -> Result<(), AddComponentError> {

        // Check for error cases first before modifying `cu`

        use AddComponentError as Ace;

        let cu = &self.unphased;

        if let Some(port) = duplicate_port(ports) {

            return Err(Ace::DuplicatePort(port));

        }

        let expected_polarities = cu.proto_description.component_polarities(identifier)?;

        if expected_polarities.len() != ports.len() {

            return Err(Ace::WrongNumberOfParamaters { expected: expected_polarities.len() });

        }

        for (&expected_polarity, &port) in expected_polarities.iter().zip(ports.iter()) {

            let info = cu.ips.port_info.map.get(&port).ok_or(Ace::UnknownPort(port))?;

            if info.owner != cu.native_component_id {

                return Err(Ace::UnknownPort(port));

            }

            if info.polarity != expected_polarity {

                return Err(Ace::WrongPortPolarity { port, expected_polarity });

            }

        }

        // No errors! Time to modify `cu`

        // create a new component and identifier

        let new_cid = cu.ips.id_manager.new_component_id();

        cu.proto_components.insert(new_cid, cu.proto_description.new_component(identifier, ports));

        // update the ownership of moved ports

        for port in ports.iter() {

            match cu.ips.port_info.map.get_mut(port) {

                Some(port_info) => port_info.owner = new_cid,

                None => unreachable!(),

            }

        }

        if let Some(set) = cu.ips.port_info.owned.get_mut(&cu.native_component_id) {

            set.retain(|x| !ports.contains(x));

        }

        Ok(())

    }

}

impl Predicate {

    #[inline]

    pub fn singleton(k: SpecVar, v: SpecVal) -> Self {

        Self::default().inserted(k, v)

    }

    #[inline]

    pub fn inserted(mut self, k: SpecVar, v: SpecVal) -> Self {

        self.assigned.insert(k, v);

        self

    }

    // Return true whether `self` is a subset of `maybe_superset`

    pub fn assigns_subset(&self, maybe_superset: &Self) -> bool {

        for (var, val) in self.assigned.iter() {

            match maybe_superset.assigned.get(var) {

                Some(val2) if val2 == val => {}

                _ => return false, // var unmapped, or mapped differently

            }

        }

        // `maybe_superset` mirrored all my assignments!

        true

    }

    /// Given the two predicates {self, other}, return that whose

    /// assignments are the union of those of both.

    fn assignment_union(&self, other: &Self) -> AssignmentUnionResult {

        use AssignmentUnionResult as Aur;

        // iterators over assignments of both predicates. Rely on SORTED ordering of BTreeMap's keys.

        let [mut s_it, mut o_it] = [self.assigned.iter(), other.assigned.iter()];

        let [mut s, mut o] = [s_it.next(), o_it.next()];

        // populate lists of assignments in self but not other and vice versa.

        // do this by incrementally unfolding the iterators, keeping an eye

        // on the ordering between the head elements [s, o].

        // whenever s<o, other is certainly missing element 's', etc.

        let [mut s_not_o, mut o_not_s] = [vec![], vec![]];

        loop {

            match [s, o] {

                [None, None] => break, // both iterators are empty

                [None, Some(x)] => {

                    // self's iterator is empty.

                    // all remaning elements are in other but not self

                    o_not_s.push(x);

                    o_not_s.extend(o_it);

                    break;

                }