This is an oversight in DMN16-100 which should have added ONNX to the list in the first paragraph of section "10.3.2.12 Mapping between FEEL and other domains":

Some kinds of values can be passed between FEEL and external Java methods, between FEEL and external PMML models

Add ONNX to the list

Add ONNX to the list

A single-parameter version of the FEEL number() function is needed by users and for conversion in B-FEEL.

Add single-parameter version of number function

Add a single-parameter version of the number function and reuse the existing semantics of passing in null for the second and third parameters.

Here, I am considering the following operators: =, <, >, not(), and, or, in, between

When considering FEEL for low-codes applications, we should expect these binary operators to always return true or false. Currently, when there is typing error, it returns null.

ex:
"a" = 1 => null
false and "a" => null
"a" in [0..100] => null
...

Alternative B-FEEL dialect with a single definition of null

In FEEL, the null value is used to both represent missing data or an execution error. We are proposing that null should be used only to represent missing data. All operations and built-in functions that return null in FEEL when an error occurs have their semantic modified to return a non-null value.

Abusing null as an error indicator is not enough for reporting/handling errors.
In particular, it does not solve the need for users to:

• know exactly what the root cause of an error was
• control the reaction to errors

The specification already mentions error reporting but is neither a strict requirement nor consequently used:

When a built-in function encounters input that is outside its defined domain, the function SHOULD report or log diagnostic information if appropriate and SHALL return null.

Add strict mode

Improve de specification of error handling by adding two modes lenient and strict, with the lenient mode, the current one, the default one.

The idea is to configure the execution engine with the error handling mode when the models are executed.

The Copyright section needs an update to reflect the DMN 1.6 RTF membership

Update copyright section

Update Copyright. Add Softeam that has been left out.

Currently the 4 rounding methods: round up, round down, round half up, round half down only have signatures with 2 numeric arguments (n and scale).

However, pre-existing rounding functions: floor and ceiling have both a single numeric argument version and a 2 numeric argument function (n and scale).

The single numeric argument is backward compatible with DMN 1.3 (and before). It assumes a scale of 0.

Add single parameter versions of all rounding functions

Add single parameter versions of all rounding functions and adjust the examples to use them.

Section "12.2 Machine Readable Files" refers to dtc/15-11-12 as a source for XMI and XSDs. This is wrong in several ways:

• The file is from DMN 1.1
• It is the ancillary .zip file of the RTF report, which contains a mix of normative files but also internal files of various RTF discussions
• Therefore, it is restricted to OMG members only

Update reference to machine-readable files

Use a link to the OMG website and update the list of provided files.

ONNX https://onnx.ai/ is an open format for ML models that supports some model types, especially neural networks, better than PMML. DMN should consider allow ONNX functions as it does PMML functions.

Support ONNX as an alternative to PMML

ONNX is an alternative to PMML for interchanging ML and AI models. This proposal extends the Kind of functions to include the ONNX Kind. It uses a similar approach to the existing Java and PMML Kinds so that a function can be defined as the execution of an ONNX model.

Currently concatenating strings is not intuitive to users, as I always have to convert non string values to strings using the built-in `string` function.

So

```
"Today is " + now() = null
```

In order to yield the actual string you explicitly convert `now()` to its string representation:

```
"Today is " + string(now()) = "Today is 2021-12-12"
```

A more user friendly behavior would be to coherse the second argument to string if the first argument is already a string. This always yields a string representation of the thing. If it is not what I desire I can use custom stringification mechanisms explicitly.

We'd need to amend the Table 57 (page 128, https://www.omg.org/spec/DMN/1.4/Beta1/PDF) to support such cohersion.

—

Additional details on this case can be found in https://github.com/dmn-tck/tck/issues/538 (DMN TCK issue on this topic).

Addressed in B-FEEL via DMN16-109

Addressed in B-FEEL via DMN16-109

Currently, `string(string_variable) = string_variable`, but `number(number_variable) = null`.
This leads to surprising results like `number(5) = null` but `number("5") = 5`.
Let's add a function `number(from)` which would accept `number` as the parameter.

Add number(from: number)

Add a version of the number(from) function that accepts a number as an input and returns it, which is in line with the behavior of other conversion functions, e.g. string(from), and helps in situations where expressions produce, e.g. a string or a number.

The specification lists for 1.6 will list three external function types - Java, PMML and ONNX. It is not reasonable to insist on support for these to be conformant.
2.1 Conformance Levels should be amended such that Conformance Level 3 excludes the need to support any function Kind other than FEEL - support for Java, PMML and ONNX is not required..

Make Java, PMML & ONNX optional

Make Java, PMML & ONNX optional

Grammar rule does not match to the one in proposal https://issues.omg.org/browse/DMN15-107

35. numeric literal = [ "" ] , ( digits , [ ".", digits ] | "." , digits, [ ( "e" | "E" ) , [ "+" | "" ] , digits ] ) ;

should be

35. numeric literal = [ "" ] , ( digits , [ ".", digits ] | "." , digits) , [ ( "e" | "E" ) , [ "+" | "" ] , digits ] ;

Typo already fixed in formal edit of DMN 1.5

Typo originated during edit of the convenience document. Michelle Seaver applied the revised text correctly in smsc/24-04-02 leaving no issue to be addressed in DMN 1.6.

There are a few other DMN example files with the same error as in DMN15-74. Also the typeRef, has to move into the body of the BKM not the encapsulatedLogic as this one is the same with BKM.typeRef.

Correct the typeRef for BKMs in examples

Move typeRef from variable and/or encapsulatedLogic into the body of the BKM (is the type returned by the BKM)

For tools to clearly identify the version of a DMN file or FEEL expression, the XML namespaces of DMN, and FEEL should be updated.

Namespace URIs must be backwards compatible with the scheme applied in previous versions for tools that support multiple versions in parallel. See:

• https://issues.omg.org/browse/DMN12-62?focusedCommentId=18500&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-18500
• DMN13-191
• DMN14-166
• DMN15-160

DMN DI, DI, and DC namespaces can stay the same as DMN 1.6 DI is unchanged since 1.5 and still based on the same DD 1.1 specification and "OMG Policy for Versioning of Specification URIs, File URIs, and XML Namespaces in OMG Specifications", states explicitly:

Note: if a spec has many machine readable files, and only some of them change at a given specification version, then only the changed files should get new URIs. That could mean a mixture of URI date segment values for a given specification version.

Update Namespace URIs for DMN 1.6

Update namespace URIs with the following values:

XSD: https://www.omg.org/spec/DMN/20240513/MODEL/
FEEL: https://www.omg.org/spec/DMN/20240513/FEEL/
XMI: https://www.omg.org/spec/DMN/20240513/DMN16.xmi

These URIs conform to the OMG Policy for Specification URIs and Namespaces (smsc/2018-08-01) and are backwards-compatible with the namespace scheme applied in DMN 1.2, 1.3, 1.4, and 1.5 which is important for vendors supporting multiple versions in parallel.

Section 4.1 Acknowledgement needs to be updated with DMN 1.6 RTF contributors.

Add acknowledgements for DMN 1.6 contributors

Add paragraphs to acknowledge the DMN 1.6 contributors to section "4.1 Acknowledgements" based on taskforce membership

