# feel v0.1.0 - API Reference

## Modules

- [Feel](Feel.md): FEEL, the Friendly Enough Expression Language of DMN 1.6.
- [Feel.AST](Feel.AST.md): The syntax tree that `Feel.parse/2` returns.
- [Feel.Analysis.AllowedValues](Feel.Analysis.AllowedValues.md): Compiles allowed values: those of a variable of a `Feel.Scope`, and those of the result of
an expression (D-138).
- [Feel.Analysis.Analyzer](Feel.Analysis.Analyzer.md): Turns a syntax tree into the resolved form that a backend runs.
- [Feel.Analysis.AtLiterals](Feel.Analysis.AtLiterals.md): The value of an `@"..."` literal, decoded when the expression is prepared.
- [Feel.Analysis.Callees](Feel.Analysis.Callees.md): The functions a callee can be, read from the node of the callee (D-193).
- [Feel.Analysis.Calls](Feel.Analysis.Calls.md): The part of analyzing a call of a built-in function that does not need the analyzer (D-56).
- [Feel.Analysis.DateArithmetic](Feel.Analysis.DateArithmetic.md): The dates that a date plus or minus a duration can be (D-109).
- [Feel.Analysis.DatePreimage](Feel.Analysis.DatePreimage.md): The dates and the durations that give a date in a set when one is added to the other (D-122).
- [Feel.Analysis.DateProperties](Feel.Analysis.DateProperties.md): The year, month, day, weekday and value of a date that is one of the days of a set (D-109).
- [Feel.Analysis.Declarations](Feel.Analysis.Declarations.md): What the declarations of a scope are used for: the one option `declarations:` of `Feel.prepare/2` (D-138).
- [Feel.Analysis.DurationProperties](Feel.Analysis.DurationProperties.md): The components of a duration that is one of the amounts of a set (D-109).
- [Feel.Analysis.External](Feel.Analysis.External.md): 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).
- [Feel.Analysis.Failure](Feel.Analysis.Failure.md): The operands for which an operation, or a call of a number built-in, can be `null` (D-194).
- [Feel.Analysis.Filters](Feel.Analysis.Filters.md): The types of `source[brackets]` (DMN 1.6, Table 69; D-71).
- [Feel.Analysis.Grain](Feel.Analysis.Grain.md): How fine the numbers of a node are (D-161, step D).
- [Feel.Analysis.Identity](Feel.Analysis.Identity.md): A value compared with itself (D-170): `x = x` is `true` and `x != x` is `false`, for every value of FEEL, `null` included.
- [Feel.Analysis.Images](Feel.Analysis.Images.md): The type of the result of a call of a built-in function, exact to the values of its arguments (D-161, step C).
- [Feel.Analysis.Images.Boolean](Feel.Analysis.Images.Boolean.md): The rules for the boolean built-ins (`Feel.Analysis.Images`, D-161): `not`.
- [Feel.Analysis.Images.Context](Feel.Analysis.Images.Context.md): The rules for the context functions (`Feel.Analysis.Images`, D-170; `Feel.Builtin.Context`): `context`, `context merge`,
`context put`, `get entries` and `get value`.
- [Feel.Analysis.Images.Conversion](Feel.Analysis.Images.Conversion.md): 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`.
- [Feel.Analysis.Images.List](Feel.Analysis.Images.List.md): The rules for the list built-ins (`Feel.Analysis.Images`, D-161, step C): the 24 functions of `Feel.Builtin.List`.
- [Feel.Analysis.Images.Number](Feel.Analysis.Images.Number.md): 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.
- [Feel.Analysis.Images.Number.Modulo](Feel.Analysis.Images.Number.Modulo.md): The numbers `modulo(dividend, divisor)` can give, and when it gives `null` (`Feel.Analysis.Images.Number`, D-161).
- [Feel.Analysis.Images.Number.Preimage](Feel.Analysis.Images.Number.Preimage.md): The numbers an argument of a number built-in can be when the result is in a set (D-161, step C).
- [Feel.Analysis.Images.Number.Real](Feel.Analysis.Images.Number.Real.md): The numbers `sqrt`, `log` and `exp` can give, and when they give `null` (`Feel.Analysis.Images.Number`, D-161).
- [Feel.Analysis.Images.Number.Rounding](Feel.Analysis.Images.Number.Rounding.md): The numbers `floor`, `ceiling`, `round up`, `round down`, `round half up`, `round half down` and `decimal` can give
(`Feel.Analysis.Images.Number`, D-161).
- [Feel.Analysis.Images.Range](Feel.Analysis.Images.Range.md): 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`.
- [Feel.Analysis.Images.String](Feel.Analysis.Images.String.md): 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`.
- [Feel.Analysis.Images.Temporal](Feel.Analysis.Images.Temporal.md): 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`.
- [Feel.Analysis.Inference](Feel.Analysis.Inference.md): The static result types of operations, for `Feel.Analysis.Analyzer`.
- [Feel.Analysis.IntegerSet](Feel.Analysis.IntegerSet.md): Sets of whole numbers, as sets of numbers (D-109).
- [Feel.Analysis.Intervals](Feel.Analysis.Intervals.md): What an operation does to a set of numbers (D-39).
- [Feel.Analysis.Invocations](Feel.Analysis.Invocations.md): 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.
- [Feel.Analysis.Iterations](Feel.Analysis.Iterations.md): The types of `for`, `some` and `every` (D-86), which the analyzer reads off the types of the domains and of the body.
- [Feel.Analysis.MomentArithmetic](Feel.Analysis.MomentArithmetic.md): The times and dates and times that a time or a date and time plus or minus a duration can be (D-109).
- [Feel.Analysis.MomentProperties](Feel.Analysis.MomentProperties.md): 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).
- [Feel.Analysis.MomentTests](Feel.Analysis.MomentTests.md): What a comparison of a time or a date and time says of the values, as sets of their images (D-109).
- [Feel.Analysis.MomentZones](Feel.Analysis.MomentZones.md): 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).
- [Feel.Analysis.MonthScaling](Feel.Analysis.MonthScaling.md): The months that a years and months duration times a number, or divided by one, can be (D-109).
- [Feel.Analysis.Narrowing](Feel.Analysis.Narrowing.md): What a condition says about the names it reads (D-194).
- [Feel.Analysis.Narrowing.Kinds](Feel.Analysis.Narrowing.Kinds.md): The kinds of subject some facts are about, and the subjects that are paths from each name (D-194, D-154).
- [Feel.Analysis.NullReasons](Feel.Analysis.NullReasons.md): Why an operation can be `null` for the values of its operands (D-161, step B).
- [Feel.Analysis.Operands](Feel.Analysis.Operands.md): The values an operand of an arithmetic operation can be, when the result is in a set (D-122).
- [Feel.Analysis.Paths](Feel.Analysis.Paths.md): The type of `e.name` from the type of `e` (D-65).
- [Feel.Analysis.Preimage](Feel.Analysis.Preimage.md): The numbers an operand can be when the result of an operation is in a set (D-122).
- [Feel.Analysis.QuotedNames](Feel.Analysis.QuotedNames.md): The report of the names that were written in backticks (D-81).
- [Feel.Analysis.References](Feel.Analysis.References.md): Which of some names an expression reads, found in its syntax tree.
- [Feel.Analysis.Refinement](Feel.Analysis.Refinement.md): The seam between the analysis of an expression and the proofs about the values it can have (D-133).
- [Feel.Analysis.Refinement.Operations](Feel.Analysis.Refinement.Operations.md): What the operators do to sets of values: the part of typing an operation that is refinement (D-133).
- [Feel.Analysis.ScopeStack](Feel.Analysis.ScopeStack.md): The names visible at one point of an expression, innermost first (DMN 1.6, section
10.3.2.11).
- [Feel.Analysis.Tables](Feel.Analysis.Tables.md): 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`).
- [Feel.Analysis.TestSets](Feel.Analysis.TestSets.md): The values that unary tests accept, as sets (D-39).
- [Feel.Backend](Feel.Backend.md): What turns a resolved expression into something that runs.
- [Feel.Backend.Beam](Feel.Backend.Beam.md): The backend that compiles an expression to a BEAM module.
- [Feel.Backend.Beam.Chunks](Feel.Backend.Beam.Chunks.md): Cuts the long straight lines of generated code into functions of a bounded size.
- [Feel.Backend.Beam.Emitter](Feel.Backend.Beam.Emitter.md): Turns the resolved form of an expression into Erlang abstract format.
- [Feel.Backend.Beam.Loader](Feel.Backend.Beam.Loader.md): Compiles generated forms and manages the modules they become.
- [Feel.Backend.Beam.Scalar](Feel.Backend.Beam.Scalar.md): The guarded fast path of the BEAM backend, for the expressions that only do scalar work on declared names (D-164).
- [Feel.Backend.Interpreter](Feel.Backend.Interpreter.md): The backend that walks the resolved form of an expression.
- [Feel.Backend.Interpreter.Monitored](Feel.Backend.Interpreter.Monitored.md): 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`).

