Kind Constructors

The mechanism by which Inform records the characteristics of different kinds.

§1. Constructors are divided into four groups:

define PUNCTUATION_GRP 1  used in the construction of other kinds only
define PROTOCOL_GRP 2  such as arithmetic value
define BASE_CONSTRUCTOR_GRP 3  such as number
define PROPER_CONSTRUCTOR_GRP 4  with positive arity, such as "list of ..."

§2. Besides all the properties of kinds used in this module, Inform also needs to store further metadata in order to be able to make the extensive run-time code needed to support all these kinds in actual programs. All of this means that a kind_constructor object is a great big rag-bag of properties, some set by commands in Neptune files, others set by calls from Inform.

So, deep breath:

define MAX_KIND_CONSTRUCTION_ARITY 2

typedef struct kind_constructor {
    struct noun *dt_tag;  text of name
    int group;  one of the four values above

     A: how this came into being
    int is_incompletely_defined;  newly defined and ambiguous as yet
    struct parse_node *where_defined_in_source_text;  if so

     B: constructing kinds
    int constructor_arity;  0 for base, 1 for unary, 2 for binary
    int variance[MAX_KIND_CONSTRUCTION_ARITY];  must be COVARIANT or CONTRAVARIANT
    int tupling[MAX_KIND_CONSTRUCTION_ARITY];  extent to which tupling is permitted
    struct kind *cached_kind;  cached result of Kinds::base_construction

     C: compatibility with other kinds
    struct parse_node *superkind_set_at;  where it says, e.g., "A rabbit is a kind of animal"
    struct kind_constructor_casting_rule *first_casting_rule;  list of these
    struct kind_constructor_instance_rule *first_instance_rule;  list of these

     D: how constant values of this kind are expressed
    struct literal_pattern *ways_to_write_literals;  list of ways to write this
    struct table *named_values_created_with_table;  alternatively...
    int next_free_value;  to make distinguishable instances of this kind
    int constant_compilation_method;  one of the *_CCM values
    int forbid_assertion_creation;  an enumeration which cannot be explicitly created?

     E: knowledge about values of this kind
    struct inference_subject *base_as_infs;  inferences about properties
    struct text_stream *default_value;  used for built-in types only

     F: behaviour as a property as well
    int can_coincide_with_property;  allowed to coincide in name with a property
    struct property *coinciding_property;  property of the same name, if any

     G: performing arithmetic
    struct text_stream *comparison_routine;  for instance, when sorting table or list entries
    int dimensionless;
    struct dimensional_rules dim_rules;  how arithmetic operations work here
    struct unit_sequence dimensional_form;  dimensions of this kind
    int dimensional_form_fixed;  whether they are derived
    struct kind_constructor *relative_kind;

     H: representing this kind at run-time
    struct text_stream *explicit_identifier;  to become an Inter identifier
    int class_number;  for classes of object
    #ifdef CORE_MODULE
    struct kind_constructor_compilation_data compilation_data;
    #endif

     I: storing values at run-time
    int short_block_size;  if stored as a block value, size in words of the SB
    int long_block_size;  if stored as a block value, minimum number of LB fields
    int flexible_long_block_size;  if stored as a block value, typical number of LB fields
    int can_exchange;  with external files and therefore other story files
    struct text_stream *distinguish_function;  Inter routine to see if values distinguishable
    struct kind_constructor_comparison_schema *first_comparison_schema;  list of these
    struct text_stream *loop_domain_schema;  how to compile a loop over the instances
    struct linked_list *instances;  if enumerated explicitly in a Neptune file

     J: printing and parsing values at run-time
    struct text_stream *print_identifier;  an Inter identifier used for compiling printing rules
    struct text_stream *ACTIONS_identifier;  ditto but for ACTIONS testing command
    struct command_grammar *understand_as_values;  used when parsing such values
    struct text_stream *understand_function;  routine name, when not compiled automatically
    struct text_stream *recognise_function;  for recognising an explicit value as preposition

     K: pointer-value handling functions at run-time
    struct text_stream *create_function;
    struct text_stream *cast_function;
    struct text_stream *copy_function;
    struct text_stream *copy_short_block_function;
    struct text_stream *quick_copy_function;
    struct text_stream *destroy_function;
    struct text_stream *make_mutable_function;
    struct text_stream *hash_function;
    struct text_stream *long_block_size_function;
    struct text_stream *serialise_function;
    struct text_stream *unserialise_function;
    struct linked_list *arithmetic_schemas[NO_DEFINED_OPERATION_VALUES];  of arithmetic_schema
    int arithmetic_modulus;

     L: indexing and documentation
    struct text_stream *specification_text;  text for pseudo-property
    struct text_stream *index_default_value;  and its description in the Kinds index
    struct text_stream *index_maximum_value;  ditto
    struct text_stream *index_minimum_value;  ditto
    int index_priority;  from 1 (highest) to LOWEST_INDEX_PRIORITY (lowest)
    int linguistic;  divide off as having linguistics content
    int indexed_grey_if_empty;  shaded grey in the Kinds index
    struct text_stream *documentation_reference;  documentation symbol, if any

    CLASS_DEFINITION
} kind_constructor;