It is not very clear (see discussion on TCK https://github.com/dmn-tck/tck/pull/366) if DRGElement can be referenced in the same XML file using an absolute path.

For example,

<requiredDecision
href=”http://www.example.org/Definitions01.xml#prebureauriskDec01”/>

is a valid reference even if prebureauriskDec01 is defined in the same file with element the referenced it.

Add clarification on DMNReference

Add clarification on DMNReference

Current DMN Specification v1.4 does not define a mapping of FEEL to JSON, while it already provides mapping for Java, XML, PMML in chapter "10.3.2.12 Mapping between FEEL and other domains"

This capability can be useful in other use-cases beyond mapping itself. For example, but not limiting to: the need for external REST-based invocation of externally defined (stateless, side-effect-free) decision services.

*Add mapping between FEEL and JSON *

Add relevant entries in chapter 10.3.2.12 in order to introduce mapping of FEEL to JSON, in addition to existing mappings.

A Knowledge Package is mechanism for packaging and distributing a set of BPM+ models (the knowledge)
A Knowledge Package references separate, but connected BPM+ models (BPMN Processes, CMMN Cases, and DMN Decision Services)
KPMN is focused solely on the BMI behavioral standards
A Knowledge Package also contains a Data Item library for the data that will be used by the BPM+ models
A Situational Data Model and Notation (SDMN) is also being proposed as a potential BMI standard to be added to the BPM+ stack (see separate presentation on this topic)
A Knowledge Package also contains metadata about the topic of the package to aid in understanding the content and to find appropriate Knowledge Packages
We are still exploring the relationships between KPMN and Provenance and Pedigree
KPMN includes a diagram to illustrate the scope of the Knowledge Package’s content (a Knowledge Model Diagram)

Close because KPMN cancelled

The KPMN 1.0 FTF decided in January 2024 to not submit a report and therefore the specification got dropped by OMG.

Figure 8-20 shows UnaryTests as being a specialization of DMNElement when it has been changed to be a specialization of Expression. The figure should be updated.

Update MM figure 8-20

Replace Figure 8-20 with a version that shows UnaryTests as a subclass of Expression

See also diff in GitHub: https://github.com/omg-dmn-taskforce/omg-dmn-spec/pull/32/files

Currently the at literal = "@", string literal
Rather than a string following the @ symbol we would use the ISO 8601 format.
For date : @YYYY-MM-DD e.g. @2019-09-17
For time : @THH:MM:SS e.g. @T09:55:00
For date and time : @YYYY-MM-DDTHH:MM:SS e.g. @2019-09-17T09:55:00
For duration : @P[n]Y[n]M[n]DT[n]H[n]M[n]S where [n] is a number
e.g. @P18M, @P365D, PT48H

The expected benefit of user friendliness does not warrant a change of grammar.

While it would be friendlier to drop the quotes in the At-literals, it would require a change of grammar. We do not expect any ambiguities to occur, but believe that such a change does not present sufficient benefit.
The issues does not seem to get much attention as it is open since DMN 1.3.

(1) The spec says "Collect: returns all hits in arbitrary order. An operator (‘+’, ‘<’, ‘>’, ‘#’) can be added to apply a simple function to the outputs. If no operator is present, the result is the list of all the output entries.". This is confusing - as I understand it if an operator is present a collect hit policy does not return all hits, only the result of the operation.

(2) The spec should state clearly what result is returned by Collect decision tables when no rules fire. In particular the result of a C+ decision table is not clear, because the result of sum([]) is undefined. I think a case could be made (based on a recursive definition) that the sum of an empty list is zero, which would be a much more useful result from the decision table than null. In general, section 10.3.4.4 restricts the semantics of all list functions to non-empty lists, although some functions have natural and useful results for the empty list e.g. count([])=0, sum([])=0, sublist([],x,y)=[], append([],items)=[items], concatenate([],items)=items, reverse([])=[], union([],items)=[], distinct values([])=[], flatten([])=[].

(3) Why is the result of C+ defined as "sum of all the distinct outputs" rather than just "sum of all the outputs"? I would say that if three rules fire proposing the value 5, the C+ result should be 15, not 5.

Clarify description of Collect hit policy

The issue raises three points. As discussed in the comments of DMN15-31:

• Point 2 has been fixed in DMN 1.4 with wording on page 118 (PDF 134).
• Point 3 has been fixed in DMN12-175

This proposal therefore only addresses Point 1 by providing revised wording for the description of the Collect hit policy.

The names of the number() function in note 1 at the end of Table 72

Correct footnote of table 72 (page 139)

In table 72 on page 138, the cell of the 9th line and 2nd column refers to a footnote ¹, which can be found on page 139.
The footnote intends to mention the parameters specified in the cell of the 9th line and 1st column of the table, but does not refer to them with correct names:

• grouping separator is incorrectly referred to as grouping
• decimal separator is incorrectly referred to as decimal
  In addition, the footnote reference ¹ in column 2 should rather be placed at the end of string, string, sting instead of after the first string.

Chapter 10.3.2.3.4 time, 10.3.2.3.5 date, 10.3.2.3.6 date-time, 10.3.2.3.7 days and time duration and chapter 10.3.2.3.8 years and months duration defines each a value function. For date time arithmetic operations it would be useful to have this value available in the FEEL semantic domain. Therefore we suggest to add a new property value that is directly available for values of this type. Return type of the value if always a number.

Table 53 should be adjusted accordingly.

Introduce new property 'value'

Expose value functions for each semantic domain as a property

A lexical time string is defined o page 131 by XML Schema Part 2 Datatypes (for local times and offset times) and by ISO 8601 with the extended form of a local time (for zoned times).

Unfortunately XML Schema Part 2 and ISO 8601 has different definitions. Therefore it is unclear which of them to use. Or are both of them valid?

Additionally the user should not have different lexical time string formats for a local time, an offset time or a zoned time.

The list of ambiguities:

• ISO 8601 allows a leading "T" character prefix. XML Schema Part 2 does not.
• ISO 8601 allows optional seconds. In XML Schema Part 2, the seconds are mandatory.
• ISO 8601 allows decimal fraction for seconds and minutes. XML Schema Part does not allow this.
• ISO 8601 allows 00:00:00 and 24:00:00 for midnight. XML Schema Part 2 only allows 00:00:00.
• ISO 8601 allows time offset of hours only. Minutes are optional. XML Schema Part 2 always requires minutes.

Therefore clarification is needed. Which definitions are valid for FEEL? The stricter XML Schema Part 2 or the more user friendly ISO 8601 spec?

Deprecate IANA time zone use in time strings

• Remove the XML Schema Part 2 from the specification as the ISO 8601 covers it.
• Deprecate usage of IANA IDs for time literals
• Add new function to allow migration of deprecated use cases.

The below text was a separate paragraph in DMN 1.4. In DMN 1.5 is a part of the previous paragraph. Also, the new typeConstraint property is missing.

An alternative way to define an instance of ItemDefinition is as a composition of ItemDefinition elements. An instance of ItemDefinition may contain zero or more itemComponent, which are themselves ItemDefinitions. Each itemComponent in turn may be defined by either a typeRef and allowedValues or a nested itemComponent. In this way, complex types may be defined within DMN. The name of an itemComponent (nested ItemDefinition) must be unique within its containing ItemDefinition or itemComponent.

Split paragraphs again

Split accidentally merged paragraphs and complete the list of options

Currently the in parameter is defined as: This attribute holds the expression that is evaluated as the collection to be processed.

The intention was to align with the FEEL version of filter and iterators and therefore apply the the 10.3.2.9.4 Type conversions rule: to singleton list: When the type of the expression is T and the target type is List<T> the expression is converted to a singleton list.

The definition of the in parameter needs to be updated to properly reflect this.

Clarify that implicit conversion applies to Filter and Iterator

Clarify that implicit conversion to singleton list applies

10.3.2.9.2 says "The global context is a context provided for convenience and 'pre-compilation'. Any number of expressions can be named and represented in a FEEL context m. The syntactic description m of this context can be evaluated once, that is, mapped to the FEEL domain as m, and then re-used to evaluate many expressions." For example, you might want to put a Relation used as a multi-dimensional constant in the global context. Or you might want to put a reusable function definition in the global context. Currently the xsd does not have globals. All expressions are bound to a specific drgElement, not global. The Import element probably needs to be modified to support this also.

Issue does not relate to current spec wording

The paragraph referred to in the issue has been reworded significantly in later versions.

There is no visual way to show that a decision iterates over a collection at the top level.

Issue has mostly been addressed

A marker for Data Input collections has been added in DMN14-151. Adding a marker for decisions iterating over them would attempt to reveal part of the decision's logic, which is not the purpose of a DRD.
DMN14-195 already added the boxed iterator expression.
So there is very little left to add to a DRD and DMN14-151 has already used the icon that would be natural from a BPMN perspective.

I described several issues with the current way of representing decision table properties and made concrete suggestions for improvement in this LinkedIn post: https://www.linkedin.com/pulse/decision-table-properties-dmn-beyond-jacob-feldman

Issue withdrawn

Jacob is fine with the feedback given to him and no changes to the spec are required.

FEEL function definitions are defined as lexical closures, which simply means that names in the function body must be in scope, and that scope includes the function parameters and, just like any other decision logic, it includes the information requirements and the knowledge requirements. This is very handy. For example, it allows the logic of a BKM to reference 100 Input Data items by name, without requiring that each invocation pass in 100 parameter bindings.

In order for this to work, the BKM would model 100 Information Requirements on the 100 Input Data items, instead of modeling them as parameters. The boxed invocations would not have 100 rows of repetitive binding information. We must extend the MM and Table 2 to allow a BKM to have information requirements.

Issue rendered redundant by introduction if Invocable

This issue was raised before the introduction of invocables and decision services. Not considered necessary now.

The notion of a 'type' or ItemDefinition is in the metamodel (with some pending issues) and in the semantics and concepts, but little is in the notation. Thus, we have notation that allows you to execute an expression with actual arguments, but no notation to allow validation based on type information without actual values.

We have most of the pieces, so it should not be difficult. E.g., individual values can be number, string, date and time, etc. We can allow numeric ranges using our unary tests, e.g. '>0', '[10..30)', etc. We can allow LOVs using "abc", "def", "ghi". These can be 'simple items', and we can also define structures using something similar to boxed contexts.

No requirement for item definition notation

Notation for Item Definition is being addressed in SDMN

• out of scope for DMN

The expected output of the built-in function string() should be defined for each type. Otherwise it is unclear what the result for a value, for example of type time, is. Is it the string literal or the full expression with built-in function time()?

// which FEEL expression is valid?
string(time("11:00:00")) = "11:00:00"
string(time("11:00:00")) = "time("11:00:00")"

Recommendation: Introduce a new table that lists example outputs for all types:

• null -> null
• boolean -> "true" or "false"
• string -> "This is a string"
• number -> "-1.234"
• date -> "2017-10-11"
• time -> "11:00:00.123" or "11:00:00.123+02:00" or "11:00:00.123@Europe/Paris"
• date and time -> "2017-10-11T11:00:00.123" or "2017-10-11T11:00:00.123+02:00" or "2017-10-11T11:00:00.123@Europe/Paris"
• days and time duration -> "P2DT3H4M5.123S"
• years and months duration -> "P2Y3M"
• list -> "[1,2,3]"
• context -> "{a: true, b: false}"
• range -> "[1..100]"
• unary test -> "> 10"
• function -> null

Defer to DMN 1.7

Defer to DMN 1.7

Some built-in functions has optional parameters. Chapter 10.3.4 describes "Whenever a parameter is outside its domain, the result of the built-in is null."

Should the following call to a built-in function result to null?

replace("This is a string", "[a-z]", "#", null)

The optional parameter "flags" of the built-in function replace() is null. Parameter domain is string as stated in table 60 on page 133. Null is not in the domain of type string.

This topic was already discussed in the DMN TCK. We think that the behavior should be the same as the function is called without the optional parameter:

replace("This is a string", "[a-z]", "#", null) = replace("This is a string", "[a-z]", "#")

Clarification in the specification is appreciated.

May be we can change the sentence in chapter 10.3.4 on page 130 to: "Whenever a parameter is outside its domain, the result of the built-in is null. If null is passed as value to an optional parameter, the built-in behaves like no value is passed."

Defer to DMN 1.7

Defer to DMN 1.7

In XSD, business context pointers are duplicated in both directions. E.g. decisionOwner and decisionMaker point to organizationalUnit, which in turns has pointers back the other way. This duplication adds no new information, just potential for internal inconsistency. I suggest omitting one of these directions; the other one is easily extracted from the serialization by XPATH.

Defer to DMN 1.7

Defer to DMN 1.7

In some decision models, the input data must conform to an industry-standard xml schema in which elements of interest are many levels deep. Converting such a schema directly to a FEEL item definition requires very long path references. The xpath language has a descendants operator that significantly shortens the path expression. I propose a similar operator (or, less ideally, a function) for FEEL.

An example is MISMO from the Mortgage Bankers Association. In home appraisals, one item of interest is the Appraiser. To reference the Appraiser from the FEEL item definition generated from the xsd requires this:
MESSAGE.DOCUMENT_SETS.DOCUMENT_SET.DOCUMENTS.DOCUMENT.DEAL_SETS.DEAL_SET.DEALS.DEAL.SERVICES.SERVICE.VALUATION.VALUATION_RESPONSE.VALUATION_ANALYSES.VALUATION_ANALYSIS.PARTIES.PARTY[ROLES.ROLE.ROLE_DETAIL.PartyRoleType="Appraiser"][1]

In xpath, omitting namespace prefixes, the descendants operator // simplifies this considerably:
MESSAGE//PARTY[.//PartyRoleType='Appraiser']

If // were used as a FEEL descendants operator, you would need only
MESSAGE//PARTY//PartyRoleType="Appraiser"[1]

To get the Appraiser's name, instead of
MESSAGE.DOCUMENT_SETS.DOCUMENT_SET.DOCUMENTS.DOCUMENT.DEAL_SETS.DEAL_SET.DEALS.DEAL.SERVICES.SERVICE.VALUATION.VALUATION_RESPONSE.VALUATION_ANALYSES.VALUATION_ANALYSIS.PARTIES.PARTY[ROLES.ROLE.ROLE_DETAIL.PartyRoleType="Appraiser"].INDIVIDUAL.NAME[1]

you would need only

MESSAGE//PARTY//PartyRoleType="Appraiser"//NAME[1]

Add a descendent operator to the FEEL grammar

Add a descendant operator in the FEEL grammar that is similar to a path expression but uses 3 dots (...) instead of one.

The semantics of Import is not fully specified.

In certain use cases the same DMN element (e.g. ItemDefinition or DRGElement) can be imported multiple times (e.g. transitive imports).

Lets consider the following use case:

• Model A contains the definition of an InputData for a Person (e.g. name, age etc)
• Model B imports model A. Model B contains a decisions DB that uses the Person as input
• Model C imports models A and B. Model C contains a decision DC that uses Person and DB as input

In this situation model C imports Person twice due to transitive import.

In order to evaluate DC the Person InputData has to be bound to a value. The question is how many values is the user going to provide, lets say in a Web form? A single value or one value for each import path (in this case 2)?

I am inclining towards the first option - one single value per input data. Here is my rationale:

• InputDatas / DRGElements are uniquely identified by model namespace and DRGElement.name
• InputDatas own one single variable (see 6.3. Metamodel). The semnatics for InputData.variable is in Table 18:
  The instance of InformationItem that stores the result of this InputData.
• Consistency with the import of other DMN Elements: it does not make any sense for ItemDefinitions, BKMs and DSs to have multiple variables / values when imported several times.
• If we choose the second option and the model is refactored (e.g. models are merged), but the logic does not change, the user has to fill-in different input forms. It is not very user friendly.
• I am not aware of any PL/DSL that uses the second option

Lets discuss.

Define semantics for multiple imports

Define semantics for multiple imports of the same input data

In the DMN spec the only supported number type is decimal.

However, there are a few places (e.g. scale in round functions and list access) when an integer is needed.

What is the expected behavior when an integer is expected but a decimal number is provided? For example 'decimal(123, 5.6)' or ''remove([1, 2], 1.5).

Is this an error or the engine recovers from the error and uses only the integer part of the number?

Define type conversion from decimal to integer

Define type conversion from decimal to integer

According to the DMN spec (10.3.2.3.1 number) a number is equivalent to "Java BigDecimal with MathContext DECIMAL 128.".

The Java doc states, " A BigDecimal consists of an arbitrary precision integer unscaled value and a 32-bit integer scale.".

However, the DMN spec de scale is in range range [−6111..6176].

The question is what is the correct range for scale?

Clarify definition of number as based on IEEE 754-2008 Decimal128

Remove misleading sentence from the definition of FEEL numbers as it lead people to believe that the definition was based on Java. The sentence was just a hint for implementers and that is already covered elsewhere in the spec.

on page 122 in table 43 in row 2 and 3: "e1 in [e2, e3, ...]"
on page 109 grammar rule 51.c: expression "in" positive unary test
on page 109 grammar rule 51.c: expression "in" "(" positive unary tests ")"

The syntax with square brackets is not allowed by the grammar rules 51.c. Either table 43 or grammar definition should be changed.

Already possible

The issue was raised a long time ago. In the meantime, the grammar has changed. Currently, a positive unary test can be any feel expression, hence the second operand can be a list.

In section 10.3.1.3 Literals, data types, built-in functions, there is an enumeration of FEEL datatypes.

The first 3 starts with uppercase letters (Number, String, Boolean) while the other starts with lowercase letters.

Number, String and Boolean should be number, string, boolean like presented in the Figure 10-26: FEEL lattice type on page 112.

Correct capitalisation in 10.3

In Section 10.3.1.3, correct the capitalization of the first three items in the list.

in typographic literals, italics are strings and bold italics are date literals, but in 10.3, italics are feel syntactic elements and bold are semantic elements. Better to have different notations

Defer to DMN 1.7

Defer to DMN 1.7

The specification says that the addition/subtraction of a date and time and a years and months duration value is defined as:

date and time (
   date(e1.year +/– e2.years + floor((e1.month+/– e2.months)/12),
   e1.month +/– e2.months – floor((e1.month +/– e2.months)/12) * 12,
   e1.day), 
   time(e1))

If you apply this expression to the following two values:

• date and time("2017-08-30T11:00:00Z")
• duration("P18M")
  you would expect the following results:

date and time("2017-08-30T11:00:00Z") + duration("P18M")  --> result should be date and time("2019-02-28T11:00:00Z")
date and time("2017-08-30T11:00:00Z") - duration("P18M")  --> result should be date and time("2016-02-29T11:00:00Z")

If you apply the values to the defined formula, you get:

date and time (
   date(2017 +/– 1 + floor((8 +/– 6)/12),
   8 +/– 6 – floor((8 +/– 6)/12) * 12,
   30), 
   time("11:00:00Z"))

Addition
which results for addition into:

date and time (
   date(2018 + floor(1,1667),
   14 – floor(1,1667) * 12,
   30), 
   time("11:00:00Z"))

which is:

date and time (date(2019, 2, 30), time("11:00:00Z"))

The adjustment to the last valid day in a month is missing. 30th February is invalid, since February has only 28/29 days.

Subtraction
which results for subtraction into:

date and time (
   date(2016 + floor(0,1667),
   2 – floor(0,1667) * 12,
   30), 
   time("11:00:00Z"))

which is:

date and time (date(2016, 2, 30), time("11:00:00Z"))

The adjustment to the last valid day in a month is missing. 30th February is invalid, since February has only 28/29 days.

Recommendation:
Adjustment to last valid day in month must be added to spec.

Defer to DMN 1.7

Defer to DMN 1.7

This is a suggestion for future versions of the spec:

Add support for Unary Tests as first class citizens of the FEEL language, in a similar way as ranges and functions already are.

A unary test is really a “predicate”: a single parameter function that returns a boolean. It is syntax sugar on:

function ( x ) x in <unary_test>

FEEL already supports functions as first class citizens, so it makes sense to support Unary Tests. The following two syntaxes would then be equivalent:

is minor : < 18
is minor : function( age ) age in < 18

Invoking unary tests explicitly would be like invoking a function:

Bob is minor : is minor( bob.age )

More importantly, it would allow the implementation to actually support passing unary tests as parameters to functions and make the example on page 115 viable:

decision table (
outputs: "Applicant Risk Rating",
input expression list: [Applicant Age, Medical History],
rule list: [
[ >60, "good", "Medium" ],
[ >60, "bad", "High" ],
[ [25..60], -, "Medium" ],
[ <25, "good", "Low" ],
[ <25, "bad", "Medium" ]
],
hit policy: "Unique"
)

Unary test syntax is not ambiguous, so supporting it would mean to basically change rule 2 in the grammar to include rules 14 and 17 as possible options. The semantic mapping table on page 116 would also need to include a new FEEL value type: "unary test".

Defer to DMN 1.7

Defer to DMN 1.7

Figure 10 on page 25 with text "The encapsulated decisions are therefore

"

Figure 11 on page 26 with text "The encapsulated decisions for this services are

".

Table 20 on page 56:

• "outputDecisions: This attribute lists the instances of Decision required to be output by this DecisionService".
• "encapsulatedDecisions: If present, this attribute lists the instances of Decision to be encapsulated in this DecisionService".

For us it is unclear what decisions should be stored in the DMN model as encapsulated decisions. Must the output decisions also be included in the list of encapsulated decisions (as stated on page 25, 26)? Or does the list of encapsulated decisions only hold the decisions contained in the lower compartment of a decision service (as mentioned on 56 since encapsulatedDecisions seems to be optional)?

Defer to DMN 1.7

Defer to DMN 1.7

In Figure 6.15 the multiplicity of output decisions for a decision service is shown as zero to many (0..), but the text below and Table 16 says the that multiplicity is one to many (1..). The figure should be correct to match the text and table.

Defer to DMN 1.7

Defer to DMN 1.7

For interchange of test cases along with a decision model, it would be convenient to define metamodel and xsd elements for a suite of test cases, where a test case contains values for input data and expected values output decisions.

Defer to DMN 1.7

Defer to DMN 1.7

While the scope of context entry specifically says to include the previous context entry (section 7.3.1), there is no mention for the scope of input and output entries of decision tables.

Defer to DMN 1.7

Defer to DMN 1.7

Currently S-FEEL / FEEL contains only one single numeric type called number that matches the semantics defined in IEEE 754-2008.

This can lead to some strange constructions, such as
substring("footbar", 3.67)
perfect valid in FEEL.

It also has impact on the performance of the execution (speed).

Here is my proposal:

• keep number as an abstract type to backwards compatibility
• add a new concrete type real/float/decimal that matches the semantics of defined in IEEE 754-2008
• add a new concrete type integer
• change the signature of all built-in functions to restrict number to integer when it makes sense (e.g. index in a string and list, length of string. size of list)
• add a separate paragraph to specify the implicit conversions performed by the FEEL processor when required (e.g. function resolution). For example,
  2 + 4.5 leads to a promotion 2 -> 2.0 that adding it 4.5.

If we agree in principal all start working on it.

Defer to DMN 1.7

Defer to DMN 1.7

in chapter 10.3.2.10: "Sometimes we do not want to evalutate a FEEL expression e, we just want to know the type of e."

in table 54: column Applicability defines which row in the table to use, depending on the type of a FEEL expression.

Table 54 only makes sense if it is not allowed to pre-evaluate the expression e2, since even for a pre-evaluation context entries (for example: "item") must be declared in scope.

How do we know the type of a FEEL expression if it is not allowed to evaluate it?

Examples:

• [1,2,3][min(3,2,1)]
• {a:function() external {java: {class: "clazz", method signature: "method()"}}, b:[1,2,3][a()]}.b
• {a: 1, b: a instance of number, c: [1,2,3][b] }

Defer to DMN 1.7

Defer to DMN 1.7

The grammar contains several sub-grammars each one with its own start non-terminal: expression, simple expressions, unary tests.

The grammar should be broken in several grammars, and common part to make things more obvious. It will help the CL3 implementation.

Defer to DMN 1.7

Defer to DMN 1.7

The FEEL grammar contains simple expressions as starting terminal

page 107 6. simple expressions = simple expression ,

;

I could not find a mapping to a semantics domain for it. What is the type / domain of "simple expressions"? A list with element type Any or a Tuple Type with several element types?

Defer to DMN 1.7

Defer to DMN 1.7

If an expression in a user defined function body references a name outside of it's scope (for example a parent scope), this scope must be available also during invocation of the function.

Examples:

• {f:function() a, a:1, i:f()}

  possible, since name a is still available in local context (scope) during invocation

• {b:1,f:function() b}

  .f() impossible, since name b is not available outside of the context.

It would be nice if the semantic mapping and the differentiation between function definition and invocation is clearly specified in the spec. What names can be referenced? Must the scopes also be available during invocation?

Defer to DMN 1.7

Defer to DMN 1.7

Please clarify if it is possible to have multiple models on the same namespace. For instance:

<definitions namespace="http://my.company/financeModels" name="Model A" ...

<definitions namespace="http://my.company/financeModels" name="Model B" ...

The current text of the specification does not say anything explicitly one way or another, so please clarify that.

In addition to this, if multiple models can use the same namespace, then the <import> element will require an additional attribute (for instance: modelName) in order to uniquely identify which model should be imported.

Defer to DMN 1.7

Defer to DMN 1.7

Date "=" is defined to include the time zone, and "<" and ">" does not. This causes a bunch of problems.

see: https://social-biz.org/2017/08/03/a-strange-feeling-about-dates/

Suggestion is simple: define date equality to be (date1 - date2 == 0) Eliminate the need to compare the "timezone" of the dates.

My experience with the group is that most suggestions are ignored, so I don't really want to waste any time making a more detailed proposal, but if you have questions about this problem you can contact me.

Defer to DMN 1.7

Defer to DMN 1.7

As I see the spec doesn't define what should happen if in a context a name should be declared that already exists in the current context. Sample FEEL expression: "for i in [1,2,3], i in [4,5,6] return i * i" Does the second definition of i overwrite the first one or should we return null for the complete "for" expression?

Defer to DMN 1.7

Defer to DMN 1.7

For simple positive unary test(s) there are extra entry points in the FEEL grammar. Therefore why do we need simple positive unary test in grammar rule 2.i. What is the semantic mapping?

Defer to DMN 1.7

Defer to DMN 1.7

Section "8.2.11 Hit policy" describes that hit policy "Collect: returns all hits in arbitrary order". This implies that the order of the results does not have to be deterministic and can also vary among different implementations. However, the standard only supports the notion of 'lists', which do have an order. The comparison of lists is also specified in a way that the order of elements is significant. The issue might get more clear when thinking about testing the interface of decisions. Strictly speaking, it is currently not feasible to define a test against a decision table with hit policy 'collect'. The expected result can only be defined using a list, whose elements do have an order. The operator to compare the 'expected' and the 'actual' result will also take order into account.

The issue could easily be resolved by replacing 'arbitrary order' with 'rule order'.

Defer to DMN 1.7

Defer to DMN 1.7

All date expressions, if the timezone is not explicitly mentioned, are interpreted as being in the timezone of the computer running the code. This means you can design a model that runs correctly in one timezone,a nd incorrectly in a different one.

Imagine you have a development team in Bangalore which makes a DMN model that runs correctly and passes all the tests. Then it is installed into the company server in London, and it fails.
Does anyone think this is a good idea?

The solution is simple: the model should have a default timezone. All date expressions that don't mention the timezone are interpreted according to this default time zone, and NOT according the timezone of the machine you are running on. Then, models will run exactly the same way no matter where it is run. That is a good idea, right?

See this: https://social-biz.org/2017/08/03/a-strange-feeling-about-dates/

Defer to DMN 1.7

Defer to DMN 1.7

I remember discussions about allowing "-" in conclusions to mark an unspecified conclusion in a decision table. This would allow some of the conclusions in a multiple output decision table to be marked as "unspecified" where there was no output relevant for that conclusion for a specific rule and to allow rules in multi-hit tables to show that a particular combination of conditions had been considered but did not result in anything being added to the result set.
However the standard as written says that an output entry must adhere to the literal expression grammar, and '-' is not allowed. You have to return some FEEL value, e.g. 0, false, "N/A", null, etc.

Defer to DMN 1.7

Defer to DMN 1.7

The current spec uses objects from BMM and BPMN. However it is not at all clear how links to these objects, and the objects at the end of the links, should be interchanged. Does the DMN file contain a snippet of BPMN? Should a separate BPMN file be generated and then referenced? If we are going to have these links then we need to show/explain how to interchange them both with tools that only support DMN (and so only have a few BPMN or BMM objects) and with those that support DMN/BPMN/BMM.

Defer to DMN 1.7

Defer to DMN 1.7

(from Bruce)
a. String-join(stringList, separatorString)

b. Format-number(value, formatString), where formatString (to be negotiated) generally follows Excel or xpath, maybe not all the features.

c. Format-date(value, formatString), format-dateTime(value, formatString)

Defer to DMN 1.7

Defer to DMN 1.7

The definition of "well formed" for a BusinessKnowledgeModel excludes the notion of the encapulatedLogic of a BusinessKnowledgeModel being able to invoke itself to permit recursion. There is no means to define a 'self' relationship via knowledgeRequirements - the spec forbids it.

However, vendors are currently supporting BusinessKnowledgeModel recursion simply by permitting a BusinessKnowledgeModel's encapulatedLogic to invoke the contained BusinessKnowledgeModel as a function using the contained BusinessKnowledgeModel's name. I propose we formalise this in the spec.

I propose that after the definition of well-formed on page 56/57 (repeated below):

"An instance of BusinessKnowledgeModel is said to be well-formed if and only if, either it does not have any knowledgeRequirement, or all of its knowledgeRequirement elements are well-formed. That condition
entails, in particular, that the requirement subgraph of a BusinessKnowledgeModel element SHALL be acyclic, that is, that a BusinessKnowledgeModel element SHALL not require itself, directly or indirectly. "

The following paragraph is added:

"However, the encapsulatedLogic within a BusinessKnowledgeModel may invoke itself in a recursive manner by using the name of the containing BusinessKnowledgeModel as an invokable name."

Defer to DMN 1.7

Defer to DMN 1.7

Situational Data is the set of Data Items and their structures that are needed for the performance and understanding of a Knowledge Package Model.
The details of the Data Items will usually be a subset of the “official” complexity of those items in the environment of the Knowledge Package Model.
For example, the official definition of the Data Item for Blood Pressure (in healthcare) includes more than 50 properties. A Data Item in a Situational Data Model may need only 2 of those properties for execution of the Processes, Cases, and or Decision Services.
Semantic References can be added to link the Data Item to the “official” details.
Uses of the Data Items in BPM+ models that determine the scope of Situational Data include:
Data required for DMN Decisions
Data required for BPMN Gateways transitions
Data required to be passed to/from services invoked by BPMN and CMMN
Data required to trigger Sentries in CMMN
Etc.

Defer to DMN 1.7

Defer to DMN 1.7

some built in functions are overloaded in that they can have multiple signatures. So, say, performing an "instance of" to compare against the function "min" is meaningless as the signature is not known unless it is invoked.

Unless the type system is to take into account overloaded functions?

Defer to DMN 1.7

Defer to DMN 1.7

Figure 10.17 defines DMN Expressions and lists its specializations, but it does not list Unary Tests.
UnaryTest should be added to the diagram.

Defer to DMN 1.7

Defer to DMN 1.7

The spec sometimes refers to the temporal precision as milliseconds and sometimes to seconds. Sections 10.3.2.3.3, 10.3.2.3.5 and 10.3.2.3.6 refer to Seconds whereas table 48 offers a semantic of Milliseconds

Defer to DMN 1.7

Defer to DMN 1.7

the builtin function is() refers to this section. It should cover some pos/neg examples of equality vs. identity, and explain aggregate elements in D, e.g. list of structures.

Defer to DMN 1.7

Defer to DMN 1.7

E.g. in aggregation, default for item definition, see examples in DMN-2, where filters like [item!=null] are used repeatedly

Defer to DMN 1.7

Defer to DMN 1.7

some notes toward a proper description:
FEEL has ordered lists and some set builtins, e.g. distinct values and union. Lacks intersection and equality.

[1,2] in (1,2,[1,2], 3) is true

intersect([1,2,3], [3,1,4]) = [1,3]

set equals([1,1,3], [3,1]) is true
probably - distinct values([1,1,3]) = distinct values([3,1])
maybe change to set([1,1,3]) = set([3,1])
(set needs to both remove dups and return elements in canonical order)
what is canonical order [null, 0, {}, []]?
[1,3] = [3,1] is false

Another option is to add sets to FEEL semantic domain (along with lists, numbers, contexts, ...). And need syntax.

simpler and more biz friendly proposal - add 'contains any' and 'contains all' as boolean infix operators taking 2 lists as LHS and RHS. And allow these to be added to unary tests w/o a '?'. E.g. 1,2,3 , in (1,2,3) , contains any (1,2,3), contains all (1,2,3). First 2 are what we have now (2nd allowed for symmetry). Last 2 assume input expr is a list (set).

if we just add set oriented builtins, but no friendlier syntax, this may not solve the biz problem of allowing DTs to process sets in a user friendly way. Too many ()s and ?s

Defer to DMN 1.7

Defer to DMN 1.7

None of the metamodels contain logic constraints. For example, the name of a decision table is the same with the name of the variable defined inside of the decision table tag (invariant at decision table level).

Ideally these constrains would be used to validate the diagrams before execution (e.g. generating code from Java). Bruce Silver's already covers some of the. We should add them and more in the spec.

I think the metamodel constraints should be described with OCL – see the UML metamodels. There should be constraints for CL1, CL2 and CL3. It’s very likely the CL3 constraints will be a superset of CL2 constraints.

Defer to DMN 1.7

Defer to DMN 1.7

In section 7.3.1 Expression Meta-Model: there is no table to display the typeRef attribute added by Expression to DMNElement

Defer to DMN 1.7

Defer to DMN 1.7

split off from DMN13-12

Defer to DMN 1.7

Defer to DMN 1.7

Since DMNv1.2 the spec dropped the equivalence of:

[a] = a

because it does not apply to the statement that

a singleton list L, when used in an expression where a list is not expected, behaves as if L[1] is written.

So the expression

[a] = a

on DMNv1.2 is expected to return false.

However, in section 10.3.2.6 Context of the spec, it provides the following statement for the get entries function:

To retrieve a list of key,value pairs from a context m, the following built-in function may be used: get entries(m).
For example, the following is true:

get entries({key 1 : "value 1 "})[key="key 1 "].value = "value 1 "

BUT

get entries({key1 : "value1"})[key="key1"].value = "value1"

  by substitution:

[ { key : "key1", value : "value1" } ][key="key1"].value = "value1"
[ { key : "key1", value : "value1" } ].value = "value1"
[ "value1" ] = "value1"

according to DMNv1.2 should be false

By the same principle that the DMNv1.2 for the following literal expression:

[123] = 123

on DMNv1.2 is expected to be false

Defer to DMN 1.7

Defer to DMN 1.7

SDMN, BPMN, and CMMN have a property that specifies the kind of element that is being modeled. The set of enumerations for this property include: data, conceptual, physical, etc.
SDMN is directly referencing DMN’s ItemDefinition, but is extending the element to include this “itemKind” property.
If this property makes sense in the DMN context and is added in DMN 1.4, then SDMN would not have to extend ItemDefinition for this property.
SDMN extends ItemDefinition in other ways, which will be addressed by separate issues.

Defer to DMN 1.7

Defer to DMN 1.7

Section 9.4 says "Comparison operators are defined only when the two operands have the same type, except for years and months duration
and days and time duration, which can be compared for equality. Notice, however, that “with the exception of the zerolength
duration, no instance of xs:dayTimeDuration can ever be equal to an instance of xs:yearMonthDuration.”

Thus stating that `P0D == P0Y` despite the fact they are different types and do not comply with the type-lattice equivalency. This is as per the XPATH operation `op:duration-equal` that the spec says equality here conforms to.

It is not crystal clear if this applies to FEEL as well as SFEEL though the same sections does say:

> The semantics of S-FEEL expressions are defined in this section, in terms of the semantics of the XML Schema datatypes
and the XQuery 1.0 and XPath 2.0 Data Model datatypes, and in terms of the corresponding functions and operators
defined by XQuery 1.0 and XPath 2.0 Functions and Operators (prefixed by “op:” below). A complete stand-alone
specification of the semantics is to be found in clause 10.3.2, as part of the definition of FEEL. Within the scope of SFEEL,
the two definitions are equivalent and equally normative.

So, "Within the scope of SFEEL, the two definitions are equivalent and equally normative." seems to indicate that it does hold true for FEEL.

My recommendation is that `P0D == P0Y` does apply to FEEL because it would make sense to a business person. `1 Apple != 1 Orange`, but zero apples is really the same as zero oranges, or zero anything for that matter. And, in practice, zero days really is the same as zero years.

Defer to DMN 1.7

Defer to DMN 1.7

The new is() function is in a spec section called "Date and time functions" but it is unclear if it related only to date and time types. The examples only show date and time. Though it would seem reasonable that is also handled datetime type as well.

Additionally, it references section 10.3.2.2 for descriptions of semantics and that section deals with ore than just date and time. It also deals with other 'primitive' types - so it is unclear if is() relates to these also. Additionally, that section does not deal with other types like range/context/function/list so it is not clear if is() deals with all types in that section, and indeed other types as well.

By example, is it not evident if is({},{}) is true, false, or illegal. Similarly for is([1], [1]) or is(1,1), or is([null..2], < 2).

Additionally, it is also unclear (to me) from the semantic description whether is(@"2021-02-19T10:10:10Z", @"2021-02-19T10:10:10@Etc/GMT") as they are both UTC forms. The spec says they are 'comparable', but does that relate to is()?

Defer to DMN 1.7

Defer to DMN 1.7

In some places the spec uses type(e) and other places type(e). These are different. The former provides a type-checking function that can validate a FEEL expression e without input data values (although some kind of scope is needed for disambiguation). The latter simply returns the datatype of the semantic domain element e. The former is more useful to implementors, but more work to specify. Essentially, all the semantic mapping tables need a new column to specify the result type given the input types, for each FEEL operator and builtin. The latter is a matter of generalizing Table 39. It must cover cases such as type([0,false]). It should be clear that type(e) as a function must return the most specific type (and there must be only 1), but informally the types also include those that are conformed to, so for example, [1,2,3] has types list<number>, list<Any>, Any.

Defer to DMN 1.7

Defer to DMN 1.7

DMN spec refers to usage of iana timezones. iana does not specify that timezones are case-sensitive - that is up to the implementation. https://data.iana.org/time-zones/theory.html: re zone naming:

"Do not use names that differ only in case. Although the reference implementation is case-sensitive, some other implementations are not, and they would mishandle names differing only in case."

This issue is seeking clarification via the spec as to whether DMN's usage of time zones permits case insensitivity such that "etc/utc" is the same zone as "Etc/UTC" ... or not.

Defer to DMN 1.7

Defer to DMN 1.7

Section "10.3.2.13.2 User-defined functions" provides definition and invocation semantics for user defined functions but permits unused parameters.

As DMN is to be 'executable documentation' I suggest that unused parameters provide documentation that does not reflect reality.

I propose the follow additional paragraph to "10.3.2.13.2 User-defined functions" :

"The body expression of a user-defined function SHALL utilise every formal parameter. "

Defer to DMN 1.7

Defer to DMN 1.7

The `parameters` attribute of the new FunctionItem introduced in DMN 1.3 is plural in name and not singular like all other array attributes described in the meta-models. This is an exception.

This leads to an XML form where each `<parameters>` element contains one parameter.

Recommendation. Change FunctionItem array attribute `parameters` to `parameter`. Another possibility is to deprecate `parameters` in favour of `parameter` and drop support in a future version.

Defer to DMN 1.7

Defer to DMN 1.7

Item Definitions are hierarchical so the top level one in an Input Data or a Decision might not be a collection while one or more of those contained are. This means that there may be a collection to process even if the Input Data or Decision is not marked as a collection (see DMN14-123 for this separate issue). It should be possible to show both "fan in" where multiple instances of the source of the requirement are used by a single instance of a decision and "fan-out" when the source of requirement contains a collection which will be processed one at a time by the decision.

Defer to DMN 1.7

Defer to DMN 1.7

Section "10.5.3 FunctionDefinition metamodel" does not specify that formal parameters must be utilised in the function logic . As DMN is a self-documenting decision executable this leads to a situation where (documented) parameters may be defined but unnecessary.

I propose the following paragraph is added to section "10.5.3 FunctionDefinition metamodel":

"The body expression of a FunctionDefinition SHALL utilise every formal parameter. "

Defer to DMN 1.7

Defer to DMN 1.7

The `before` and `after` range functions have ambiguous invocation when using named params. Both functions have 4 variants - take `before` as an example:

```
(a) before(point1, point2)
(b) before(point, range)
(c) before(range, point)
(d) before(range1, range2)
```

If I invoke `before(range: [1..10], point: 1)` is it for variant (b) ... or (c) ... ?

Suggest renaming the param names or making the variants separate functions.

Defer to DMN 1.7

Defer to DMN 1.7

DMN models are serialized in the XML format. XML notation is not user-friendly.

I suggest adopting an equivalent textual notation that is user-friendly similar to the HUTN notation for UML https://www.omg.org/spec/HUTN/1.0/PDF

Defer to DMN 1.7

Defer to DMN 1.7

Subsection "6.2.2.2 Knowledge Requirement notation" of "6.2.2 DRD Requirements" states that knowledge requirements must be utilised in the decision/BKM knowledge requirement:

"If e is a decision or a BKM in some DRD, and e contains a knowledge requirement on some invocable element b, then the logic of e must contain an invocation expression of b, including expressions for each of b's parameters."

However, this section does not mandate that Information Requirements must also be utilised by the requiring DRG element in the same way that a knowledge requirement must. If a purpose of DMN is to serve as documentation and show actual relationships between decision elements then it is paramount the DRG reflects actual usage in the model, otherwise the graph is incorrect - it may show relationships that do not reflect the decision-making reality.

I propose adding the following to section "6.2.2.1 Information Requirement notation":

"If e is a DRG element in some DRD, and e contains an information requirement on some other DRG element b, then the logic of e MUST contain a usage of the information provided by b"

Defer to DMN 1.7

Defer to DMN 1.7

There are many different Functions that are needed to make FEEL expressive enough for tackle the logic of various contexts/industries:
e.g Financial Functions, Healthcare Functions, etc. even advanced Mathematical functions or Matrix manipulation functions.

Currently these functions need to be imported in, and then all functions need to be prefixed with a namespace.
This not ideal as the business friendly name with space such as "annual interest rate" now becomes cryptic as "financial.annual interest rate"
or "discount as percentage" becomes "financial.discount as percentage"

Defer to DMN 1.7

Defer to DMN 1.7

It should be possible to define partial temporal values but only for trailing precisions (i.e., if you specify a day, you must also specify a year and month)
Values of type Date, the precision unit must be one of: years, months, or Days
e.g. date( 2019 ), date( 2019, 09 ), date( 2019, 09, 17)
Values of type Time, the precision unit must be one of: hours, minutes, or seconds
e.g. time( 09 ), time( 09, 55), time( 09, 55, 00)
Values of type Date and Time, the precision unit must be one of: years, months, days, hours, minutes, or seconds
e.g. date and time( date(2019,09,17), time(09,55) ), date and time( “2019-09-17T09:55”)

Operations carried out on elements with different time based precision units shall be done based on the lowest common precision unit (truncating any resulting decimal portion) 

Defer to DMN 1.7

Defer to DMN 1.7

In many situations, it is desirable to have a data input that is an interval. Particularly when it comes to temporal logic many situations requires one to enter the "Valid Period", the "Measurement Period", the "Disccount Period" etc
To currently achieve this requires to create two data inputs (one for the start data/time and one for the end data/time) and then assembling them into an interval named "Period using a literal expression [start..end].

Defer to DMN 1.7

Defer to DMN 1.7

Add a new interval built-in function called: width of( Interval )
to offer the behavior as follows:
width of( (1..10] ) = 9
width of( [1..10] ) = 10
width of( (1..10) ) = 8
width of( [ time(“09:55:00”)..time(“10:35:00”) ] ) = PT40M

Defer until we have Integer numbers

We see the potential value of the proposed function. The examples show that results can be interpreted in different ways. Usefulness would be increased if we had integer numbers.

In other sections in the spec, InformationItem is described as storing the data through an ItemDefinition or Expression. Figure 6.16 shows that InformationItem has a /type association with ItemDefinition. Other figures show this also.
But the table in the section on InformationItem (7.3.4) doesn't list this association and ItemDefinition is not mentioned in the section.

Defer to DMN 1.7

Defer to DMN 1.7

Currently if a DMN model makes use of an external library of functions, the receiving tool may be challenged in also importing this library and execute on these new functions.

We should explore a way to make the interchanged model not only exchangeable but also executable.

Defer to DMN 1.7

Defer to DMN 1.7

The current definition of externally-defined functions only allows Java and PMML external functions. There are clear use cases for allow an external (stateless and side-effect free) service to be used in this way.

Defer to DMN 1.7

Defer to DMN 1.7

A "bucket" for collecting related issues around external links

Defer to DMN 1.7

Defer to DMN 1.7

I do not understand the following aspect about collections: Assume the input data node is a collection, but the decision is NOT a collection. From my understanding, the individual values of the input collection are passed iteratively to the decision. As the latter is NOT a collection in the example, it is my understanding there should be some form of aggregation(?).

I can understand how this should work for numerical values (e.g. "aggregate" by sum) however I am not clear of the aggregation method (is it always sum?). Furthermore, how should aggregation work if the output column of the decision contains strings?

Example: Two rules: "a"->"b", "c"->"d". Then an input collection {"a","c"} is passed. So the two outputs are "b", "d". As the decision is NOT a collection, we should not yield something like {"b","d"}, but should aggregate(?), yet, as stated, how to aggregate b,d?

Defer to DMN 1.7

Defer to DMN 1.7

When a decision service is fully defined, its dependencies are shown as the information requirements of its encapsulated decisions on external decisions or input data. If the encapsulated decisions of a decision service are not fully defined (e.g. temporarily during analysis, or because it is modelling a 3rd-party service with partial obfuscation), this may not be possible. It would be convenient in such cases to be able to draw information dependencies attaching to the boundary of the decision service. Such a service would not be executable.

This issue is a continuation of https://issues.omg.org/browse/DMN15-36 which was deferred to 1.6.

Defer to DMN 1.7

Defer to DMN 1.7

In section 10.3.4.9 of the DMN 1.5 specification (page 153, PDF 161) the sort function is defined with the possibility to use a precedes boolean function to compare list elements.

Text should be added after table 80 to clarify how the precedes function deal with equal parameters.

I would propose that precedes return false when both parameters are equals.

This new paragraph should also establish the stability expectation of the sort FEEL function (equal elements keep the order of the original list).

I would propose that the FEEL sort function does not guarantee stability. Guaranteeing stability could impact certain sort performances.

Defer to DMN 1.7

Defer to DMN 1.7

Especially when used in projects that use ML or AI models, the current approach to Knowledge Sources is not fit for purpose. A more structured, template-based approach is needed to specify what information should be captured about a policy document, a regulation, a MVAR/imputation approach, an ML model training regime, data distributions etc. Either a defined set of knowledge source types should be defined with more specific properties or it should be possible to define, exchange and use templates.

Defer to future revision

There seems to be to little interest for now

According to 6.3.1 DMN Element metamodel and 6.3.5 DRG Element metamodel, DRGElements have name and label attributes.

They also have a variable property that has a name. The DMNDI model also has a label property.

Possible solution:

• deprecate the attributes (e.g. DMNElement.label)
• add a constraint (e.g. DRGElement.name == DRGElement.variable.name)

Defer to DMN 1.7

Defer to DMN 1.7

Sections 10.3.2.9.1 Type Equivalence and 10.3.2.9.2 Type Conformance define relations between types.

The definitions do not contain specification for existing builtin functions with variable arguments (e.g. sum).

The issue was discovered in TCK when testing function invocations.

Defer to DMN 1.7

Defer to DMN 1.7

When creating a data type I cannot assign a default value (for when the user input is provided as null)

Defer to DMN 1.7

Defer to DMN 1.7

There is clear value to ML projects of using DMN to document their projects (requirements, project design, MLOps). ML programmers though use Python not Java for their functions. If DMN can support Java libraries for rules developers, it should support Python for ML developers.

Defer to DMN 1.7

Defer to DMN 1.7

Currently, the version of DMN used in an DMN XML file is identified by the XML namespace URI, which is therefore changed with every revision. However, frequently changing namespace URIs cause market fragmentation across supported specification versions, as it cannot be assumed that all vendors update to the latest version of the spec at the same time, if at all.

This forces users to do unnecessary version migrations, or their models would be rejected by a tool as invalid or outdated even though language features used in the model may be perfectly supported by the tool. This issue has also been recognized by Specification Common Elements (SCE) in SCE-117.

With DMN shipping bugfixes on a yearly pace, the fragmentation of the tool market increases, while the actual number of changes to the XML schema decreases. In fact, DMN 1.6 has zero changes to the XML schema at all but if it would follow the "tradition", it would again declare itself totally incompatible with DMN 1.5 and all prior versions.

DMN 1.x revisions have been following the backwards compatibility guidelines for machine-readable files and XML schemas as defined in the OMG Policy for Versioning of Specification URIs, File URIs, and XML Namespaces (smsc/2018-08-01). Therefore, DMN 1.x revisions should not change the namespace URL until a version 2.0 introduces breaking changes, which is not planned at the moment.

The "tradition" to always change the namespace has somewhat accidentally grown:

• DMN 1.1 had to legitimately change the namespace because the XML serialization from DMN 1.0 was unimplementable and required breaking changes
• DMN 1.2 had to change the namespace because the one from DMN 1.1 did not conform to OMG's policy (due to last-minute bad advice from the technical director at the time)
• DMN 1.3 jumped on that to abuse it as a version indicator
• DMN 1.4 and DMN 1.5 followed to be "consistent with the scheme"

Defer to DMN 1.7

Defer to DMN 1.7