Domain Prefixes

Overview

This page details the various domain prefixes used in Appian. Domain prefixes appear before the identifying name of certain functions, rules, data, etc. Between the prefix and name is an exclamation mark !, also referred to as a 'bang'.

Domain prefixes serve a couple of purposes:

  • Reference design objects and functions - In the appropriate context, domain prefixes are used to reference a design object or a function.
  • Invoke properties - In the appropriate context, domain prefixes are used to invoke a particular property.
  • Prevents name collisions - If functions, rules, or other properties are identically named, the domain prefix will define what Appian uses.

Domain prefixes are used anywhere someone can create an expression. However, certain prefixes are only used in certain contexts.

Best Practice: With the exception of the fn! domain, always use domain prefixes in your expressions.

After entering a domain prefix in an expression, a type ahead will begin to suggest the best matched function, object, or data point.

Function prefixes

There are two function domain prefixes in Appian: fn! and a!. When you type the a! or fn! domain into an expression and followed by a character, type ahead will suggest functions that map to the domain and character you entered. Always use the a! domain when you need to call various system, smart service, and connector functions as well as interface components.

Unlike the a! domain, the fn! domain is not required to call a related function, unless you are referencing a function within another function. For example, the all() function allows you to evaluate whether a given function or rule is true or false for each item in a list. As shown in the expression below, the fn function is required to reference the isnull() function within the all() function.

all(fn!isnull, {10, null, 30})

Object prefixes

Design objects also have a domain prefix that allows you to directly or indirectly reference a design object or invoke object properties. The following table list the various design objects with their prefixes.

Design Object Domain Prefix Reference Type Use Case
Constants cons! Indirect Use this domain to indirectly reference a design object. See Call a Constant from an Expression for more information.
Data Types type! Direct Use this domain to reference an Appian data type or custom data types. See Construction Data Type Values for examples on how to use this prefix. See Data prefixes for information on which data prefixes to use to invoke stored data values in an expression.
Decisions rule! Indirect Use this domain to indirectly reference an expression rule, an interface, a decision, and an integration. See Call a decision from another expression for more information.
Expression Rules rule! Indirect Use this domain to indirectly reference an expression rule, an interface, a decision, and an integration. See Call an expression rule from another expression for more information.
Integrations rule! Indirect Use this domain to indirectly reference an expression rule, an interface, a decision, and an integration. See Call an integration to query data for more information.
Interfaces rule! Indirect Use this domain to indirectly reference an expression rule, an interface, a decision, and an integration. See Interfaces as rules for more information.
Record Type Object recordType! Direct Use this domain to reference a record object type any any record list actions or related actions associated with the record type. See Referencing a record type from an expression for more information.

Direct and indirect object references

Direct object references are used to call an object directly into an expression or function. These references use the appropriate domain prefix for the design object followed by the name of the design object. If the object has rule inputs or properties, the direct object reference allows you to pass the inputs or properties into the expression as parameters.

Indirect object references are used for design objects that you cannot call directly into an expression. This reference type is helpful for calling objects that vary between environments and objects that are referenced in multiple design objects. For example, if you wants to assign a security group to multiple design objects and the group's access rights vary across environments, you could use a single constant to reference the security group and call it in each environment.

Data prefixes

You can use data prefixes to reference data types or invoke stored data values. Certain data prefixes are specific to a single object type while others can be used in multiple object types.

Multiple object prefixes

The following data prefixes can be used in multiple object types in Appian.

  • Rule Inputs - ri! Rule-based objects, like expression rules, interfaces, and decisions, let designers create rule inputs, which are invoked using the ri! prefix.

Single object prefix

The following prefixes can only be invoked in certain cases: within an object's expression editors (like process models or record types).

Do not reference these prefixes outside of their intended location. For example, do not try to use pv! or rf! directly on an interface. Instead create a rule input for those values and pass data in through the rule input.

Process only prefixes

Process models have several out-of-the-box domain prefixes that can be used from expression editors within the Process Modeler.

Process level prefixes
  • Process Model Properties - pm!
  • Process Properties - pp!
  • Process Variables - pv!
Node level prefixes
  • Activity Class Parameters - ac!
  • Task Properties - tp!
  • Message Properties - msg!

Record only prefixes

Record types have three domain prefixes that can be used to retrieve certain record data and properties.

  • Record Fields - rf!
  • Record Properties - rp!
  • Record Service Properties - rsp! Exclusively used in legacy expression-backed records created with Appian 19.4 and earlier to handle paging, searching, and filtering. The rsp! domain is no longer required to configure these record fields. See Record Data Source and User Filters for more information on the new, simpler configuration experience.

Appian recommends using rf! in record titles.

Web API only prefixes

Web APIs use the http! prefix to expose certain http properties when someone calls that web API.

Test prefixes

Test cases in Expression rules can use test!output to create test assertions based on the test's output.

Function-specific prefixes

Within certain functions, properties of that function can be called by using the following prefixes:

  • Local Variables - local! Through the a!localVariables(), load(), and with() functions designers can create local variables and call those local variables using the local! prefix.
  • Function Variables - fv! used within certain functions and interface components. The available function variables will be listed in the inline documentation.
  • Save Value - save! used within a!save() function.
Open in Github

On This Page

FEEDBACK