The structure kind_constructor is accessed in 2/tlok, 2/dk, 2/uk, 3/dmn, 4/mcr, 4/st, 4/kc and here.

§3. A few of the settings connect pairs of kinds together, so structures like the following are also needed.

typedef struct kind_constructor_casting_rule {
    struct text_stream *cast_from_kind_unparsed;  to the one which has the rule
    struct kind_constructor *cast_from_kind;  to the one which has the rule
    struct kind_constructor_casting_rule *next_casting_rule;
} kind_constructor_casting_rule;

The structure kind_constructor_casting_rule is accessed in 4/kc and here.

§4. And this is the analogous structure for recording conformance:

typedef struct kind_constructor_instance_rule {
    struct text_stream *instance_of_this_unparsed;
    struct kind_constructor *instance_of_this;
    struct kind_constructor_instance_rule *next_instance_rule;
} kind_constructor_instance_rule;

The structure kind_constructor_instance_rule is accessed in 4/kc and here.

§5. And this is the analogous structure for giving Inter schemas to compare data of two different kinds:

typedef struct kind_constructor_comparison_schema {
    struct text_stream *comparator_unparsed;
    struct kind_constructor *comparator;
    struct text_stream *comparison_schema;
    struct kind_constructor_comparison_schema *next_comparison_schema;
} kind_constructor_comparison_schema;

The structure kind_constructor_comparison_schema is accessed in 4/kc.

§6. And this is where explicit instances are recorded:

typedef struct kind_constructor_instance {
    struct text_stream *natural_language_name;
    struct text_stream *identifier;
    int value;
    int value_specified;
} kind_constructor_instance;

The structure kind_constructor_instance is accessed in 4/kc.

§7. The "tupling" of an argument is the extent to which an argument can be allowed to hold a variable-length list of kinds, rather than a single one. There aren't actually many possibilities.

define NO_TUPLING 0  a single kind
define ALLOW_NOTHING_TUPLING 1  a single kind, or "nothing"
define ARBITRARY_TUPLING 10000  a list of kinds of any length

§8. Constant compilation modes are:

define NONE_CCM 1  constant values of this kind cannot exist
define LITERAL_CCM 2  a numerical annotation decides the value
define NAMED_CONSTANT_CCM 3  an instance annotation decides the value
define SPECIAL_CCM 4  special code specific to the kind of value is needed

