Freon Terminology

A - C

Phrase	Description
Abstract concept	A concept that cannot be instantiated directly; other concepts inherit from it.
Abstract Syntax Tree (AST)	The internal tree structure of a model, where each node represents an instance of a language concept. It is the core model manipulated directly by users of the Freon editor instead of plain text.
Action	Certain behavior of the editor, for instance, the reaction to a key stroke.
Alternative namespace	A statement in the scoper definition that removes the names from the parent namespace, and replaces them by names of another namespace.
Alternative Nodes	Declared nodes from namespaces that have an alternative relationship with the current namespace, defined in the alternatives block.
`alternatives` (keyword)	Defines replacement or non-hierarchical visibility relationships between namespaces.
Anytype Rule	A general validation rule that applies to all concepts.
AST	See Abstract Syntax Tree (AST).
.ast file	File containing the definition of the metamodel of the language. The extension must be ‘.ast’.
AST.change()	A helper method from @freon4dsl/core to ensure all model mutations are MobX-reactive.
AST-Based Interpretation	Evaluation performed directly on the AST, without parsing or lexing steps, thanks to Freon’s projectional editor.
Balancing expressions	Automatic restructuring of binary expression trees in Freon so that operator precedence is reflected correctly after editing.
Binary expression	A subtype of Expression that defines an expression with a left and right operand, combined using an operator such as +, *, AND, or >.
Boolean type	A primitive type with two values: true or false.
Box	A TypeScript class that represents a rectangle on the editor screen.
Box API	Key editor box methods such as findParam(), setFocus(), and refreshComponent(). Used by external components and custom projections for runtime interaction with the editor.
Box Provider	A generated class that produces boxes for specific AST concepts in the Freon editor.
Box Role	An identifier assigned to a box that links it to specific editor behaviors or actions. Box roles connect visual elements in a projection to the logic that handles user interactions.
Box Tree / box model	The hierarchy of boxes used by the Freon editor to represent layout and structure of a model on screen.
Caret Position	The current insertion point in the editor, managed by the FreCaret interface.
Concept	The primary building block of a Freon metamodel, similar to a class in UML.
Concrete Syntax Tree (CST)	A tree representing how a model appears visually; in Freon, this corresponds to the Box Model.
`conformsto` (keyword)	A predefined function in the typer, that defines that a certain type conforms to another type. The function can also be used in the validator.
Container Descriptor (piContainer)	Metadata linking an element to its parent container in the AST hierarchy.
CST	See Concrete Syntax Tree (CST).
Custom Action	A user-defined editor action created with FreCustomAction.create().
Custom Box Definitions	User-defined layouts or components replacing generated box structures.
Custom Message Rule	Definition of user-defined error messages and severity levels (message, severity) used during validation.
Custom Projection	A user-defined method that returns a box for a given concept, registered in nodeTypeToBoxMethod.
Custom Scoper	A user-defined replacement for, or augmentation to, the generated scoper, currently applied globally rather than per concept.
Custom Typer	A user-defined replacement for, or augmentation to, the generated typer, applied per concept.
Customization Level	The layer where handwritten TypeScript code extends or replaces generated behavior in Freon.

D - E

Phrase	Description
Declared Nodes	All named nodes (with a name: identifier property) within a namespace’s AST subtree, including nodes that define other namespaces, but excluding the declared nodes from those namespaces.
Default Validation Rules	Automatically enforced checks such as required properties, valid references, and non-empty lists.
Document Object Model (DOM)	The browser’s structure of HTML elements; Freon’s rendered boxes eventually map to DOM nodes.
Domain-Specific Language (DSL)	A programming or modeling language tailored to a specific problem domain, providing constructs and abstractions closely aligned with domain concepts rather than general-purpose computation. In Freon, DSLs are designed, edited, and executed using generated tools that combine structural definitions (metamodels), projections, and validation rules.
Domain-Specific Runtime Class	A subclass of RtObject that models domain-specific runtime behavior.
DSL	See Domain-Specific Language
.edit file	File containing the definition of the editors, or projection sets of the language. The extension must be ‘.edit’.
Editor	A loosely used term to refer to the runtime tool in the browser, or to a certain projection set.
Editor definition (.edit)	A file describing how concepts and their properties are projected in the Freon editor, thus defining a projection set.
Editor Framework	The set of Freon subsystems that manage projections, actions, caret movement, and rendering.
Embedding Freon	Integrating the Freon editor into a custom web application, typically using Svelte components.
Enumeration	See limited concept.
`equalsto` (keyword)	A predefined function in the typer, that defines that a certain type is considered to be equal to another type. The function can also be used in the validator.
Error Severity	Classification of validation messages (e.g., error, warning, hint, info).
Evaluation	The process of computing the value associated with an AST node during interpretation.
Evaluation Function	A generated or user-defined method that determines the meaning or output of a specific AST node.
Evaluation Override	The act of redefining a generated evaluation function to perform actual interpretation logic.
Expression (or Expression Concept)	A subtype of Concept that defines a construct that produces a value.
External Component	A Svelte or Svelte-wrapped component embedded inside a Freon projection.

