Modules
FEEL, the Friendly Enough Expression Language of DMN 1.6.
The syntax tree that Feel.parse/2 returns.
Compiles allowed values: those of a variable of a Feel.Scope, and those of the result of
an expression (D-138).
Turns a syntax tree into the resolved form that a backend runs.
The value of an @"..." literal, decoded when the expression is prepared.
The functions a callee can be, read from the node of the callee (D-193).
The part of analyzing a call of a built-in function that does not need the analyzer (D-56).
The dates that a date plus or minus a duration can be (D-109).
The dates and the durations that give a date in a set when one is added to the other (D-122).
The year, month, day, weekday and value of a date that is one of the days of a set (D-109).
What the declarations of a scope are used for: the one option declarations: of Feel.prepare/2 (D-138).
The components of a duration that is one of the amounts of a set (D-109).
An external function (function(a, b) external {java: {...}}, DMN 1.6 10.3.2.13), lowered to a call of the function that an
extension adds for its kind (D-211).
The operands for which an operation, or a call of a number built-in, can be null (D-194).
The types of source[brackets] (DMN 1.6, Table 69; D-71).
How fine the numbers of a node are (D-161, step D).
A value compared with itself (D-170): x = x is true and x != x is false, for every value of FEEL, null included.
The type of the result of a call of a built-in function, exact to the values of its arguments (D-161, step C).
The rules for the boolean built-ins (Feel.Analysis.Images, D-161): not.
The rules for the context functions (Feel.Analysis.Images, D-170; Feel.Builtin.Context): context, context merge,
context put, get entries and get value.
The rules for the conversion functions (Feel.Analysis.Images, D-170; Feel.Builtin.Conversion): date, date and time,
duration, number, range, string, time and years and months duration.
The rules for the list built-ins (Feel.Analysis.Images, D-161, step C): the 24 functions of Feel.Builtin.List.
The rules for the number built-ins (Feel.Analysis.Images, D-161): the type of the result of a call of abs, ceiling,
decimal, even, exp, floor, log, modulo, odd, round down, round half down, round half up, round up
and sqrt, from the types of the arguments.
The numbers modulo(dividend, divisor) can give, and when it gives null (Feel.Analysis.Images.Number, D-161).
The numbers an argument of a number built-in can be when the result is in a set (D-161, step C).
The numbers sqrt, log and exp can give, and when they give null (Feel.Analysis.Images.Number, D-161).
The numbers floor, ceiling, round up, round down, round half up, round half down and decimal can give
(Feel.Analysis.Images.Number, D-161).
The rules for the range functions (Feel.Analysis.Images, D-170; Feel.Builtin.Range): after, before, coincides,
during, finished by, finishes, includes, meets, met by, overlaps, overlaps after, overlaps before,
started by and starts.
The rules for the string built-ins (Feel.Analysis.Images, D-161, step C): contains, ends with, lower case,
matches, replace, split, starts with, string join, string length, substring, substring after,
substring before and upper case.
The rules for the functions of Feel.Builtin.Temporal (Feel.Analysis.Images, D-161, step C): day of week,
day of year, is, month of year, now, today and week of year.
The static result types of operations, for Feel.Analysis.Analyzer.
Sets of whole numbers, as sets of numbers (D-109).
What an operation does to a set of numbers (D-39).
The type of the result of the call of a value, f(1), (function(a) a)(2), g(3)(4) (D-82), and what can be
said of the call before it runs.
The types of for, some and every (D-86), which the analyzer reads off the types of the domains and of the body.
The times and dates and times that a time or a date and time plus or minus a duration can be (D-109).
The year, month, day, weekday, hour, minute and second of a time or a date and time that is one of the seconds of a set (D-109).
What a comparison of a time or a date and time says of the values, as sets of their images (D-109).
The value, time offset and timezone of a time or a date and time that is one of the seconds of a set (D-109).
The months that a years and months duration times a number, or divided by one, can be (D-109).
What a condition says about the names it reads (D-194).
The kinds of subject some facts are about, and the subjects that are paths from each name (D-194, D-154).
Why an operation can be null for the values of its operands (D-161, step B).
The values an operand of an arithmetic operation can be, when the result is in a set (D-122).
The type of e.name from the type of e (D-65).
The numbers an operand can be when the result of an operation is in a set (D-122).
The report of the names that were written in backticks (D-81).
Which of some names an expression reads, found in its syntax tree.
The seam between the analysis of an expression and the proofs about the values it can have (D-133).
What the operators do to sets of values: the part of typing an operation that is refinement (D-133).
The names visible at one point of an expression, innermost first (DMN 1.6, section 10.3.2.11).
What the analyzer knows of a decision table that does not need the analyzer: whether the node is a table at all, and the type of
its result (DMN 1.6, clause 8, 10.3.2.10; the node is described in Feel.AST).
The values that unary tests accept, as sets (D-39).
What turns a resolved expression into something that runs.
The backend that compiles an expression to a BEAM module.
Cuts the long straight lines of generated code into functions of a bounded size.
Turns the resolved form of an expression into Erlang abstract format.
Compiles generated forms and manages the modules they become.
The guarded fast path of the BEAM backend, for the expressions that only do scalar work on declared names (D-164).
The backend that walks the resolved form of an expression.
The walk of the nodes of a monitored run, Feel.Backend.Interpreter.run_monitored/4: Feel.Backend.Interpreter.Walk
with a monitor, a function of a node and its value that is told each node as it is made (Feel.Paranoid, D-159). An
operand that is read under a condition that does not hold is not told (and, or, between).
The walk of the nodes of a run, Feel.Backend.Interpreter.run/3: Feel.Backend.Interpreter.Walk without a monitor.
eval/3 is the evaluation of a node.
The walk of the nodes that Feel.Backend.Interpreter runs, as the text of a module that is made twice
The built-in functions of FEEL (DMN 1.6, section 10.3.4).
What the built-in functions share in dealing with their arguments (DMN 1.6, section 10.3.4, D-79).
The boolean function of FEEL (DMN 1.6, section 10.3.4.2, Table 74).
The context functions of FEEL (DMN 1.6, section 10.3.4.10, Table 82): get value, get entries,
context, context put and context merge.
The conversion functions of FEEL (DMN 1.6, section 10.3.4.1, Table 73).
A built-in function of FEEL, as the registry describes it (D-56, which settles D-56).
The list functions of FEEL (DMN 1.6, section 10.3.4.4, Table 76), and sort
(section 10.3.4.9).
The list functions that make one value of a list of them (DMN 1.6, section 10.3.4.4, Table 76): count,
sum, mean, median, mode, stddev, product, min, max, all and any. They are a part of
Feel.Builtin.List, which has the others and says what it is that they share.
The list functions that make a list of a list or ask about its items (DMN 1.6, section 10.3.4.4, Table 76):
append, concatenate, distinct values, flatten, index of, insert before, list contains,
list replace, remove, reverse, sort (section 10.3.4.9), sublist and union. They are a part of
Feel.Builtin.List, which has the others and says what it is that they share.
The numeric functions of FEEL (DMN 1.6, section 10.3.4.5, Table 77).
The range functions of FEEL (DMN 1.6, section 10.3.4.7, Table 79): before, after, meets, met by,
overlaps, overlaps before, overlaps after, finishes, finished by, includes, during, starts,
started by and coincides.
The size of what a built-in function is going to make, worked out before it makes it (D-154).
The string functions of FEEL (DMN 1.6, section 10.3.4.3, Table 75).
The functions of FEEL that read date and time values: is (section 10.3.4.6),
day of week, day of year, week of year, and month of year (section
10.3.4.8), and now and today (section 10.3.4.11).
A report about a problem in a FEEL expression.
The dialects of FEEL that an expression can be prepared in (D-49).
The error returned when an expression cannot be prepared or its run is cut short.
A prepared FEEL expression.
A set of additions to FEEL that a caller switches on when it prepares an expression (D-81).
The functions that Camunda has and DMN 1.6 does not (D-81).
FEEL values as JSON text and the other way (D-81): what to json(value) and from json(value) of Camunda do.
The signatures that Camunda gives to functions of DMN 1.6 (D-81).
The spellings of a time and of a date and time that Camunda reads and DMN 1.6 does not (D-81).
The extensions that are on for an expression, resolved (D-81).
The resolved form of an expression: what Feel.prepare/2 builds from the syntax
tree, and what the backends run.
The item definitions of a DMN model, read into the types and the allowed values of a Feel.Scope (DMN 1.6,
section 7.3.2, "Item definition"; D-99).
Caps on how much work an expression may cause.
Names in FEEL.
The step between the analyzer and the backends: it removes from the IR what the analysis has already settled (D-45).
Inspection for trusted fixtures; execution and monitoring run in the caller.
Use the ordinary Feel APIs for default containment of untrusted input.
Functions that call one another, each prepared on its own (D-188).
Questions about a table of rules whose entries are unary tests, the input entries of a decision table: does the table cover the inputs, do two rules share an input, is a rule never reached.
The shared runtime and generated-code cache stamp.
The verification of a value against allowed values (D-138).
The arithmetic operators of FEEL: +, -, *, /, and negation (DMN 1.6,
Tables 57 to 61 and 63).
The conversion of bound values to the types that were declared for them (D-138).
The values an expression reads by name.
The strict reading of the condition of a boxed expression (DMN 1.6, 10.2.1.8 to 10.2.1.10; D-212).
A cumulative budget for sequential runs in one process.
Equality and ordering: =, !=, <, <=, >, and >= (DMN 1.6, Tables 50
and 53 to 55).
The run of a decision table (DMN 1.6, clause 8 and 10.3.2.10), for both backends.
The environment of one run: its mode, its dialect, its extensions, its clock, its limits, and the diagnostics it has produced so far.
Which items of a list are the first of several that are equal, and which are equal to one before them
(occurrences/1), and the list without the items that are equal to one that was kept
(distinct/1), without comparing
every pair.
Filters and indexes: source[predicate] (DMN 1.6, section 10.3.2.5 and Table 69).
The run of an expression by the interpreter's walk, for generated code that has begun one and cannot finish it (D-164).
Function values, and the call of one (DMN 1.6, section 10.3.2.13, Table 64; D-82).
for, some and every (DMN 1.6, section 10.3.2.14 and Table 50; D-86).
The kind of a value: which row of the semantic tables of DMN 1.6 (section 10.3.2.15) applies to it.
Three-valued logic: conjunction, disjunction, and negation (DMN 1.6, section 10.3.2.4 and Tables 51 and 52).
A null operand that is an error (D-103, was D-103).
Arithmetic on FEEL numbers: decimal128, with the scale rules of DMN 1.6 (Tables 58 and 60).
The power base ** exponent of two FEEL numbers, as one correctly rounded result
(DMN 1.6, decision D-62).
The results of a for so far, for a body that only indexes partial (partial[i - 1], count(partial)).
Selecting from a value by a name: e.name (DMN 1.6, Tables 65 to 68 and section 10.3.2.5, D-65).
Builds the value of a range literal such as [1..10) (DMN 1.6, grammar rule 66, section 10.3.2.7;
decision D-61).
Reads the text of a range, as range(from) does (DMN 1.6, Table 73, grammar rules 66 and 67; decision D-73).
The regular expressions of matches, replace and split (DMN 1.6, section 10.3.4.3, footnote 2 of
Table 75; D-80, was D-80).
The conversion of a result to the type that was declared for it (D-138).
Arithmetic and comparison of dates, times, dates and times, and durations (DMN 1.6, Tables 54, 55 and 58; decision D-54).
Reads the text of a time or a date and time as DMN 1.6 writes it, and as the extensions that are on spell it (D-81).
The instance of operator (DMN 1.6, Table 62).
What it means for a value to satisfy unary tests (DMN 1.6, sections 7.3.2 and 10.3.2.10; notes 08 §4.6 and §4.8).
The names and types an expression may refer to, known before it runs.
The character classes of the FEEL lexical grammar (DMN 1.6, section 10.3.1.2).
Splits FEEL source text into raw tokens (DMN 1.6, section 10.3.1.4).
A set of canonical names (see Feel.Name) that tells a name from the start of one.
Parses a FEEL expression (DMN 1.6, grammar rules 1 and 2) from tokens.
The check that an expression is in S-FEEL, the simple subset of FEEL (DMN 1.6, clause 9; D-49).
What the parser needs to know of a scope, made once and added to one name at a time.
A token of FEEL source text.
Parses a type expression (DMN 1.6, grammar rule 52) from tokens.
The FEEL type system (DMN 1.6, section 10.3.2.9).
Function types as arrows, an overloaded function as the intersection of several (D-171), and the questions about them.
Declared types that go past the specification's lattice: {:not, type} and {:union, [type, ...]} (D-178).
How types relate to each other (DMN 1.6, sections 10.3.2.9.1 and 10.3.2.9.2).
The implicit conversions of DMN 1.6, section 10.3.2.9.4.
Numbers worked on without rounding (D-109).
The members of a union that are a list, a range, a context or a function less some others (D-152).
The numbers that stand for the values of a date or a duration, so that their sets can be sets of numbers (D-109).
How values relate to types (DMN 1.6, sections 10.3.2.9 and 10.3.2.15, Tables 43 and 62).
The numbers that stand for a time and for a date and time in a set (D-109).
A set of numbers, as intervals (D-39).
Finite graphs for guarded recursive item declarations.
A set of strings that has intervals in it: ["a".."m"], ("m"..), (.."c"), and strings that are
left out of them: (..) except "a", which is every string but "a" (D-39).
Types with the null made explicit, for inference (D-39).
A question about types, answered yes, no with a value, or unknown.
A value of a type: the proof that a type is not empty, and the counterexample that a question about types needs.
FEEL values, and the FEEL type Any.
The FEEL type boolean (DMN 1.6, section 10.3.2.3.3).
The FEEL type context (DMN 1.6, section 10.3.2.6): a collection of key/value entries, like a record or a JSON
object, in the order they were written (D-135).
The FEEL type date (DMN 1.6, section 10.3.2.3.5).
The FEEL type date and time (DMN 1.6, section 10.3.2.3.6): a date together
with a time of day.
The FEEL type days and time duration (DMN 1.6, section 10.3.2.3.7).
The text of a value, as string(...) writes it (DMN 1.6, section 10.3.4.1; D-56).
The FEEL type function (DMN 1.6, section 10.3.2.8).
The FEEL type list (DMN 1.6, section 10.3.2.5): an ordered sequence of
values.
The FEEL type Null: the bottom of the type lattice (DMN 1.6, sections
10.3.2.1 and 10.3.2.9).
The FEEL type number (DMN 1.6, section 10.3.2.3.1).
The FEEL type range (DMN 1.6, section 10.3.2.7): an interval between two
endpoints.
The FEEL type string (DMN 1.6, section 10.3.2.3.2).
Reads the text of a date, a time, a date and time, or a duration, and finds out which of the five it is.
Other spellings of the text of a time and of a date and time, and how DMN 1.6 writes them (D-81).
The FEEL type time (DMN 1.6, section 10.3.2.3.4): a time of day.
The FEEL type years and months duration (DMN 1.6, section 10.3.2.3.8).
The time zones of times and of dates and times, and what offset they have (D-54).
Runs work in a monitored BEAM process with a deadline and bounded transfers.
The budget of the preflight: the step that runs in the caller, before a worker exists, and decides what the job closure
copied into the worker holds (the internal run_prepared entry point of Feel.Worker). Internal: not a supported API.