§9. We keep track of the newest-created base kind of value (which isn't a kind of object) here:

kind *latest_base_kind_of_value = NULL;

§10. Arithmetic schemas record:

typedef struct arithmetic_schema {
    struct text_stream *operands_unparsed[2];
    struct kind_constructor *operands[2];
    struct text_stream *schema;
    CLASS_DEFINITION
} arithmetic_schema;

The structure arithmetic_schema is accessed in 4/kc and here.

§11. Creation. Constructors come from two sources. Built-in ones like number or list of K come from commands in Neptune Files, while source-created ones ("Air pressure is a kind of value") result in calls here from Kinds::new_base — which, as the name suggests, can only make base kinds, not proper constructors.

Here super will be the super-constructor, the one which this will construct subkinds of. In practice this will be NULL when CON_VALUE is created, and then CON_VALUE for kinds like "number" or this one:

Weight is a kind of value.

but will be the constructor for "door" for kinds like this one:

Portal is a kind of door.

kind_constructor *KindConstructors::new(kind_constructor *super,
    text_stream *source_name, text_stream *initialisation_macro, int group) {
    kind_constructor *con = CREATE(kind_constructor);
    kind_constructor **pC = FamiliarKinds::known_con(source_name);
    if (pC) *pC = con;

    int copied = FALSE;
    if (super == Kinds::get_construct(K_value)) Fill in a new constructor11.1
    else { Copy the new constructor from its superconstructor11.2; copied = TRUE; }
    con->group = group;

    con->explicit_identifier = Str::duplicate(source_name);
    #ifdef CORE_MODULE
    con->compilation_data = RTKindConstructors::new_compilation_data(con);
    KindSubjects::new(con);
    #endif
    con->where_defined_in_source_text = current_sentence;

    kind **pK = FamiliarKinds::known_kind(source_name);
    if (pK) *pK = Kinds::base_construction(con);
    return con;
}

§11.1. If our new constructor is wholly new, and isn't a subkind of something else, we need to initialise the entire data structure; but note that, having done so, we apply any defaults set in Neptune files.

default LOWEST_INDEX_PRIORITY 100

Fill in a new constructor11.1 =

    con->dt_tag = NULL;
    con->group = 0;  which is invalid, so the interpreter needs to set it

     A: how this came into being
    con->is_incompletely_defined = FALSE;
    con->where_defined_in_source_text = NULL;  but will be filled in imminently

     B: constructing kinds
    con->constructor_arity = 0;  by default a base constructor
    for (int i=0; i<MAX_KIND_CONSTRUCTION_ARITY; i++) {
        con->variance[i] = COVARIANT;
        con->tupling[i] = NO_TUPLING;
    }
    con->cached_kind = NULL;

     C: compatibility with other kinds
    con->superkind_set_at = NULL;
    con->first_casting_rule = NULL;
    con->first_instance_rule = NULL;

     D: how constant values of this kind are expressed
    con->ways_to_write_literals = NULL;
    con->named_values_created_with_table = NULL;
    con->next_free_value = 1;
    con->constant_compilation_method = NONE_CCM;
    con->forbid_assertion_creation = FALSE;

     E: knowledge about values of this kind
    con->base_as_infs = NULL;  but will be filled in imminently, in almost all cases
    con->default_value = Str::new();

     F: behaviour as a property as well
    con->can_coincide_with_property = FALSE;
    con->coinciding_property = NULL;

     G: performing arithmetic
    con->dimensionless = TRUE;
    con->comparison_routine = Str::new();
    WRITE_TO(con->comparison_routine, "UnsignedCompare");
    if ((con == CON_KIND_VARIABLE) || (con == CON_INTERMEDIATE) ||
        ((Str::eq_wide_string(source_name, U"NUMBER_TY")) ||
            (Str::eq_wide_string(source_name, U"REAL_NUMBER_TY"))))
        con->dimensional_form =
            Kinds::Dimensions::fundamental_unit_sequence(NULL);
    else
        con->dimensional_form =
            Kinds::Dimensions::fundamental_unit_sequence(Kinds::base_construction(con));
    con->dimensional_form_fixed = FALSE;
    Kinds::Dimensions::dim_initialise(&(con->dim_rules));
    con->relative_kind = NULL;

     H: representing this kind at run-time
    con->explicit_identifier = Str::new();
    con->class_number = 0;

     I: storing values at run-time
    con->long_block_size = 0;
    con->flexible_long_block_size = 0;
    con->short_block_size = 1;
    con->can_exchange = FALSE;
    con->first_comparison_schema = NULL;
    con->distinguish_function = NULL;
    con->loop_domain_schema = NULL;
    con->instances = NEW_LINKED_LIST(kind_constructor_instance);

     J: printing and parsing values at run-time
    con->print_identifier = Str::new();
    con->ACTIONS_identifier = Str::new();

    con->understand_as_values = NULL;
    con->understand_function = NULL;
    con->recognise_function = NULL;

     K: pointer-value handling functions at run-time
    con->create_function = NULL;
    con->cast_function = NULL;
    con->copy_function = NULL;
    con->copy_short_block_function = NULL;
    con->quick_copy_function = NULL;
    con->destroy_function = NULL;
    con->make_mutable_function = NULL;
    con->hash_function = NULL;
    con->long_block_size_function = NULL;
    con->serialise_function = NULL;
    con->unserialise_function = NULL;
    for (int op=0; op<NO_DEFINED_OPERATION_VALUES; op++)
        con->arithmetic_schemas[op] = NEW_LINKED_LIST(arithmetic_schema);
    con->arithmetic_modulus = 0;

     L: indexing and documentation
    con->specification_text = NULL;
    con->index_default_value = I"--";
    con->index_maximum_value = I"--";
    con->index_minimum_value = I"--";
    con->index_priority = LOWEST_INDEX_PRIORITY;
    if ((group == PUNCTUATION_GRP) || (group == PROTOCOL_GRP))
        con->index_priority = 0;
    con->linguistic = FALSE;
    con->indexed_grey_if_empty = FALSE;
    con->documentation_reference = NULL;

    kind_macro_definition *set_defaults = NULL;
    switch (group) {
        case PUNCTUATION_GRP: set_defaults = NeptuneMacros::parse_name(I"#PUNCTUATION"); break;
        case PROTOCOL_GRP: set_defaults = NeptuneMacros::parse_name(I"#PROTOCOL"); break;
        case BASE_CONSTRUCTOR_GRP: set_defaults = NeptuneMacros::parse_name(I"#BASE"); break;
        case PROPER_CONSTRUCTOR_GRP: set_defaults = NeptuneMacros::parse_name(I"#CONSTRUCTOR"); break;
    }
    if (set_defaults) NeptuneMacros::play_back(set_defaults, con, NULL);

    if (Str::len(initialisation_macro) > 0)
        NeptuneMacros::play_back(NeptuneMacros::parse_name(initialisation_macro), con, NULL);

This code is used in §11.

§11.2. However, if we create our constructor as a subkind, like so:

A turtle is a kind of animal.

then we copy the entire "animal" constructor to initialise the "turtle" one.

Note that the weak ID number is one of the things copied; this is deliberate. It means that all kinds of object share the same weak ID as "object".

Copy the new constructor from its superconstructor11.2 =

    int I = con->allocation_id;
    void *N = con->next_structure;
    void *P = con->prev_structure;
    *con = *super;
    con->allocation_id = I;
    con->next_structure = N;
    con->prev_structure = P;
    con->cached_kind = NULL;  otherwise the superkind's cache is used by mistake
    con->explicit_identifier = Str::new();  otherwise this will be called OBJECT_TY by mistake

This code is used in §11.

§12. The noun. It's a requirement that the following be called soon after the creation of the constructor:

void KindConstructors::attach_noun(kind_constructor *con, noun *nt) {
    if ((con == NULL) || (nt == NULL)) internal_error("bad noun attachment");
    con->dt_tag = nt;
}

wording KindConstructors::get_name(kind_constructor *con, int plural_form) {
    if (con->dt_tag) {
        noun *nt = con->dt_tag;
        if (nt) return Nouns::nominative(nt, plural_form);
    }
    return EMPTY_WORDING;
}

wording KindConstructors::get_name_in_play(kind_constructor *con, int plural_form,
    NATURAL_LANGUAGE_WORDS_TYPE *nl) {
    if (con->dt_tag) {
        noun *nt = con->dt_tag;
        if (nt) return Nouns::nominative_in_language(nt, plural_form, nl);
    }
    return EMPTY_WORDING;
}

noun *KindConstructors::get_noun(kind_constructor *con) {
    if (con == NULL) return NULL;
    return con->dt_tag;
}

text_stream *KindConstructors::name_in_template_code(kind_constructor *con) {
    return con->explicit_identifier;
}

§13. We also need to parse this, occasionally (if we needed this more than a small and bounded number of times we'd want a faster method, but we don't):

kind_constructor *KindConstructors::parse(text_stream *sn) {
    if (sn == NULL) return NULL;
    kind_constructor *con;
    LOOP_OVER(con, kind_constructor)
        if (Str::eq(sn, con->explicit_identifier))
            return con;
    return NULL;
}

§14. Transformations. Conversions of an existing constructor to make it a unit or enumeration also require running macros in the kind interpreter:

int KindConstructors::convert_to_unit(kind_constructor *con) {
    if (con->is_incompletely_defined == TRUE) {
        NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#UNIT"), con, NULL);
        return TRUE;
    }
    if (KindConstructors::is_arithmetic(con)) return TRUE;  i.e., if it succeeded
    return FALSE;
}

int KindConstructors::convert_to_enumeration(kind_constructor *con) {
    if (con->is_incompletely_defined == TRUE) {
        NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#ENUMERATION"), con, NULL);
        if (con->linguistic)
            NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#LINGUISTIC"), con, NULL);
        return TRUE;
    }
    if (KindConstructors::is_an_enumeration(con)) return TRUE;  i.e., if it succeeded
    return FALSE;
}

§15. And similarly:

void KindConstructors::convert_to_real(kind_constructor *con) {
    NeptuneMacros::play_back(NeptuneMacros::parse_name(I"#REAL"), con, NULL);
}

§16. A few base kinds are marked as "linguistic", which simply enables us to fence them tidily off in the index.

void KindConstructors::mark_as_linguistic(kind_constructor *con) {
    con->linguistic = TRUE;
}

§17. For construction purposes.

kind **KindConstructors::cache_location(kind_constructor *con) {
    if (con) return &(con->cached_kind);
    return NULL;
}

int KindConstructors::arity(kind_constructor *con) {
    if (con == NULL) return 0;
    if (con->group == PROPER_CONSTRUCTOR_GRP) return con->constructor_arity;
    return 0;
}

int KindConstructors::tupling(kind_constructor *con, int b) {
    return con->tupling[b];
}

int KindConstructors::variance(kind_constructor *con, int b) {
    return con->variance[b];
}

int KindConstructors::is_base(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if (con->group == BASE_CONSTRUCTOR_GRP) return TRUE;
    return FALSE;
}

int KindConstructors::is_proper_constructor(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if (con->group == PROPER_CONSTRUCTOR_GRP) return TRUE;
    return FALSE;
}

§18. Questions about constructors. The rest of Inform is not encouraged to poke at constructors directly; it ought to ask questions about kinds instead (see "Using Kinds"). However:

int KindConstructors::is_definite(kind_constructor *con) {
    if ((con->group == BASE_CONSTRUCTOR_GRP) ||
        (con->group == PROPER_CONSTRUCTOR_GRP))
            return TRUE;
    if ((con == CON_VOID) || (con == CON_NIL) || (con == CON_INTERMEDIATE))
        return TRUE;
    return FALSE;
}

int KindConstructors::is_understandable(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if ((KindConstructors::is_definite(con)) &&
        (KindConstructors::compatible(con,
            Kinds::get_construct(K_understandable_value), FALSE))) return TRUE;
    return FALSE;
}

int KindConstructors::is_arithmetic(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if ((KindConstructors::is_definite(con)) &&
        (KindConstructors::compatible(con,
            Kinds::get_construct(K_arithmetic_value), FALSE))) return TRUE;
    return FALSE;
}

int KindConstructors::is_arithmetic_and_real(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if ((KindConstructors::is_definite(con)) &&
        (KindConstructors::compatible(con,
            Kinds::get_construct(K_real_arithmetic_value), FALSE))) return TRUE;
    return FALSE;
}

int KindConstructors::is_an_enumeration(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if ((KindConstructors::is_definite(con)) &&
        (KindConstructors::compatible(con,
            Kinds::get_construct(K_enumerated_value), FALSE))) return TRUE;
    return FALSE;
}

§19. All floating-point kinds use a common comparison function: the one for K_real_number.

int KindConstructors::uses_signed_comparisons(kind_constructor *kc) {
    if (kc == NULL) return FALSE;
    if (Str::eq_wide_string(kc->comparison_routine, U"signed")) return TRUE;
    return FALSE;
}

text_stream *KindConstructors::get_comparison_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    if ((KindConstructors::is_arithmetic_and_real(kc)) && (K_real_number))
        return K_real_number->construct->comparison_routine;
    if (Str::eq_wide_string(kc->comparison_routine, U"signed")) return NULL;
    return kc->comparison_routine;
}