F - H

Phrase	Description
Fragment	A part of a projection definition.
FreAction	Defines an executable editor operation such as inserting, deleting, or modifying nodes.
FreBehavior	Encapsulates user interaction logic that links triggers to editor actions.
FreCaret	Interface representing the caret’s current position, movement, and focus behavior.
FreComponentProps	The properties passed to an external component, containing editor and box references.
FreCustomAction	User-defined action class used to add or override default editor behavior.
FreEditor	The main runtime editor interface controlling projections, boxes, and user interactions.
FreEnvironment	Central registry providing access to language definitions, scopers, typers, and validators.
FreError Interface	Interface defining issues or diagnostics produced during validation or typing.
FreExpression Interface	Base interface for all expression elements in the Freon model.
FreNamedNode Interface	Interface that extends FreNode with a name property used in references and scoping.
FreNode Interface	The base interface for all Freon model elements, providing identity and structural information.
FreNodeReference	A Freon class that represents name-based references, ensuring models remain trees instead of graphs.
Freon	The Freon framework for building DSL editors for the web. The name ‘Freon’ comes from the Frisian word for ‘friend’.
`freon all`	Command that generates all dependent components in the correct order, ensuring compilable and consistent output.
`freon ast-it`	Command that generates code for all concepts, units etc. from .lang definition files.
`freon clean-it`	Command that removes all generated TypeScript code for your language.
`freon diagram-it`	Command that generates UML diagrams from .ast definition files.
`freon edit-it`	Command that generates projection code from .edit definition files.
Freon Editor	The projectional graphical editor generated from a Freon DSL specification.
Freon interpreter framework	A Freon runtime framework that allows execution or simulation of DSL models.
`freon interpret-it`	Command that generates interpreter code for your language.
Freon Language Workbench	The Freon platform for defining, generating, and executing web-based DSL editors.
`freon parse-it`	Command that generates parser code from .edit definition files.
`freon scope-it`	Command that generates scoping code from .scope definition files.
`freon type-it`	Command that generates typing code from .type definition files.
`freon validate-it`	Command that generates validation code from .valid definition files.
FrePostAction	Action executed after a primary action, often for cleanup or UI refresh.
FreProjection Interface	Interface defining how a language concept is visually projected in the editor.
FreProjectionHandler	A Freon runtime class that manages projection rendering and links between AST nodes and visual boxes.
FreReader	Component that parses models from text or serialized data into AST structures.
FreReader Interface	Interface defining how models are parsed from text input into Freon’s AST representation.
FreScoper	Component responsible for resolving references and managing name visibility in the model.
FreScoper Interface	Interface defining the logic for resolving references and visible names within a Freon model.
FreStdlib	Component that holds the standard library of predefined elements and limited concepts available in a language.
FreStdlib Interface	Interface defining all predefined instances and limited concepts for a given language in Freon.
Fre-tools	The modular components generated by Freon, such as the editor, scoper, typer, validator, parser, and standard library.
FreTriggerType	Enumeration defining input types (e.g., key, mouse) that can trigger editor actions.
FreTriggerUse	Enumeration describing how triggers are applied (e.g., pressed, released, repeated).
FreType Interface	Interface implemented by all type concepts in Freon.
FreTyper	Component for inferring and checking the types of model elements.
FreTyper Interface	Interface defining the logic for type inference, type equality, and conformance checks.
FreTyperPart	A modular part of the typer that implements type inference for a subset of concepts.
FreUndoManager	Component that handles undo and redo operations for model edits.
FreValidator	Component for validating models to ensure semantic correctness.
FreValidator Interface	Interface defining how models are validated to ensure semantic correctness.
FreWriter	Component that serializes models back to text or persistent form.
FreWriter Interface	Interface defining how models are serialized or exported from Freon to text or files.
Global section	The .edit file section listing available external components in a language, and settings to be applied globally in the editor.
GradeScore	A concept representing a grading rule composed of a grade and an expression.
hasType Rule	Identifies which AST concepts or interfaces have an associated type.

