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

    pub(crate) fn num_embedded(&self) -> u32 {

                            let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_idx);

                                    let def_types = types.get_procedure_monomorph(cur_frame.monomorph_idx);

                            let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_idx);

                                    let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_idx);

                let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_idx);

        let ast_definition = &self.heap[definition_id];

        if !ast_definition.is_component() {

        let ast_definition = ast_definition.as_component();

        if !ast_definition.poly_vars.is_empty() {

        // - check number of arguments by retrieving the one instantiated

        //   monomorph

        let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(definition_id, 0)] };

        let mono_index = self.types.get_procedure_monomorph_index(&definition_id, &concrete_type.parts).unwrap();

        let mono_type = self.types.get_procedure_monomorph(mono_index);

        if mono_type.arg_types.len() != arguments.values.len() {

            let expected_type = &mono_type.arg_types[arg_idx];

            let monomorph = ctx.types.get_monomorph(element.reserved_monomorph_idx);

            for poly_arg in monomorph.concrete_type.embedded_iter(0) {

                    match ctx.types.get_procedure_monomorph_index(&definition_id, &concrete_type.parts) {

        let procedure_arguments = match &self.definition_type {

                &definition.parameters

                &definition.parameters

        let target = ctx.types.get_procedure_monomorph_mut(self.reserved_idx);

/// Generic monomorph has a specific concrete type, a size and an alignment.

/// Extra data is in the `MonomorphVariant` per kind of type.

pub(crate) struct TypeMonomorph {

    pub concrete_type: ConcreteType,

    pub size: usize,

    pub alignment: usize,

    pub variant: MonomorphVariant,

}

pub(crate) enum MonomorphVariant {

    Enum, // no extra data

impl MonomorphVariant {

    fn as_struct(&self) -> &StructMonomorph {

        match self {

            MonomorphVariant::Struct(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_struct_mut(&mut self) -> &mut StructMonomorph {

        match self {

            MonomorphVariant::Struct(v) => v,

            _ => unreachable!(),

        }

    }

    pub(crate) fn as_union(&self) -> &UnionMonomorph {

        match self {

            MonomorphVariant::Union(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_union_mut(&mut self) -> &mut UnionMonomorph {

        match self {

            MonomorphVariant::Union(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_tuple(&self) -> &TupleMonomorph {

        match self {

            MonomorphVariant::Tuple(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {

        match self {

            MonomorphVariant::Tuple(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_procedure(&self) -> &ProcedureMonomorph {

        match self {

            MonomorphVariant::Procedure(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {

        match self {

            MonomorphVariant::Procedure(v) => v,

            _ => unreachable!(),

        }

    }

    // note that the stack size is in the `TypeMonomorph` struct. This size and

    // alignment will include the size of the union tag.

    //

/// Key used to perform lookups in the monomorph table. It computes a hash of

/// the type while not taking the unused polymorphic variables of the base type

/// into account (e.g. `struct Foo<A,B>{ A field }`, here `B` is an unused

/// polymorphic variable).

struct MonomorphKey {

    parts: Vec<ConcreteTypePart>,

    in_use: Vec<bool>,

}

use std::hash::*;

impl Hash for MonomorphKey {

    fn hash<H: Hasher>(&self, state: &mut H) {

        // if `in_use` is empty, then we may assume the type is not polymorphic

        // (or all types are in use)

        if self.in_use.is_empty() {

            self.parts.hash(state);

        } else {

            // type is polymorphic

            self.parts[0].hash(state);

            // note: hash is computed in a unique way, because practically

            // speaking `in_use` is fixed per base type. So we cannot have the

            // same base type (hence: a type with the same DefinitionId) with

            // different different polymorphic variables in use.

            let mut in_use_index = 0;

            for section in ConcreteTypeIter::new(self.parts.as_slice(), 0) {

                if self.in_use[in_use_index] {

                    section.hash(state);

                }

                in_use_index += 1;

            }

        }

    }

}

impl PartialEq for MonomorphKey {

    fn eq(&self, other: &Self) -> bool {

        if self.in_use.is_empty() {

            return self.parts == other.parts;

        } else {

            // Outer type does not match

            if self.parts[0] != other.parts[0] {

                return false;

            }

            debug_assert_eq!(self.parts[0].num_embedded() as usize, self.in_use.len());

            let mut iter_self = ConcreteTypeIter::new(self.parts.as_slice(), 0);

            let mut iter_other = ConcreteTypeIter::new(other.parts.as_slice(), 0);

            let mut index = 0;

            while let Some(section_self) = iter_self.next() {

                let section_other = iter_other.next().unwrap();

                let in_use = self.in_use[index];

                index += 1;

                if !in_use {

                    continue;

                }

                if section_self != section_other {

                    return false;

                }

            }

            return true;

        }

    }

}

impl Eq for MonomorphKey {}

use std::cell::UnsafeCell;

/// Lookup table for monomorphs. Wrapped in a special struct because we don't

/// want to allocate for each lookup (what we really want is a HashMap that

/// exposes it CompareFn and HashFn, but whatevs).

pub(crate) struct MonomorphTable {

    lookup: HashMap<MonomorphKey, i32>, // indexes into `monomorphs`

    pub(crate) monomorphs: Vec<TypeMonomorph>,

    // We use an UnsafeCell because this is only used internally per call to

    // `get_monomorph_index` calls. This is safe because `&TypeMonomorph`s

    // retrieved for this class remain valid when the key is mutated and the

    // type table is not multithreaded.

    //

    // I added this because we don't want to allocate for each lookup, hence we

    // need a reusable `key` internal to this class. This in turn makes

    // `get_monomorph_index` a mutable call. Now the code that calls this

    // function (even though we're not mutating the table!) needs a lot of extra

    // boilerplate. I opted for the `UnsafeCell` instead of the boilerplate.

    key: UnsafeCell<MonomorphKey>,

}

impl MonomorphTable {

    fn new() -> Self {

        return Self {

            lookup: HashMap::with_capacity(256),

            monomorphs: Vec::with_capacity(256),

            key: UnsafeCell::new(MonomorphKey{

                parts: Vec::with_capacity(32),

                in_use: Vec::with_capacity(32),

            })

        }

    }

    fn insert_with_zero_size_and_alignment(&mut self, concrete_type: ConcreteType, in_use: &[PolymorphicVariable], variant: MonomorphVariant) -> i32 {

        let key = MonomorphKey{

            parts: Vec::from(concrete_type.parts.as_slice()),

            in_use: in_use.iter().map(|v| v.is_in_use).collect(),

        };

        let index = self.monomorphs.len();

        let _result = self.lookup.insert(key, index as i32);

        debug_assert!(_result.is_none()); // did not exist yet

        self.monomorphs.push(TypeMonomorph{

            concrete_type,

            size: 0,

            alignment: 0,

            variant,

        });

        return index as i32;

    }

    fn get_monomorph_index(&self, parts: &[ConcreteTypePart], in_use: &[PolymorphicVariable]) -> Option<i32> {

        // Note: the entire goal of this internal `MonomorphKey` is to prevent

        // allocation. So:

        let key = unsafe {

            let key = &mut *self.key.get();

            key.parts.clear();

            key.parts.extend_from_slice(parts);

            key.in_use.clear();

            key.in_use.extend(in_use.iter().map(|v| v.is_in_use));

            &*key

        };

        match self.lookup.get(key) {

            Some(index) => return Some(*index),

            None => return None,

        }

    }

    #[inline]

    fn get(&self, index: i32) -> &TypeMonomorph {

        debug_assert!(index >= 0);

        return &self.monomorphs[index as usize];

    }

    #[inline]

    fn get_mut(&mut self, index: i32) -> &mut TypeMonomorph {

        debug_assert!(index >= 0);

        return &mut self.monomorphs[index as usize];

    }

    fn get_monomorph_size_alignment(&self, index: i32) -> Option<(usize, usize)> {

        let monomorph = self.get(index);

        if monomorph.size == 0 && monomorph.alignment == 0 {

            // If both are zero, then we wish to mean: we haven't actually

            // computed the size and alignment yet. So:

            return None;

        } else {

            return Some((monomorph.size, monomorph.alignment));

        }

    }

}

    definition_id: DefinitionId, // TODO: Check if it can be removed?

    monomorph_idx: i32,

    next_member: u32,

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

    monomorph_idx: i32,

    monomorph_idx: i32,

    /// Lookup from AST DefinitionId to a defined type. Also lookups for

    /// concrete type to monomorphs

    pub(crate) type_lookup: HashMap<DefinitionId, DefinedType>,

    pub(crate) mono_lookup: MonomorphTable,

            type_lookup: HashMap::with_capacity(128),

            mono_lookup: MonomorphTable::new(),

        debug_assert!(self.type_lookup.is_empty());

        self.type_lookup.reserve(reserve_size);

        debug_assert_eq!(self.type_lookup.len(), reserve_size, "mismatch in reserved size of type table"); // NOTE: Temp fix for builtin functions

            let poly_type = self.type_lookup.get(&definition_id).unwrap();

            if !poly_type.definition.type_class().is_data_type() || !poly_type.poly_vars.is_empty() {

                continue;

            }

            // If here then the type is a data type without polymorphic

            // variables, but we might have instantiated it already, so:

            let concrete_parts = [ConcreteTypePart::Instance(definition_id, 0)];

            let mono_index = self.mono_lookup.get_monomorph_index(&concrete_parts, &[]);

            if mono_index.is_none() {

    #[inline]

        self.type_lookup.get(&definition_id)

    #[inline]

    pub(crate) fn get_procedure_monomorph_index(&self, definition_id: &DefinitionId, type_parts: &[ConcreteTypePart]) -> Option<i32> {

        let base_type = self.type_lookup.get(definition_id).unwrap();

        return self.mono_lookup.get_monomorph_index(type_parts, &base_type.poly_vars);

    }

    #[inline]

    pub(crate) fn get_monomorph(&self, monomorph_index: i32) -> &TypeMonomorph {

        return self.mono_lookup.get(monomorph_index);

    #[inline]

    pub(crate) fn get_procedure_monomorph_mut(&mut self, monomorph_index: i32) -> &mut ProcedureMonomorph {

        debug_assert!(monomorph_index >= 0);

        let monomorph = self.mono_lookup.get_mut(monomorph_index);

        return monomorph.variant.as_procedure_mut();

    #[inline]

    pub(crate) fn get_procedure_monomorph(&self, monomorph_index: i32) -> &ProcedureMonomorph {

        debug_assert!(monomorph_index >= 0);

        let monomorph = self.mono_lookup.get(monomorph_index);

        return monomorph.variant.as_procedure();

        let base_type = self.type_lookup.get_mut(definition_id).unwrap();

        let mono_index = self.mono_lookup.insert_with_zero_size_and_alignment(

            concrete_type, &base_type.poly_vars, MonomorphVariant::Procedure(ProcedureMonomorph{

                arg_types: Vec::new(),

                expr_data: Vec::new(),

            })

        );

        return mono_index;

        let poly_type = self.type_lookup.get_mut(&definition_id).unwrap();

        if let Some(idx) = self.mono_lookup.get_monomorph_index(&concrete_type.parts, &poly_type.poly_vars) {

            return Ok(idx);