- [Feel.Backend.Interpreter.Plain](Feel.Backend.Interpreter.Plain.md): 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.

- [Feel.Backend.Interpreter.Walk](Feel.Backend.Interpreter.Walk.md): The walk of the nodes that `Feel.Backend.Interpreter` runs, as the text of a module that is made twice
- [Feel.Builtin](Feel.Builtin.md): The built-in functions of FEEL (DMN 1.6, section 10.3.4).
- [Feel.Builtin.Arguments](Feel.Builtin.Arguments.md): What the built-in functions share in dealing with their arguments (DMN 1.6, section 10.3.4, D-79).
- [Feel.Builtin.Boolean](Feel.Builtin.Boolean.md): The boolean function of FEEL (DMN 1.6, section 10.3.4.2, Table 74).
- [Feel.Builtin.Context](Feel.Builtin.Context.md): 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`.
- [Feel.Builtin.Conversion](Feel.Builtin.Conversion.md): The conversion functions of FEEL (DMN 1.6, section 10.3.4.1, Table 73).
- [Feel.Builtin.Function](Feel.Builtin.Function.md): A built-in function of FEEL, as the registry describes it (D-56, which settles D-56).
- [Feel.Builtin.List](Feel.Builtin.List.md): The list functions of FEEL (DMN 1.6, section 10.3.4.4, Table 76), and `sort`
(section 10.3.4.9).
- [Feel.Builtin.List.Aggregate](Feel.Builtin.List.Aggregate.md): 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.
- [Feel.Builtin.List.Sequence](Feel.Builtin.List.Sequence.md): 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.
- [Feel.Builtin.Number](Feel.Builtin.Number.md): The numeric functions of FEEL (DMN 1.6, section 10.3.4.5, Table 77).
- [Feel.Builtin.Range](Feel.Builtin.Range.md): 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`.
- [Feel.Builtin.Size](Feel.Builtin.Size.md): The size of what a built-in function is going to make, worked out before it makes it (D-154).
- [Feel.Builtin.String](Feel.Builtin.String.md): The string functions of FEEL (DMN 1.6, section 10.3.4.3, Table 75).
- [Feel.Builtin.Temporal](Feel.Builtin.Temporal.md): 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).
- [Feel.Diagnostic](Feel.Diagnostic.md): A report about a problem in a FEEL expression.
- [Feel.Dialect](Feel.Dialect.md): The dialects of FEEL that an expression can be prepared in (D-49).
- [Feel.Expression](Feel.Expression.md): A prepared FEEL expression.
- [Feel.Extension](Feel.Extension.md): A set of additions to FEEL that a caller switches on when it prepares an expression (D-81).
- [Feel.Extension.Camunda.Functions](Feel.Extension.Camunda.Functions.md): The functions that Camunda has and DMN 1.6 does not (D-81).
- [Feel.Extension.Camunda.Json](Feel.Extension.Camunda.Json.md): FEEL values as JSON text and the other way (D-81): what `to json(value)` and `from json(value)` of Camunda do.
- [Feel.Extension.Camunda.Overloads](Feel.Extension.Camunda.Overloads.md): The signatures that Camunda gives to functions of DMN 1.6 (D-81).
- [Feel.Extension.Camunda.TemporalFormats](Feel.Extension.Camunda.TemporalFormats.md): The spellings of a time and of a date and time that Camunda reads and DMN 1.6 does not (D-81).
- [Feel.Extensions](Feel.Extensions.md): The extensions that are on for an expression, resolved (D-81).
- [Feel.IR](Feel.IR.md): The resolved form of an expression: what `Feel.prepare/2` builds from the syntax
tree, and what the backends run.
- [Feel.ItemDefinitions](Feel.ItemDefinitions.md): 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).
- [Feel.Limits](Feel.Limits.md): Caps on how much work an expression may cause.
- [Feel.Name](Feel.Name.md): Names in FEEL.
- [Feel.Optimizer](Feel.Optimizer.md): The step between the analyzer and the backends: it removes from the IR what the analysis has
already settled (D-45).
- [Feel.Paranoid](Feel.Paranoid.md): Inspection for trusted fixtures; execution and monitoring run in the caller.
Use the ordinary `Feel` APIs for default containment of untrusted input.
- [Feel.Recursion](Feel.Recursion.md): Functions that call one another, each prepared on its own (D-188).
- [Feel.Rules](Feel.Rules.md): 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.
- [Feel.Runtime](Feel.Runtime.md): The shared runtime and generated-code cache stamp.
- [Feel.Runtime.AllowedValues](Feel.Runtime.AllowedValues.md): The verification of a value against allowed values (D-138).
- [Feel.Runtime.Arithmetic](Feel.Runtime.Arithmetic.md): The arithmetic operators of FEEL: `+`, `-`, `*`, `/`, and negation (DMN 1.6,
Tables 57 to 61 and 63).
- [Feel.Runtime.BindingTypes](Feel.Runtime.BindingTypes.md): The conversion of bound values to the types that were declared for them (D-138).
- [Feel.Runtime.Bindings](Feel.Runtime.Bindings.md): The values an expression reads by name.
- [Feel.Runtime.Boxed](Feel.Runtime.Boxed.md): The strict reading of the condition of a boxed expression (DMN 1.6, 10.2.1.8 to 10.2.1.10; D-212).
- [Feel.Runtime.Budget](Feel.Runtime.Budget.md): A cumulative budget for sequential runs in one process.
- [Feel.Runtime.Compare](Feel.Runtime.Compare.md): Equality and ordering: `=`, `!=`, `<`, `<=`, `>`, and `>=` (DMN 1.6, Tables 50
and 53 to 55).
- [Feel.Runtime.DecisionTable](Feel.Runtime.DecisionTable.md): The run of a decision table (DMN 1.6, clause 8 and 10.3.2.10), for both backends.
- [Feel.Runtime.Env](Feel.Runtime.Env.md): The environment of one run: its mode, its dialect, its extensions, its clock, its limits, and the
diagnostics it has produced so far.
- [Feel.Runtime.EqualItems](Feel.Runtime.EqualItems.md): Which items of a list are the first of several that are equal, and which are equal to one before them
([`occurrences/1`](Feel.Runtime.EqualItems.html#occurrences/1)), and the list without the items that are equal to one that was kept
([`distinct/1`](Feel.Runtime.EqualItems.html#distinct/1)), without comparing
every pair.
- [Feel.Runtime.Filter](Feel.Runtime.Filter.md): Filters and indexes: `source[predicate]` (DMN 1.6, section 10.3.2.5 and Table 69).
- [Feel.Runtime.Interpret](Feel.Runtime.Interpret.md): The run of an expression by the interpreter's walk, for generated code that has begun one and cannot finish it
(D-164).
- [Feel.Runtime.Invoke](Feel.Runtime.Invoke.md): Function values, and the call of one (DMN 1.6, section 10.3.2.13, Table 64; D-82).
- [Feel.Runtime.Iteration](Feel.Runtime.Iteration.md): `for`, `some` and `every` (DMN 1.6, section 10.3.2.14 and Table 50; D-86).
- [Feel.Runtime.Kind](Feel.Runtime.Kind.md): The kind of a value: which row of the semantic tables of DMN 1.6 (section
10.3.2.15) applies to it.
- [Feel.Runtime.Logic](Feel.Runtime.Logic.md): Three-valued logic: conjunction, disjunction, and negation (DMN 1.6, section
10.3.2.4 and Tables 51 and 52).
- [Feel.Runtime.NullOperand](Feel.Runtime.NullOperand.md): A `null` operand that is an error (D-103, was D-103).
- [Feel.Runtime.Number](Feel.Runtime.Number.md): Arithmetic on FEEL numbers: decimal128, with the scale rules of DMN 1.6 (Tables
58 and 60).
- [Feel.Runtime.Number.Power](Feel.Runtime.Number.Power.md): The power `base ** exponent` of two FEEL numbers, as one correctly rounded result
(DMN 1.6, decision D-62).
- [Feel.Runtime.Partial](Feel.Runtime.Partial.md): The results of a `for` so far, for a body that only indexes `partial` (`partial[i - 1]`, `count(partial)`).
- [Feel.Runtime.Path](Feel.Runtime.Path.md): Selecting from a value by a name: `e.name` (DMN 1.6, Tables 65 to 68 and section 10.3.2.5, D-65).
- [Feel.Runtime.RangeLiteral](Feel.Runtime.RangeLiteral.md): 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).
- [Feel.Runtime.RangeText](Feel.Runtime.RangeText.md): Reads the text of a range, as `range(from)` does (DMN 1.6, Table 73, grammar rules 66 and 67; decision D-73).
- [Feel.Runtime.Regex](Feel.Runtime.Regex.md): 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).
- [Feel.Runtime.ResultType](Feel.Runtime.ResultType.md): The conversion of a result to the type that was declared for it (D-138).
- [Feel.Runtime.Temporal](Feel.Runtime.Temporal.md): Arithmetic and comparison of dates, times, dates and times, and durations (DMN 1.6, Tables 54,
55 and 58; decision D-54).
- [Feel.Runtime.TemporalText](Feel.Runtime.TemporalText.md): 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).
- [Feel.Runtime.TypeCheck](Feel.Runtime.TypeCheck.md): The `instance of` operator (DMN 1.6, Table 62).
- [Feel.Runtime.UnaryTests](Feel.Runtime.UnaryTests.md): 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).
- [Feel.Scope](Feel.Scope.md): The names and types an expression may refer to, known before it runs.
- [Feel.Syntax.Characters](Feel.Syntax.Characters.md): The character classes of the FEEL lexical grammar (DMN 1.6, section 10.3.1.2).
- [Feel.Syntax.Lexer](Feel.Syntax.Lexer.md): Splits FEEL source text into raw tokens (DMN 1.6, section 10.3.1.4).
- [Feel.Syntax.NameSet](Feel.Syntax.NameSet.md): A set of canonical names (see `Feel.Name`) that tells a name from the start of one.
- [Feel.Syntax.Parser](Feel.Syntax.Parser.md): Parses a FEEL expression (DMN 1.6, grammar rules 1 and 2) from tokens.
- [Feel.Syntax.SFeel](Feel.Syntax.SFeel.md): The check that an expression is in S-FEEL, the simple subset of FEEL (DMN 1.6, clause 9; D-49).
- [Feel.Syntax.ScopeIndex](Feel.Syntax.ScopeIndex.md): What the parser needs to know of a scope, made once and added to one name at a time.
- [Feel.Syntax.Token](Feel.Syntax.Token.md): A token of FEEL source text.
- [Feel.Syntax.TypeParser](Feel.Syntax.TypeParser.md): Parses a type expression (DMN 1.6, grammar rule 52) from tokens.
- [Feel.Type](Feel.Type.md): The FEEL type system (DMN 1.6, section 10.3.2.9).
- [Feel.Type.Arrows](Feel.Type.Arrows.md): Function types as arrows, an overloaded function as the intersection of several (D-171), and the questions about them.
- [Feel.Type.Composite](Feel.Type.Composite.md): Declared types that go past the specification's lattice: `{:not, type}` and `{:union, [type, ...]}` (D-178).
- [Feel.Type.Conformance](Feel.Type.Conformance.md): How types relate to each other (DMN 1.6, sections 10.3.2.9.1 and 10.3.2.9.2).
- [Feel.Type.Conversion](Feel.Type.Conversion.md): The implicit conversions of DMN 1.6, section 10.3.2.9.4.
- [Feel.Type.ExactNumber](Feel.Type.ExactNumber.md): Numbers worked on without rounding (D-109).
- [Feel.Type.Except](Feel.Type.Except.md): The members of a union that are a list, a range, a context or a function **less** some others (D-152).
- [Feel.Type.Image](Feel.Type.Image.md): The numbers that stand for the values of a date or a duration, so that their sets can be sets
of numbers (D-109).
- [Feel.Type.Instance](Feel.Type.Instance.md): How values relate to types (DMN 1.6, sections 10.3.2.9 and 10.3.2.15, Tables 43
and 62).
- [Feel.Type.Moment](Feel.Type.Moment.md): The numbers that stand for a time and for a date and time in a set (D-109).
- [Feel.Type.NumberSet](Feel.Type.NumberSet.md): A set of numbers, as intervals (D-39).
- [Feel.Type.Recursive](Feel.Type.Recursive.md): Finite graphs for guarded recursive item declarations.
- [Feel.Type.StringSet](Feel.Type.StringSet.md): 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).
- [Feel.Type.Union](Feel.Type.Union.md): Types with the null made explicit, for inference (D-39).
- [Feel.Type.Verdict](Feel.Type.Verdict.md): A question about types, answered **yes**, **no with a value**, or **unknown**.
- [Feel.Type.Witness](Feel.Type.Witness.md): A value of a type: the proof that a type is not empty, and the counterexample that a question about types needs.
- [Feel.Value](Feel.Value.md): FEEL values, and the FEEL type `Any`.
- [Feel.Value.Boolean](Feel.Value.Boolean.md): The FEEL type `boolean` (DMN 1.6, section 10.3.2.3.3).
- [Feel.Value.Context](Feel.Value.Context.md): 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).
- [Feel.Value.Date](Feel.Value.Date.md): The FEEL type `date` (DMN 1.6, section 10.3.2.3.5).
- [Feel.Value.DateTime](Feel.Value.DateTime.md): The FEEL type `date and time` (DMN 1.6, section 10.3.2.3.6): a date together
with a time of day.
- [Feel.Value.DaysAndTimeDuration](Feel.Value.DaysAndTimeDuration.md): The FEEL type `days and time duration` (DMN 1.6, section 10.3.2.3.7).
- [Feel.Value.Format](Feel.Value.Format.md): The text of a value, as `string(...)` writes it (DMN 1.6, section 10.3.4.1; D-56).
- [Feel.Value.Function](Feel.Value.Function.md): The FEEL type `function` (DMN 1.6, section 10.3.2.8).
- [Feel.Value.List](Feel.Value.List.md): The FEEL type `list` (DMN 1.6, section 10.3.2.5): an ordered sequence of
values.
- [Feel.Value.Null](Feel.Value.Null.md): The FEEL type `Null`: the bottom of the type lattice (DMN 1.6, sections
10.3.2.1 and 10.3.2.9).
- [Feel.Value.Number](Feel.Value.Number.md): The FEEL type `number` (DMN 1.6, section 10.3.2.3.1).
- [Feel.Value.Range](Feel.Value.Range.md): The FEEL type `range` (DMN 1.6, section 10.3.2.7): an interval between two
endpoints.
- [Feel.Value.String](Feel.Value.String.md): The FEEL type `string` (DMN 1.6, section 10.3.2.3.2).
- [Feel.Value.Temporal](Feel.Value.Temporal.md): Reads the text of a date, a time, a date and time, or a duration, and finds out
which of the five it is.
- [Feel.Value.Temporal.Spellings](Feel.Value.Temporal.Spellings.md): Other spellings of the text of a time and of a date and time, and how DMN 1.6 writes them (D-81).
- [Feel.Value.Time](Feel.Value.Time.md): The FEEL type `time` (DMN 1.6, section 10.3.2.3.4): a time of day.
- [Feel.Value.YearsAndMonthsDuration](Feel.Value.YearsAndMonthsDuration.md): The FEEL type `years and months duration` (DMN 1.6, section 10.3.2.3.8).
- [Feel.Value.Zone](Feel.Value.Zone.md): The time zones of times and of dates and times, and what offset they have (D-54).
- [Feel.Worker](Feel.Worker.md): Runs work in a monitored BEAM process with a deadline and bounded transfers.
- [Feel.Worker.Preflight](Feel.Worker.Preflight.md): 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.

- Exceptions
  - [Feel.Error](Feel.Error.md): The error returned when an expression cannot be prepared or its run is cut short.