I - N

Phrase	Description
`if(MetaType)` (function)	Limits a scope expression to nodes of a specific metatype (concept or model unit); skips others.
Imported Nodes	Declared nodes of other namespaces included via an imports block; private properties are excluded.
`imports` (keyword)	Adds declared nodes from other namespaces to the current namespace’s visible nodes; can be marked recursive.
Inference Rule	Defines how to determine the type of a term, e.g. infertype self.declaredType.
`initialize()`	Function used in external components to set up and synchronize data before rendering.
Interpreter	A component that traverses and evaluates the AST to compute values to be associated with certain nodes.
Interpreter Context	A runtime data structure that stores variable bindings, constants, and references during evaluation, allowing nested evaluations to access local and parent scopes.
Interpreter Framework	Freon’s subsystem that enables the evaluation of DSL models directly from their Abstract Syntax Tree (AST).
`isNamespace` (keyword)	Declares which concepts, model units, or interfaces identify namespaces within the language.
`istype` (keyword)	Declares which AST concepts are recognized as types.
`isunique` (keyword) / is-unique rule	Built-in validation rule ensuring that all elements in a list are unique, effectively treating the list as a strict set. Used in .valid files to enforce uniqueness constraints within Freon models.
Language engineer	The person using Freon to create a DSL and the tools to use the DSL.
Language Environment	Runtime environment containing the generated Fre-tools for a specific language.
Limited Concept	A structural element in the language, that can only have a limited number of predefined instances. A more extensive version of an enumeration.
LionWeb	An open initiative for web-based interoperability of modeling tools using a standard JSON interchange format.
LionWeb repository	A server implementation that stores models using the LionWeb protocol; it can be connected to Freon for model persistence.
M0 Level	The runtime level, representing values or results from executing or interpreting M1 models.
M1 Level	The model level, containing user-created instances of language concepts edited in the Freon editor.
M2 Level	The language definition level, describing available concepts in .ast files.
Meta Levels	The conceptual separation of model definition (M2), model instance (M1), and runtime execution (M0).
Metamodel	The structure that defines the syntax and semantics of a DSL in Freon.
MobX Reactivity	The reactive data layer used in Freon to track model state and automatically update the UI.
Model	An instance of the language metamodel, like an object is an instance of a class. The model is what the user is interested in.
Model Unit	A modular part of a model that can be edited or stored separately, enabling large-scale DSL models.
Name Resolution	Process of linking references in the model to their declared elements.
Name-based reference	A Freon reference mechanism that identifies model elements by name rather than by internal ID.
Named Editor	A projection set.
Named Elements	Model elements with unique names that can be referenced by other parts of the model.
Named property projection	A single projection in a (named) projection set.
Namespace	A subtree of the AST where a certain set of nodes is visible, identified by an instance of a concept, model unit, or interface.
Namespace addition	A rule allowing one namespace to import names from another (e.g., from a related page).
Namespace Graph / Tree	The overall structure formed by all namespaces; forms a tree when hierarchical, or a directed graph when imports or alternatives exist.
`notempty` (keyword) / not-empty rule	Built-in validation rule ensuring that lists are not empty. Used in .valid files to enforce that a property contains at least one element within a Freon model.

O - R

Phrase	Description
Object Constraint Language (OCL)	A formal language co-created by Jos Warmer for expressing constraints on UML models.
Operator Priority	The precedence rules defining how binary expressions are grouped during editing and interpretation.
`owner()` (function)	Returns the owning namespace of the current property or node, used for navigating upward through the AST.
Parameter Lookup	The process by which the interpreter retrieves a parameter’s current value from the active context.
Parent Nodes	Visible nodes inherited from the parent namespace, contributing to hierarchical or lexical scoping.
Pareto principle	The principle that roughly 80% of the effects come from 20% of the causes; used in Freon to explain how the framework focuses on simplifying the majority of language-engineering tasks.
Parsing (Reader)	The operation of reading a textual or serialized representation into a Freon model.
Partial Interpretation	Occurs when evaluation cannot be completed because required context or values are missing.
Precedence of projections	In a set of projections for the same concept, the priority of one projection over the other.
`private` (keyword)	Marks properties in .ast files that should not be imported into other namespaces.
Private Properties	Properties in .ast files marked with the `private` keyword; visible only within their own namespace, not when imported elsewhere.
Projection	The visual representation of the model’s AST displayed and manipulated in the Freon editor.
Projection Priority	The Freon mechanism that determines whether a projection comes from a custom, definition-based, or default source.
Projection set	A named set of projection definitions, one per structural element in the language.
Projectional Editing	An editing paradigm where users work directly on the model structure (AST) instead of plain text.
Projectional Editor	An editor that directly manipulates the AST, ensuring models are always syntactically valid.
Public property	A property that is not declared private with regard to namespace imports.
Reference	A property linking one concept to another (similar to associations in UML).
Reference shortcut	A shortcut allowing automatic creation of reference nodes without double selection.
RenderComponent	Freon’s internal renderer that displays a childBox inside an external component.
RtArray	Represents arrays of runtime objects.
RtBoolean	Represents boolean values.
RtError	Represents runtime errors encountered during interpretation.
RtNumber	Represents numeric values at runtime.
RtString	Represents string values.
Runtime Object (RtObject)	The base class for all runtime results produced by interpretation, ensuring a clear separation between model and runtime layers.
Runtime Object Library	A collection of classes used for representing evaluated runtime values.

