// TODO: @marker?

        if self.parts.len() != 1 { return false; }

        match self.parts[0] {

            ITP::Unknown | ITP::Bool => true,

            _ => false

        }

    }

    fn marker_iter(&self) -> InferenceTypeMarkerIter {

        InferenceTypeMarkerIter::new(&self.parts)

    }

    /// Given that the `parts` are a depth-first serialized tree of types, this

    /// function finds the subtree anchored at a specific node. The returned 

    /// index is exclusive.

    fn find_subtree_end_idx(parts: &[InferenceTypePart], start_idx: usize) -> usize {

        let mut depth = 1;

        let mut idx = start_idx;

        while idx < parts.len() {

            depth += parts[idx].depth_change();

            if depth == 0 {

                return idx + 1;

            }

    fn partial_display_name(heap: &Heap, parts: &[InferenceTypePart]) -> String {

        let mut buffer = String::with_capacity(parts.len() * 6);

        Self::write_display_name(&mut buffer, heap, parts, 0);

        buffer

    }

    fn display_name(&self, heap: &Heap) -> String {

        Self::partial_display_name(heap, &self.parts)

    }

}

/// Iterator over the subtrees that follow a marker in an `InferenceType`

struct InferenceTypeMarkerIter<'a> {

    parts: &'a [InferenceTypePart],

    idx: usize,

}

impl<'a> InferenceTypeMarkerIter<'a> {

    fn new(parts: &'a [InferenceTypePart]) -> Self {

        Self{ parts, idx: 0 }

    }

}

impl<'a> Iterator for InferenceTypeMarkerIter<'a> {

            let argument_type: *mut _ = self.expr_types.get_mut(&arg_id).unwrap();

            let (progress_sig, progress_arg) = Self::apply_equal2_constraint_types(

                ctx, upcast_id, signature_type, 0, argument_type, 0

            )?;

            if progress_sig {

                // Progressed signature, so also apply inference to the 

                // polymorph types using the markers 

                debug_assert!(signature_type.has_marker, "progress on signature argument type without markers");

                for (poly_idx, poly_section) in signature_type.marker_iter() {

                    let polymorph_type = &mut extra.poly_vars[poly_idx];

                    match Self::apply_forced_constraint_types(

                    ) {

                        Ok(true) => { poly_progress.insert(poly_idx); },

                        Ok(false) => {},

                        Err(()) => { poly_infer_error = true; }

                    }

                }

            }

