Modules
A DMN engine built on the FEEL library.
A compiled model: what Dmn.compile/2 makes of a Dmn.Model, and what Dmn.evaluate/4 runs.
Compiles a Dmn.Model to a Dmn.Compiled: a prepared FEEL expression for each element of the decision requirements graph, and the
plan that says what each reads.
The boxed expression that a part of a unit came from: what the source map (Dmn.Compiler.Source) knows of a range of the
virtual source besides the element and the place in it.
What the types of FEEL can say of a decision table before it runs (Feel.Rules).
What the compiler knows while it builds the syntax tree of one unit: the model, the types of its item definitions, and the names that are in scope where it is.
Maps a boxed expression to a syntax tree of FEEL (DMN 1.6, 10.2.2: boxed expressions "can be mapped to FEEL text").
A text of the model, parsed as FEEL and put in the source of the unit.
Renames the reads of a name in a syntax tree of FEEL, where the tree reads it from outside.
The text that a unit is prepared from, and where each part of it came from.
Maps a decision table to its node of FEEL's syntax tree (DMN 1.6, clause 8; Feel.AST, "Decision tables").
The nodes of Feel.AST that the compiler builds, so that the code that maps a boxed expression says what it maps to and not how
a tuple is made.
The types of a model, as FEEL has them: the item definitions read into a Feel.ItemDefinitions (DMN 1.6, 7.3.3), and from them
the type, the allowed values and the type constraints of every variable (Feel.ItemDefinitions.scope/2).
The unit of a DRG element: what is prepared of it, and what it reads.
A report about a model: something found when it was compiled, or when it ran.
What is wrong with a model, as a value.
The preflight of a DMN call: what Dmn.evaluate/4, evaluate_all/4, invoke/4 and run/2 copy into their worker.
Internal: not a supported API.
A set of additions to DMN 1.6 that a caller switches on when it compiles a model (DD-28), as Feel.Extension is for FEEL (D-81 of feel).
The names that DMN 1.1 gave the date and time types (:dmn_1_1_types): dateTime is date and time, dayTimeDuration is
days and time duration and yearMonthDuration is years and months duration. DMN 1.2 renamed them to what FEEL calls them, and
feel knows only those; the models of the DMN TCK of that time (0007, 0036) still write the old ones.
What a caller switches on when it compiles a model, as one option: features: (DD-29).
Reads the models that a model imports, all of them, through the resolver the caller gave (Dmn.Resolver).
The bounds that dmn keeps on a model that comes from outside.
A DMN model as data: the Definitions of DMN 1.6 (clause 6.3.2), read from an XML document by Dmn.Reader.
A businessKnowledgeModel (DMN 1.6, 6.3.9): a function, encapsulated_logic (a Dmn.Model.Expressions.FunctionDefinition),
that decisions and other models invoke by the name of its variable.
A decision (DMN 1.6, 6.3.7): its variable (the name and the type of its value), the requirements it has, and its
decision logic, expression, which is any boxed expression or nil for none.
A decisionService (DMN 1.6, 6.3.10): a function whose parameters are input_data and input_decisions, and whose result
is that of the output_decisions, which may be computed from the encapsulated_decisions. The lists are references.
A decisionTable (DMN 1.6, clause 8.3).
An input clause: expression is the input expression (a Dmn.Model.Expressions.LiteralExpression, with its own
type_ref), and input_values are the Dmn.Model.UnaryTests that the values of the input are expected to satisfy.
An output clause: name (none for the one output of a table that has one), type_ref, output_values (the allowed outputs,
and their order for the priority policies) and default_output_entry (a literal expression).
A rule: input_entries (Dmn.Model.UnaryTests, one for each input), output_entries (Dmn.Model.Expressions.LiteralExpression,
one for each output) and annotation_entries (texts).
The boxed expressions of DMN 1.6 (clauses 7.3, 8.3 and 10.5): the decision logic of a decision, the encapsulated logic of a business knowledge model, and what is inside them.
A binding of an invocation: the parameter of the called function, and expression, its value.
A conditional: condition (if), then, otherwise (else), each an expression or nil.
A context: its entries, in the order of the document.
A contextEntry: the variable it binds, and value, the expression of it. The entry of a context that has no variable is
the result of the context (DMN 1.6, 10.2.1.4).
A filter: the list source (in) and the expression match that selects its items.
A functionDefinition: parameters (the formalParameters) and body. kind is :feel, or the kind of an external
function (:java, :pmml, :onnx), which the engine does not run.
An invocation: function is the expression of the called function (a literal expression with the name of a business knowledge
model, a decision service or a function in scope), and bindings bind its parameters by name.
A for, some or every (kind): variable is the iteratorVariable, source the expression of in (and
source_type_ref its typeRef), and body the expression of return (for for) or satisfies (for the quantifiers).
A list: its items, expressions, in order.
A literalExpression: text is the text of the expression, nil for none. expression_language is the URI the element
names (nil for that of the model). imported_values is the importedValues element when the text is not there, which
the engine does not read.
A relation: its columns (Dmn.Model.InformationItem) and its rows, each the list of the values of the columns.
A functionItem (DMN 1.6, 7.3.3): the type of a function, in an item definition. output_type_ref is the type of the result,
and parameters are the Dmn.Model.InformationItems that the function takes.
An import (DMN 1.6, 6.3.3): the model with namespace is available under name. location_uri is a hint for a
Dmn.Resolver and is never opened by itself. It is a URI reference (RFC 3986): a relative one is resolved against the base_uri of the
model that has the import, which is what the resolver is given the importer for. An empty name imports into the default namespace
of the importing model.
An InformationItem (DMN 1.6, 7.3.4): a name with a type. It is the variable of a decision, an input data and a business
knowledge model, a parameter of a function, a column of a relation. type_ref is the name of a built-in type or of an item
definition, as Dmn.Reader normalized it (Dmn.Reader says how), or nil for no type, which is Any.
An inputData (DMN 1.6, 6.3.11): a named input of the model, with its variable.
An itemDefinition (DMN 1.6, 7.3.3): a type of the model. It has one of a type_ref (a built-in type or another item
definition), components (a context of them), and a function_item; or none of them, which is Any. allowed_values and
type_constraint are Dmn.Model.UnaryTests, and is_collection makes it a list of the type.
A knowledgeSource (DMN 1.6, 6.3.12): documentation of where a decision gets its authority. It has no logic.
A reference to an element: href="#id" is an element of the same model, href="namespace#id" one of the model with that
namespace, which a model imports (DMN 1.6, 6.3.3). An id is an xsd:ID, which has no #, and a namespace may have one
(https://example.org/m#v2), so the id is what follows the last #.
An information, knowledge or authority requirement (DMN 1.6, 6.3.13 to 6.3.15): element is the reference to what is
required, and kind says what kind of requirement it is.
A UnaryTests (DMN 1.6, 7.3.2): the text of a list of unary tests, such as the allowedValues of an item definition or an
inputEntry of a rule. expression_language is nil for that of the model.
A decision selected from a compiled model by Dmn.prepare_call/3, run with Dmn.run/2.
How the models that a model imports are found.
What Dmn.evaluate_all/4 gives: the values of the decisions that were asked for, and the diagnostics of every element that was run.
Runs a compiled model.
Reads an XML document that nobody vouches for.
An element of an XML document, as Dmn.XML reads it.