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:
Domain prefixes are used anywhere you can create an expression. However, certain prefixes are only used in certain contexts.
Tip: 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.
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})
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 and any properties of the record type like fields, actions, filters, and relationships. See Reference a record type and its properties for more information. |
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 want 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.
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.
The following data prefix can be used in multiple object types in Appian:
Name | Prefix | Description | Level | Example |
---|---|---|---|---|
Rule Inputs | ri! |
Invokes rule inputs from rule-based objects, like expression rules, interfaces, and decisions. |
The following prefixes can only be invoked in certain cases: within an object's expression editors (like process models or record types).
Note: Do not reference these prefixes outside of their intended location. For example, do not try to use pv!
or rv!
directly on an interface. Instead, create a rule input for those values and pass data in through the rule input.
Process models have several out-of-the-box domain prefixes that you can use in expression editors in the Process Modeler. You can also use some of these prefixes when editing task report data columns. Learn more about process-only prefixes.
Record types have three domain prefixes that can be used to retrieve certain record variables, fields, and properties.
Name | Prefix | Description |
---|---|---|
Record Variables | rv! |
This domain prefix is always followed by This domain allows you to reference record values within the record type object itself:
|
Record Fields | rf! |
This prefix is not supported for record types created or updated in 20.3 and beyond. |
Record Properties | rp! |
This prefix is not supported for record types created or updated in 20.3 and beyond. |
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 default filters using expressions and user filters for record types that use a web service for more information on the new, simpler configuration experience. |
Note: See Reference record values in the record type for more information on how to use the rv!
domain.
Name | Prefix | Description |
---|---|---|
Web API properties | http! |
Use in Web APIs to expose certain http properties when someone calls that web API. |
Name | Prefix | Description |
---|---|---|
Test cases | test!output |
Use in expression rules to create test assertions based on the test's output. |
Within certain functions, properties of that function can be called by using the following prefixes:
Name | Prefix | Description |
---|---|---|
Local Variables | local |
Through the a!localVariables() function 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. |
Domain Prefixes