S - T

Phrase	Description
Scope provider (or scoper)	A component that is able to determine for each term in the model which names of other elements of the model are visible.
Scoper	The Freon name for scope provider.
.scope file	File containing the definition of the scope provider for the language. The extension must be ‘.scope’.
Scoping	The mechanism that determines which names or elements are visible in a certain context.
Scoping Rules	Definitions determining which names are visible and resolvable in a given context.
Scoping, Typing, and Validation	The three main components of Freon’s semantic analysis framework.
`self` (keyword)	Optional prefix for referencing direct properties within scoping expressions, similar to “this” in programming languages.
Severity Levels	Possible values for validation message severity: error, warning, hint, improvement, todo, and info.
Simple Value Rule	Restricts a property to specific values or numeric ranges.
Singleton Pattern	Ensures only one instance of the standard library (stdlib) exists at runtime.
Stacked Architecture	Freon’s three-level structure combining default, definition-based, and custom code layers.
Standard Library (Stdlib)	Collection of built-in elements and reusable constructs defined for a language.
Svelte Components	UI building blocks written in Svelte; used to extend or replace parts of Freon’s editor interface.
Symbol	The concrete syntax to be used for the operator in a binary expression. For instance the ’+’ in ‘4+5’.
Term	Part of a model that can be associated with a type (using a typer), or with a value (using an interpreter).
Trigger	The key stroke, or series of key strokes, that the user must enter to let the editor perform a certain function.
Triggers and Key Bindings	User input patterns (keyboard or mouse) that activate specific editor actions.
Type Check Rule	Verifies that two elements have compatible or identical types (`typecheck equalsType` or `typecheck conformsTo`).
Type Comparison	Type concept instances cannot be compared by identity; comparison must use `equalsto` or `conformsto`.
Type Concept	A specialized concept representing a type within a Freon language. It implements the FreType interface and is not part of the Abstract Syntax Tree (AST) itself but provides the type information associated with model elements or terms.
Type Conformance	Rules defining whether one type can be used where another is expected.
Type Equality	Rules defining when two types are considered identical within the type system.
Type Inference	Process of determining the type of a model element based on context and rules.
Type provider (or typer)	A component that determines, for each term in the model, which type to associate with that term.
`type()` (function)	Returns the type of a node as determined by the typer; must appear at the end of an expression.
Typer	The Freon name for type provider.
.type file	File containing the definition of the type provider for the language. The extension must be ‘.type’.
Typing	Determines which elements are valid in specific locations within a model or Abstract Syntax Tree (AST).

U - Z

Phrase	Description
Unparsing (Writer)	The reverse process of serializing a model from AST to text.
User	The person using Freon’s tools — e.g., the editor, scoper, or validator — to create models in a DSL.
.valid file	File containing the definition of the validator for the language. The extension must be ‘.valid’.
Valid Identifier Rule	Checks whether identifiers follow TypeScript’s identifier rules (validIdentifier).
Validation	Defines the rules that must hold in a language beyond syntax level, ensuring consistency and correctness of the model.
Validation Rules	Rules that check whether models obey the domain semantics of a language.
Validator	A component that is able to determine for each term in the model whether the term is correct or erroneous.
Validator Definition	A .valid file containing the validation rules applied to models built by the user.
Valid-identifier-rule	A built-in function in the validator definition that defines a check on whether a string is a valid identifier.
Visible Nodes	The complete set of named nodes accessible in a namespace, constructed from declared, imported, alternative, and parent nodes.
Where-clause	A part of a typer definition that defines conditions for all properties of a concept. It is used in ‘equalsto’ and ‘conformsto’ definitions.