            if progress_arg {

                // Progressed argument expression

                self.queue_expr(arg_id);

            }

        }

        let signature_type = &mut extra.returned;

        let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

        let (progress_sig, progress_expr) = Self::apply_equal2_constraint_types(

            ctx, upcast_id, signature_type, 0, expr_type, 0

        )?;

        if progress_sig {

            // As above: apply inference to polyargs as well

            debug_assert!(signature_type.has_marker, "progress on signature return type without markers");

            for (poly_idx, poly_section) in signature_type.marker_iter() {

                let polymorph_type = &mut extra.poly_vars[poly_idx];

                match Self::apply_forced_constraint_types(

                ) {

                    Ok(true) => { poly_progress.insert(poly_idx); },

                    Ok(false) => {},

                    Err(()) => { poly_infer_error = true; }

                }

            }

        }

        if progress_expr {

            self.queue_expr_parent(ctx, upcast_id);

        }

        // If we had an error in the polymorphic variable's inference, then we

        // need to provide a human readable error: find a pair of inference

        // types in the arguments/return type that do not agree on the

        // polymorphic variable's type

        if poly_infer_error { return Err(self.construct_poly_arg_error(ctx, id)) }

        // If we did not have an error in the polymorph inference above, then

        // reapplying the polymorph type to each argument type and the return

        // type should always succeed.

        // TODO: @performance If the algorithm is changed to be more "on demand

        //  argument re-evaluation", instead of "all-argument re-evaluation",

        for poly_idx in poly_progress.into_iter() {

        }

        Ok(())

    }

    fn queue_expr_parent(&mut self, ctx: &Ctx, expr_id: ExpressionId) {

        if let ExpressionParent::Expression(parent_expr_id, _) = &ctx.heap[expr_id].parent() {

            self.expr_queued.insert(*parent_expr_id);

        }

    }

    fn queue_expr(&mut self, expr_id: ExpressionId) {

        debug_assert_expr_ids_unique_and_known!(self, expr_id);

        let expr_type = self.expr_types.get_mut(&expr_id).unwrap();

        match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0) {

            SingleInferenceResult::Modified => Ok(true),

            SingleInferenceResult::Unmodified => Ok(false),

            SingleInferenceResult::Incompatible => Err(

                self.construct_template_type_error(ctx, expr_id, template)

            )

        }

    }

    fn apply_forced_constraint_types(

        to_infer: *mut InferenceType, to_infer_start_idx: usize,

        template: &[InferenceTypePart], template_start_idx: usize

    ) -> Result<bool, ()> {

        match InferenceType::infer_subtree_for_single_type(

            unsafe{ &mut *to_infer }, to_infer_start_idx,

            template, template_start_idx

        ) {

            SingleInferenceResult::Modified => Ok(true),

            SingleInferenceResult::Unmodified => Ok(false),

            SingleInferenceResult::Incompatible => Err(()),

        }

    }

                    if !InferenceType::check_subtrees(section_a, 0, section_b, 0) {

                        // Not compatible

                        return Some((marker_a, section_a, section_b))

                    }

                }

            }

            None

        }

        // Helpers function to retrieve polyvar name and function name

        fn get_poly_var_and_func_name(ctx: &Ctx, poly_var_idx: usize, expr: &CallExpression) -> (String, String) {

            match &expr.method {

                Method::Create => unreachable!(),

                Method::Fires => (String::from('T'), String::from("fires")),

                Method::Get => (String::from('T'), String::from("get")),

                Method::Symbolic(symbolic) => {

                    let definition = &ctx.heap[symbolic.definition.unwrap()];

                    let poly_var = match definition {

                        Definition::Struct(_) | Definition::Enum(_) => unreachable!(),

                        Definition::Function(definition) => {

                            String::from_utf8_lossy(&definition.poly_vars[poly_var_idx].value).to_string()

                        },

                        Definition::Component(definition) => {

        // Actual checking

        let extra = self.extra_data.get(&call_id.upcast()).unwrap();

        let expr = &ctx.heap[call_id];

        // - check return type with itself

        if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&extra.returned, &extra.returned) {

            return construct_main_error(ctx, poly_idx, expr)

                .with_postfixed_info(

                    &ctx.module.source, expr.position(),

                    &format!(

                        "The return type inferred the conflicting types '{}' and '{}'",

                    )

                )

        }

        // - check arguments with each other argument and with return type

        for (arg_a_idx, arg_a) in extra.embedded.iter().enumerate() {

            for (arg_b_idx, arg_b) in extra.embedded.iter().enumerate() {

                if arg_b_idx > arg_a_idx {

                    break;

                }

                if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {

                    let error = construct_main_error(ctx, poly_idx, expr);

                    if arg_a_idx == arg_b_idx {

                        // Same argument

                        let arg = &ctx.heap[expr.arguments[arg_a_idx]];

                        return error.with_postfixed_info(

                            &ctx.module.source, arg.position(),

                            &format!(

                                "This argument inferred the conflicting types '{}' and '{}'",

                            )

                        )

                    } else {

                        let arg_a = &ctx.heap[expr.arguments[arg_a_idx]];

                        let arg_b = &ctx.heap[expr.arguments[arg_b_idx]];

                        return error.with_postfixed_info(

                            &ctx.module.source, arg_a.position(),

                            &format!(

                                "This argument inferred it to '{}'",

                            )

                        ).with_postfixed_info(

                            &ctx.module.source, arg_b.position(),

                            &format!(

                                "While this argument inferred it to '{}'",

                            )

                        )

                    }

                }

            }

            // Check with return type

            if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &extra.returned) {

                let arg = &ctx.heap[expr.arguments[arg_a_idx]];

                return construct_main_error(ctx, poly_idx, expr)

                    .with_postfixed_info(

                        &ctx.module.source, arg.position(),

                        &format!(

                            "This argument inferred it to '{}'",

                        )

                    )

                    .with_postfixed_info(

                        &ctx.module.source, expr.position,

                        &format!(

                            "While the return type inferred it to '{}'",

                        )

                    )

            }

        }

        unreachable!("construct_poly_arg_error without actual error found?")

    }

}