Formal Languages, Types & Programs

← Back to Domain-Specific Families

Abstractions about formal representations shared by mathematics, programming, and knowledge organization. They include syntax trees, functions, functors, type systems, specifications, relational models, closure and replacement operations, identifiers, and transformations between structured representations.

41 abstractions in this family — domain-specific abstractions that sit near one another in structural-signature space (k-means over structural-signature embeddings). Each is shown with its short description.

• Abstract Syntax Tree — Represent a program's grammatical structure as a recursive tree built from a parser, keeping the meaning-bearing constructs and discarding surface details — whitespace, comments, redundant brackets — so two sources that differ only in formatting yield the identical tree.
• Anonymous Function — Construct a callable value at an expression site without declaring a persistent function name as part of that construction, so behavior can be invoked, passed, returned, stored, or composed inline.
• Callback Hell — The readability collapse that results when a sequential chain of asynchronous steps is written as nested continuation callbacks, so indentation depth grows with step count and the code's textual shape inverts the computation's temporal order.
• Chiasmus — State two elements in one order and then restate them with their roles swapped (A-B, then B-A) across a pivot, so the crossed inversion silently asserts that the relation runs both ways.
• Closure (programming) — The runtime value that packages a function's executable code with the bindings of its free variables captured at construction, so that when applied later its free variables resolve through that captured environment rather than the caller's — preserving lexical scope across the gap between where a function is made and where it runs.
• Compiler — Translate a fully specified source language ahead of time into a semantically equivalent target form through a pipeline of formal-interface phases, so the whole program can be globally analysed and optimised once while its observable behaviour is guaranteed preserved.
• Cross-reference Relation — Connect two controlled-vocabulary entries with a typed directed half-edge drawn from a small closed inventory (USE, UF, BT, NT, RT, SA), each carrying a stipulated direction, symmetry, inverse-pairing obligation, and system action — turning a flat term list into a maintainable navigable graph.
• Data Class — Flag an object-oriented class that holds fields with getters and setters but no domain methods as a symptom that its behavior migrated outward into consumers, then resolve the verdict with one role question — should this class enforce its own invariants?
• Descent (Mathematics) — Recover a global mathematical object from compatible local objects by comparing pullbacks on fiber-product overlaps, enforcing a cocycle, and proving the resulting datum effective.
• Enumeration Algorithm — Given an input and a declared solution relation, generate every associated solution without repetition, with performance evaluated by preprocessing, inter-output delay, incremental time, total output-sensitive time, and space.
• Formal Theory — A set of sentences in a formal language, commonly closed under a specified consequence relation, that serves as the asserted or derivable content interpreted within models.
• Function-Level Programming — Build programs from whole programs through a closed vocabulary of program-forming operations, so program construction becomes an algebra over functions rather than a value-level expression with variables.
• Functional Fixedness — The cognitive bias in which encoding an object under its conventional category label crowds out inspection of its raw physical properties, blocking the solver from a non-conventional use the problem needs and the object's properties would permit.
• Functor — A structure-preserving map between categories that carries objects and morphisms while respecting identities and composition — the two axioms that make it a licence to transport theorems from one category to another along its rails.
• Hamming Scheme — The association scheme on fixed-length words over a finite alphabet whose relation classes are indexed by Hamming distance.
• Knowledge Space — Represent a curriculum as a family of feasible learner knowledge states rather than a single score, using union closure and related learning-path structure to separate what a learner can do from what the learner may be ready to learn next.
• Linked Open Data Release — Publish a dataset as a machine-traversable RDF graph with HTTP-dereferenceable identifiers, an explicit open license, and outbound links to other graphs — so downstream systems can resolve, link into, and traverse it without bilateral negotiation.
• Liskov Substitution Principle — Certify that a subtype can safely replace its supertype only when it honours the supertype's full contract toward clients — weakening preconditions, strengthening postconditions, preserving invariants — regardless of taxonomy or compilability.
• Long Parameter List — The code smell in which a function requires many separately-supplied inputs at its call boundary because internal complexity was offloaded onto callers — the defect being not the count but hidden co-variation structure that belongs inside the interface.
• Mathematical Flow Graph — Encode coupled linear equations as a weighted directed graph whose declared readback and path, loop, determinant, or elimination rules preserve and solve the represented system.
• Merge Conflict — Halt an automatic merge and hand the decision to a human exactly where two branches diverged from their common ancestor on the same region, because a three-way merge over text can rank a one-sided edit but has no syntactic basis to choose between two competing edits whose correctness lives in intent it cannot see.
• Near-equivalence Mapping — Bridge two concepts in different controlled vocabularies with a declared correspondence that carries an explicit, typed loss-risk on the bridge itself, so consumers can route each substitution on whether their use falls in the safe zone.
• Phrase structure rules — Rewrite rules that expand phrasal categories into ordered constituents to generate or analyze the syntactic structure of sentences.
• Precoordinated Heading — Fuse topic, place, period, and form into one canonical subject string at indexing time so users retrieve by matching a whole browsable label, trading expressiveness and easy schema evolution for that browsability.
• Primitive Obsession — The code smell of representing domain concepts that carry structural commitments — units, valid ranges, well-formedness, identity — as bare primitives like int or string, so the type system cannot enforce the distinctions and they survive only as validation duplicated at every callsite.
• Prototype-based programming — An object-oriented programming paradigm in which objects inherit behavior directly from reusable prototype objects rather than from classes.
• Query Optimization — Let the author state only what result a declarative query should return, then have a separate optimiser search the space of algebraically equivalent execution plans and emit the cheapest one under a cost model.
• Reflexive closure — The smallest reflexive binary relation containing a given relation, obtained by adjoining every identity pair on the underlying set.
• Refused Bequest — Flag an inheritance edge as broken when a subclass accepts a parent's implementation but refuses part of its contract — stubbing, throwing, or silently mishandling inherited members — because that refusal is exactly the Liskov substitutability violation the is-a declaration promised not to make.
• Relational Model — Organize data as typed sets of tuples queried by a small closed algebra of relation-to-relation operators, so any composition is itself a valid query, rewrites preserve meaning, and the logical schema is separated from physical storage.
• Replacement Relation — Record that a distinct successor resource takes over a predecessor's canonical standing and flags it obsolete, as a bidirectional machine-routable link, so consumers read currency off the chain rather than inspecting the artifacts themselves.
• Sequent — Package antecedent and succedent formula contexts into a two-sided formal judgment whose interpretation and admissible transformations are fixed by a proof calculus.
• Signedness — A programming-language type property that determines whether an integer representation and its operations include negative values or instead use a nonnegative modular range, affecting conversions, comparison, overflow, and interfaces.
• Specification language — A formal language used to state what a system must do at a higher level than executable implementation code.
• Subject Heading String — Assemble a main topical heading with an ordered sequence of controlled subdivisions — topical, geographic, chronological, form — into one concatenated string at indexing time, eagerly committing a multi-facet intersection as a single citable, browsable, retrievable token.
• Ternary Form — The musical A–B–A pattern in which an opening section fixes a tonal identity, a contrasting middle departs from it, and a perceptible return restores it — a frame around contrast whose homecoming carries the weight of what B traversed.
• Trie — A tree of symbol-labelled edges storing a set of strings so that every root-to-node path spells a prefix and strings sharing a prefix share a path, answering prefix queries in time proportional to the query length alone, independent of how many strings are stored.
• Type Inference — Algorithmically reconstruct the types of expressions from their usage context rather than from annotations, by generating an equality constraint at each syntactic form and solving them by unification to return either each expression's principal (most general) type or a genuine type error.
• Type System — A discipline that assigns every value and expression a type and uses that classification to constrain which operations may legally apply, verifying via compositional typing rules that well-typed programs cannot reach a wrong-kinded state (soundness).
• Unavoidable Pattern — Require that, over every finite alphabet, some alphabet-dependent length threshold forces every longer word to contain a contiguous nonerasing morphic instance of the pattern.
• Universal property — Define a mathematical object not by its internal construction but by the unique pattern of maps it sustains with every other object in a class — a commuting-diagram condition plus a unique-mediating-morphism clause that pins the object down up to unique isomorphism.