any() Function

Calls a rule or function that returns either true or false for each item in list by asking the question, "Do any items in this list yield true for this rule/function?" with the intent to discover if any item(s) yield true.

Parameters

any( predicate, list, context )

Returns

Boolean

Using the function

The following sections cover important details about the any() function.

List evaluation results

The any() function checks whether at least one item in the list parameter satisfies the condition defined by the predicate parameter, and returns a single Boolean result.

The any() function returns true as soon as an item in the list satisfies the condition. For example, the following expression returns true because user2 and user3 are members of the group referenced by cons!csaBuilding1.

1
2
3
4
5
any(
  a!isUserMemberOfGroup,
  {"user1", "user2", "user3"},
  cons!csaBuilding1
)

The any() function returns false only if no item in the list satisfies the condition. For example, the following expression returns false because none of the users are members of the group referenced by cons!csaBuilding1.

1
2
3
4
5
any(
  a!isUserMemberOfGroup,
  {"user4", "user5", "user6"},
  cons!csaBuilding1
)

If the list parameter is empty or null, the any() function returns false.

Using the predicate parameter

In the predicate parameter of any(), enter fn!functionName or a!functionName to reference an expression function, or rule!ruleName to reference a rule.

Using rules or functions with multiple arguments

To use rules or functions that take more than two arguments, use the merge() function. For example, given a rule g(x, y, z), reduce(rule!g, i, merge({a, b, c}, {d, e, f})) returns g(g(g(i, a, d), b, e), c, f).

Using the context parameter

The context parameter lets you pass fixed parameters that stay the same for each list item.

When the predicate parameter has more than two parameters, the context parameter provides the remaining ones. See Checking items with context for an example.

Unsupported functions

The any() function doesn't support a!forEach() in rules that you use as the predicate.

Examples

The following examples demonstrate the any() function.

To experiment with examples, copy and paste the expression into an expression rule and click TEST RULE to see the output.

Checking items in a list

This example checks whether any item in a list is populated, using a!isNotNullOrEmpty as the predicate.

1
2
3
4
any(
  a!isNotNullOrEmpty,
  {1, 2, null, 3, null, 4}
)

Returns true since the first value 1 was not null or empty.

Checking items in an empty list

This example shows how any() behaves when the list parameter is empty.

1
2
3
4
any(
  a!isNotNullOrEmpty,
  {}
)

Returns false.

Checking items with context

To help demonstrate how the context parameter works in looping expressions, let's look at an example.

Imagine you're building an expression that uses looping to analyze group membership in your application. You have four Group constants configured in the following ways:

The following expressions reference these constants to show how context works when checking items in a list.

Checking items in a list with context

This example uses the context parameter to pass a group into every evaluation of the predicate.

1
2
3
4
5
any(
  a!isUserMemberOfGroup,
  {"user1", "user2", "user3"},
  cons!csaBuilding1
)

Returns true. Since user2 and user3 are members of the group referenced by cons!csaBuilding1, the function returns true.

Checking all items in a list with context for more than two parameters

This example checks whether any user in a list belongs to all groups in a set. It passes two context values into a!isUserMemberOfGroup, which takes more than two parameters.

1
2
3
4
5
any(
  a!isUserMemberOfGroup,
  {"user1", "user2", "user3"},
  {cons!allGroups, true}
)

Returns true when user1 is a member of all the groups referenced in cons!allGroups. The a!isUserMemberOfGroup() function has 3 parameters: username, groups, and matchAllGroups. The any() list corresponds to username, and the list of values provided in the context parameter are used as the next two parameters, groups and matchAllGroups.

Checking all items in a list with context for more than two parameters which accept lists

This example uses merge() to pass list values through the context parameter, mapping each list to a predicate parameter.

1
2
3
4
5
any(
  a!isUserMemberOfGroup,
  {"user1", "user2", "user3"},
  merge({cons!csaAdmins, cons!csaProfs}, {true, true})
)

Returns true when user1 is a member of the groups referenced in cons!csaAdmins and cons!csaProfs. The merge() function maps the list values to the correct parameters in this example.

Checking a list with a custom expression rule

In this example, the any() function uses a helper rule, rule!isDateLater(value, referenceDate), which is defined as:

1
ri!value > ri!referenceDate

Example filter:

1
2
3
4
5
any(
  rule!isDateLater,
  {date(1950, 2, 3), date(1950, 6, 23), date(1950, 5, 2)},
  date(1950, 4, 7)
)

Returns true.

Feature compatibility

Feedback