// Builtin types with one nested type

    Array,

    Slice,

    Input,

    Output,

    // User defined type with any number of nested types

}

impl ConcreteTypePart {

    fn num_embedded(&self) -> u32 {

        use ConcreteTypePart::*;

            UInt8 | UInt16 | UInt32 | UInt64 |

            SInt8 | SInt16 | SInt32 | SInt64 |

            Character | String =>

                0,

            Array | Slice | Input | Output =>

                1,

        }

    }

}

#[derive(Debug, Clone, Eq, PartialEq)]

pub struct ConcreteType {

                CTP::Output => {

                    target.push_str(KW_TYPE_OUT_PORT_STR);

                    target.push('<');

                    idx = display_part(parts, heap, idx, target);

                    target.push('>');

                },

                    let definition = &heap[definition_id];

                    target.push_str(definition.identifier().value.as_str());

                    if num_poly_args != 0 {

                        target.push('<');

                        for poly_arg_idx in 0..num_poly_args {

                    },

                    &mut types_section, "an embedded type", Some(&mut close_pos)

                )?;

                let value = if has_embedded {

                    types_section.into_vec()

                } else {

                };

                Ok(UnionVariantDefinition{

                    span: InputSpan::from_positions(identifier.span.begin, close_pos),

                    identifier,

                    value

            let next_expr_idx = self.expr_queued.pop_front().unwrap();

            self.progress_expr(ctx, next_expr_idx)?;

        }

        // Helper for transferring polymorphic variables to concrete types and

        // checking if they're completely specified

            for (poly_idx, poly_type) in inference.iter().enumerate() {

                if !poly_type.is_done {

                    let expr = &ctx.heap[expr_id];

                    let definition = match expr {

                        Expression::Call(expr) => expr.definition,

                        Expression::Literal(expr) => match &expr.value {

                        )

                    ));

                }

                let mut concrete_type = ConcreteType::default();

                poly_type.write_concrete_type(&mut concrete_type);

            }

        }

        // Inference is now done. But we may still have uninferred types. So we

        // check for these.

        for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {

            let expr_type = &mut infer_expr.expr_type;

            // Note that only call and literal expressions need full inference.

            // Select expressions also use `extra_data`, but only for temporary

            // storage of the struct type whose field it is selecting.

            match &ctx.heap[extra_data.expr_id] {

                Expression::Call(expr) => {

                        // Builtin function

                        continue;

                    let definition_id = expr.definition;

                    match ctx.types.get_procedure_monomorph_index(&definition_id, &poly_types) {

                        Some(reserved_idx) => {

                            // Already typechecked, or already put into the resolve queue

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                        },

                    let definition_id = match &expr.value {

                        Literal::Enum(lit) => lit.definition,

                        Literal::Union(lit) => lit.definition,

                        Literal::Struct(lit) => lit.definition,

                        _ => unreachable!(),

                    };

                    infer_expr.field_or_monomorph_idx = mono_index;

                },

                Expression::Select(_) => {

                    debug_assert!(infer_expr.field_or_monomorph_idx >= 0);

                },

                _ => {

                },

                CTP::Array => parser_type.push(ITP::Array),

                CTP::Slice => parser_type.push(ITP::Slice),

                CTP::Input => parser_type.push(ITP::Input),

                CTP::Output => parser_type.push(ITP::Output),

                CTP::Instance(id, num) => parser_type.push(ITP::Instance(*id, *num)),

            }

        }

    }

    /// Construct an error when an expression's type does not match. This

    /// happens if we infer the expression type from its arguments (e.g. the

    definition_id: DefinitionId,

    monomorph_idx: usize,

    next_member: usize,

    next_embedded: usize, // for unions, the index into the variant's embedded types

}

enum BreadcrumbResult {

    TypeExists,

    PushedBreadcrumb,

    TypeLoop(usize), // index into vec of breadcrumbs at which the type matched

}

        }

    }

    /// Adds a datatype polymorph to the type table. Will not add the

    /// monomorph if it is already present, or if the type's polymorphic

    /// variables are all unused.

        }

    }

    //--------------------------------------------------------------------------

    // Building base types

    //--------------------------------------------------------------------------

                    // We're in a type loop. Add the type loop

                    let mut loop_members = Vec::with_capacity(self.breadcrumbs.len() - first_idx);

                    for breadcrumb_idx in first_idx..self.breadcrumbs.len() {

                        let breadcrumb = &mut self.breadcrumbs[breadcrumb_idx];

                        let mut is_union = false;

                            DTV::Union(definition) => {

                                // Mark the currently processed variant as requiring heap

                                // allocation, then advance the *embedded* type. The loop above

                                // will then take care of advancing it to the next *member*.

                                let monomorph = &mut definition.monomorphs[breadcrumb.monomorph_idx];

                                let variant = &mut monomorph.variants[breadcrumb.next_member];

                    alignment: 0

                });

                mono_idx

            },

            DTV::Function(_) | DTV::Component(_) => {

            },

        };

        self.breadcrumbs.push(TypeLoopBreadcrumb{

            definition_id,

            monomorph_idx,

                parts.push(part);

                continue;

            }

            // Not builtin, but if all code is working correctly, we only care

            // about the polymorphic argument at this point.

                let mut container_iter = container_type.embedded_iter(0);

                    container_iter.next();

                }

                let poly_section = container_iter.next().unwrap();

                parts.extend(poly_section);