FEEL list functions: list contains, sum, count, sort, filter and more

FEEL guide · 26 built-in functions · DMN 1.6

Lists are how a DMN decision deals with more than one of anything: order lines, applicants, past claims. FEEL lists are ordered, can hold values of any type including null and other lists, and are never modified. Every list function returns a new list.

This guide covers every list built-in, plus the patterns you need around them: summing a field across a list of contexts, filtering out nulls before aggregating, and when to use list contains and when in. Each result was computed by the FEEL engine behind the evaluator at the top.

All FEEL list functions at a glance

Rules every list function follows

Positions are 1-based, and negative positions count from the end. A position must exist in the list: 0 or anything beyond the length is outside the function's domain, and the result is null. The same goes for a sublist length that runs past the end of the list.

A single value counts as a one-element list. Where a function expects a list, FEEL converts a single value into a list with that one element, so count("abc") is 1 and sum(5) is 5.

Aggregates do not skip nulls. sum, mean, min, max and the others return null if any element is null. Filter the list first with [item != null].

Summing and counting over a list of contexts

Decision inputs are usually lists of contexts, such as order lines with a price and a quantity. Selecting a field from a list of contexts gives the list of that field's values, so sum(lines.price) works directly. For anything more than one field, use a for expression, and add a filter to count only matching entries.

list contains, in and =

list contains(list, x) and the in operator both test membership, and both find a null element, because null = null is true. Neither converts types, so the string "2" is not found in a list of numbers. Numbers compare by value, so 1 and 1.0 are equal.

Combining lists: append, concatenate, union, flatten

append adds its arguments as elements, so appending a list nests it. concatenate joins lists end to end. union also joins them but drops duplicates. flatten removes nesting at every depth.

Function reference

Each function with its examples and edge cases. The heading links to the function's own page with its parameter table.

list contains

list contains(list, element)

Returns true if the list contains the element. Unlike the = operator, it can also test for null.

The element may be null, so list contains also tests whether a list has a null entry. Comparison is by value with no type conversion.

count

count(list)

Returns the number of elements in the list.

min

min(list) or min(c1, …, cN)

Returns the smallest element. All elements must be comparable with each other (numbers, strings, or temporal values).

max

max(list) or max(c1, …, cN)

Returns the largest element. All elements must be comparable with each other.

sum

sum(list) or sum(n1, …, nN)

Returns the sum of the numbers. The sum of an empty list is null.

sum takes either one list or several numbers as separate arguments. The two things that surprise people are that an empty list sums to null, not 0, and that one null element makes the whole sum null. Both matter when the list comes from a filter that can match nothing.

To sum a field across a list of contexts, select the field: sum(orders.amount). To sum a computed value, use for.

mean

mean(list) or mean(n1, …, nN)

Returns the arithmetic average of the numbers; null for an empty list.

median

median(list) or median(n1, …, nN)

Returns the median: the middle element of the sorted values, or the mean of the two middle elements for an even count.

stddev

stddev(list) or stddev(n1, …, nN)

Returns the sample standard deviation of the numbers.

mode

mode(list) or mode(n1, …, nN)

Returns the most frequent value(s) as a list; ties produce several results in ascending order.

all

all(list) or all(b1, …, bN)

Returns true if every element is true, false if any element is false, and null otherwise. all([]) is true.

all uses three-valued logic. A single false makes the result false, even if there are nulls. Otherwise any null makes it null. Elements that are not booleans also give null.

any

any(list) or any(b1, …, bN)

Returns true if at least one element is true, false if all are false, and null otherwise. any([]) is false.

sublist

sublist(list, start position, length?)

Returns the slice of the list starting at start position, running to the end or for length elements.

append

append(list, item…)

Returns a new list with the items added to the end.

concatenate

concatenate(list…)

Returns one list containing the elements of all argument lists, in order.

insert before

insert before(list, position, newItem)

Returns a new list with newItem inserted before the given position.

remove

remove(list, position)

Returns a new list with the element at the given position removed.

reverse

reverse(list)

Returns the list in reverse order.

index of

index of(list, match)

Returns the positions of all occurrences of match, as an ascending list of 1-based indexes.

union

union(list…)

Returns all elements of the argument lists with duplicates removed, preserving first-seen order.

distinct values

distinct values(list)

Returns the list with duplicate elements removed, preserving first-seen order.

duplicate values

duplicate values(list)

Returns the values that appear more than once in the list.

flatten

flatten(list)

Returns a flat list with all nested lists recursively expanded in place.

product

product(list) or product(n1, …, nN)

Returns the product of the numbers.

sort

sort(list, precedes)

Returns the list sorted by the precedes function.

The precedes function decides the order: it receives two elements and returns true if the first belongs before the second. To sort contexts, compare the field you want. To sort in descending order, use >.

DMN 1.6 lists both parameters without marking precedes optional. The engine behind this site also accepts sort(list) for comparable elements and sorts them ascending, but a portable model passes the function.

list replace

list replace(list, position | match, newItem)

Returns a new list with the element at the position, or every element accepted by the matcher function, replaced by newItem.

partition

partition(list, size)

Not part of the DMN 1.6 standard: an extension supported by the engine behind this site. A model that uses it may not run on other DMN engines.

Splits the list into consecutive chunks of the given size; the last chunk may be shorter.

How B-FEEL differs

In standard FEEL an invalid argument makes the result null. The business-friendly B-FEEL dialect returns a type default instead. Both columns were evaluated by the same engine:

More FEEL guides

FEEL string functions · FEEL numeric functions · FEEL date and time functions · Language constructs · Examples cheat sheet

Defined by the OMG DMN 1.6 specification, chapter 10.3.4 (built-in functions).