§20. Cast and instance lists. Each constructor has a list of other constructors (all of the PROTOCOL_GRP group) which it's an instance of: value, word value, arithmetic value, and so on.

int KindConstructors::find_cast(kind_constructor *from, kind_constructor *to) {
    if (to) {
        kind_constructor_casting_rule *dtcr;
        for (dtcr = to->first_casting_rule; dtcr; dtcr = dtcr->next_casting_rule) {
            if (Str::len(dtcr->cast_from_kind_unparsed) > 0) {
                dtcr->cast_from_kind =
                    KindConstructors::parse(dtcr->cast_from_kind_unparsed);
                Str::clear(dtcr->cast_from_kind_unparsed);
            }
            if (from == dtcr->cast_from_kind)
                return TRUE;
        }
    }
    return FALSE;
}

§21. Each constructor has a list of other constructors (all of the BASE_CONSTRUCTOR_GRP group or PROPER_CONSTRUCTOR_GRP) which it can cast to.

int KindConstructors::find_instance(kind_constructor *from, kind_constructor *to) {
    kind_constructor_instance_rule *dti;
    for (dti = from->first_instance_rule; dti; dti = dti->next_instance_rule) {
        if (Str::len(dti->instance_of_this_unparsed) > 0) {
            dti->instance_of_this =
                KindConstructors::parse(dti->instance_of_this_unparsed);
            Str::clear(dti->instance_of_this_unparsed);
        }
        if (dti->instance_of_this == to) return TRUE;
        if (KindConstructors::find_instance(dti->instance_of_this, to)) return TRUE;
    }
    return FALSE;
}

