Programming Language Concepts & Notation

← Back to Domain-Specific Families

Abstractions about how programs and formal languages are structured and evaluated, including variable binding and scope, paradigms like declarative and applicative programming, notations such as Polish notation, and mechanisms like pattern matching and marshalling.

24 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.

• Applicative programming language — Classify a programming language or core calculus whose expressions are organized around applying value-level functions to arguments, with lambda-calculus-style reduction or evaluation providing the semantic center, while keeping purity, typing, evaluation order, and effects as independent dimensions.
• Bounds checking — A validation operation that verifies an index, size or numeric value lies inside its permitted range before the value is used.
• Canonicalization — The conversion of multiple equivalent data representations into one designated canonical form for comparison, hashing, storage or interoperability.
• Declarative programming — A programming paradigm that specifies desired results, relationships or constraints while leaving substantial control-flow and execution-order choices to the language implementation.
• Document Structure Description — A schema language for expressing the permitted elements, attributes, content and contextual constraints of XML documents, developed as an alternative to DTD and XML Schema.
• Formation rule — A syntactic rule that recursively determines which symbol strings or expressions are well formed in a formal language, independently of their meaning or truth.
• Forward declaration — A declaration that introduces an identifier and enough type information for earlier use while postponing the entity's complete definition until later compilation context.
• Free variables and bound variables — The distinction between variable occurrences whose values are supplied by an external assignment and occurrences captured by a quantifier, lambda or other binder within an expression.
• Funarg problem — Resolve how a first-class nested function can retain or access lexically scoped nonlocal variables when its invocation outlives or occurs outside the defining stack frame.
• Hybrid algorithm — An algorithmic design that combines two or more methods for the same problem and selects or switches among them to exploit complementary performance regimes.
• Identity transform — A data transformation that reproduces every input unchanged, serving as a neutral pipeline stage and as a recursively extensible base template in transformation languages.
• Island grammar — A partial parsing grammar that recognizes selected constructs of interest as islands while treating the surrounding unmodeled text as permissive water.
• Magic number (programming) — A literal value embedded in program code whose purpose or provenance is not apparent from its local context, making behavior harder to understand and safely change.
• Marshalling (computer science) — The transformation of an in-memory object or call's structured state into a representation suitable for storage, transmission or crossing a runtime boundary, often with metadata needed for reconstruction.
• Mutual recursion — A recursive structure in which two or more functions, predicates, grammars or datatypes are defined in terms of one another rather than each referring only to itself.
• Non-local variable — Treat a variable reference as non-local to a program unit when its binding is supplied by an enclosing or otherwise noncurrent scope, making scope resolution and captured-environment lifetime explicit.
• Overlap (term rewriting) — A term-rewriting configuration in which left-hand sides of rules match intersecting positions in one term, creating competing reductions and a critical-pair confluence obligation.
• Pattern calculus — Make pattern matching the primitive computational interaction, allowing patterns and pattern abstractions to be constructed, passed, returned, and applied to decompose both functions and data structures.
• Pattern matching — The exact or rule-governed comparison of a token sequence, tree or structured value against a pattern to determine a match and optionally bind components for extraction or rewriting.
• Polish notation — A prefix expression notation in which each fixed-arity operator precedes its operands, making parse structure unambiguous without parentheses.
• Reverse Polish notation — A postfix expression notation in which each operator follows its operands, eliminating parentheses when operator arities are known and enabling direct stack evaluation.
• Systematic name — A name generated by a codified nomenclature so its components identify one entity and often encode class, structure, composition, rank, or position reproducibly rather than relying on a historical trivial name.
• Type constructor — A type-level operator that builds a new type from zero or more argument types, such as function, product, list or parameterized generic constructors.
• Uniform function call syntax — Allow an eligible free-function call f(x, y, ...) to be written in receiver form x.f(y, ...), preserving the resolved callable while exposing a uniform chainable surface syntax.