§22. Each constructor has a list of explicitly-named instances from the Neptune file creating it (if any were: by default this will be empty):

linked_list *KindConstructors::instances(kind_constructor *kc) {
    if (kc == NULL) return FALSE;
    return kc->instances;
}

§23. Tedious access functions.

text_stream *KindConstructors::get_create_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->create_function;
}

text_stream *KindConstructors::get_cast_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->cast_function;
}

text_stream *KindConstructors::get_copy_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->copy_function;
}

text_stream *KindConstructors::get_copy_short_block_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->copy_short_block_function;
}

text_stream *KindConstructors::get_quick_copy_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->quick_copy_function;
}

text_stream *KindConstructors::get_destroy_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->destroy_function;
}

text_stream *KindConstructors::get_make_mutable_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->make_mutable_function;
}

text_stream *KindConstructors::get_hash_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->hash_function;
}

text_stream *KindConstructors::get_long_block_size_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->long_block_size_function;
}

text_stream *KindConstructors::get_serialise_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->serialise_function;
}

text_stream *KindConstructors::get_unserialise_fn_identifier(kind_constructor *kc) {
    if (kc == NULL) return NULL;
    return kc->unserialise_function;
}

text_stream *KindConstructors::get_arithmetic_schema(int op,
    kind_constructor *kc1, kind_constructor *kc2) {
    if ((op < 0) || (op >= NO_DEFINED_OPERATION_VALUES)) return NULL;
    text_stream *candidate;
    candidate = KindConstructors::get_arithmetic_schema_from(kc1, op, kc1, kc2);
    if (Str::len(candidate) > 0) return candidate;
    candidate = KindConstructors::get_arithmetic_schema_from(kc2, op, kc1, kc2);
    if (Str::len(candidate) > 0) return candidate;
    return NULL;
}

text_stream *KindConstructors::get_arithmetic_schema_from(kind_constructor *from,
    int op, kind_constructor *kc1, kind_constructor *kc2) {
    if (from == NULL) return NULL;
    arithmetic_schema *ars;
    LOOP_OVER_LINKED_LIST(ars, arithmetic_schema, from->arithmetic_schemas[op]) {
        for (int i=0; i<2; i++) {
            if (Str::len(ars->operands_unparsed[i]) > 0) {
                ars->operands[i] = KindConstructors::parse(ars->operands_unparsed[i]);
                Str::clear(ars->operands_unparsed[i]);
            }
        }
        if (((kc1 == ars->operands[0]) || ((kc1 == from) && (ars->operands[0] == NULL))) &&
            ((kc2 == ars->operands[1]) || ((kc2 == from) && (ars->operands[1] == NULL))))
            return ars->schema;
    }
    return NULL;
}

int KindConstructors::get_arithmetic_modulus(kind_constructor *kc) {
    if (kc == NULL) return 0;
    return kc->arithmetic_modulus;
}

int KindConstructors::is_dimensionless(kind_constructor *kc) {
    if (kc == NULL) return TRUE;
    return kc->dimensionless;
}

§24. Compatibility. The following tests if from is compatible with to.

int KindConstructors::compatible(kind_constructor *from, kind_constructor *to,
    int allow_casts) {
    if (to == from) return TRUE;
    if ((to == NULL) || (from == NULL)) return FALSE;
    if ((allow_casts) && (KindConstructors::find_cast(from, to))) return TRUE;
    if (KindConstructors::find_instance(from, to)) return TRUE;
    return FALSE;
}

§25. And more elaborately:

int KindConstructors::uses_block_values(kind_constructor *con) {
    if (con == NULL) return FALSE;
    if ((KindConstructors::is_definite(con)) &&
        (KindConstructors::compatible(con, Kinds::get_construct(K_pointer_value), FALSE)))
            return TRUE;
    return FALSE;
}

int KindConstructors::allow_word_as_pointer(kind_constructor *left,
    kind_constructor *right) {
    if (KindConstructors::uses_block_values(left) == FALSE) return FALSE;
    if (KindConstructors::uses_block_values(right) == TRUE) return FALSE;
    if (KindConstructors::compatible(right, left, TRUE)) return TRUE;
    return FALSE;
}