DivKit Expression DSL

Core concepts

Expression
— the base type for expressions producing a result of type T.
- build(): String — builds the “inner” DivKit expression without the "@{…}" wrapper.
- compile(): String — wraps the inner expression with "@{…}" for JSON serialization.
Expression types:
- Literals of types integer, number, string, and boolean.
- Variables Var<T>, created from a string name.
- Arithmetic operations: unary minus -, addition +, subtraction -, multiplication *, division /, remainder %`.
- Logical operations: negation !, logical and and, logical or or.
- Comparison: equality equalTo, inequality notEqualTo, greater than moreThan, less than lessThan, greater than or equal to moreThanOrEqualTo, less than or equal to lessThanOrEqualTo.
- String concatenation `+``.
- Ternary operator ifElse.
- Try operator tryExpression .
- Function call functionName(args...).
  Parentheses and escaping:
- Nested infix expressions, ternaries, and literal insertions are automatically parenthesized when necessary.
- String literals are enclosed in single quotes; an apostrophe is escaped as '.
- A number always has a decimal point (e.g., 1 → 1.0).
- Negative numbers are printed as (-1), (-2.5).

Important: do not call compile() inside other builds — it will break apostrophe escaping.

Literals

Integers

val one: Expression<Long> = 1.integer()
val one: Expression<Long> = 1L.integer()

Floating-point numbers

val one: Expression<Double> = 1.number()
val one: Expression<Double> = 1L.number()
val one: Expression<Double> = 1.0f.number()
val one: Expression<Double> = 1.0.number()

Important: the decimal point is always preserved (e.g., 1 → 1.0).

Strings

val text: Expression<String> = "text".string()

Escaping: "O'Reilly".string() produces "'O\'Reilly'"

Boolean

val isTrue: Expression<String> = true.boolean()
val isFalse: Expression<String> = false.boolean()

Using a literal expression

val expr = "1 + 2".literalExpression<Long>()

Variables

Referencing a variable:

val exprVariable: Var<Boolean> = "variable_name".booleanVariable()
val exprVariable: Var<String> = "variable_name".stringVariable()
val exprVariable: Var<Double> = "variable_name".numberVariable()
val exprVariable: Var<Long> = "variable_name".integerVariable()
val exprVariable: Var<Url> = "variable_name".urlVariable()
val exprVariable>(): Var<Map<String, Any>> = "variable_name".dictVariable<Any>()
val exprVariable: Var<Long> = "variable_name".datetimeVariable()
val exprVariable>(): Var<List<Any>> = "variable_name".arrayVariable<Any>()
val exprVariable: Var<Color> = "variable_name".colorVariable()
val exprVariable: Var<Url> = "variable_name".urlVariable()

Arithmetic operations

Includes prefix unary minus, numeric operations and string concatenation.

Prefix unary minus

operator fun Expression<Long>.unaryMinus(): Expression<Long>

Example:

val count = "count".integerVariable()
val result = -count

operator fun Expression<Double>.unaryMinus(): Expression<Double>

Example:

val amount = "amount".numberVariable()
val result = -amount

Addition

operator fun Expression<Long>.plus(other: Expression<Long>): Expression<Long>

Overloads:

operator fun Expression<Long>.plus(other: Int): Expression<Long>
operator fun Expression<Long>.plus(other: Long): Expression<Long>
operator fun Int.plus(other: Expression<Long>): Expression<Long>
operator fun Long.plus(other: Expression<Long>): Expression<Long>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a + b

operator fun Expression<Double>.plus(other: Expression<Double>): Expression<Double>

Overloads:

operator fun Expression<Double>.plus(other: Double): Expression<Double>
operator fun Expression<Double>.plus(other: Float): Expression<Double>
operator fun Expression<Double>.plus(other: Int): Expression<Double>
operator fun Expression<Double>.plus(other: Long): Expression<Double>
operator fun Double.plus(other: Expression<Double>): Expression<Double>
operator fun Float.plus(other: Expression<Double>): Expression<Double>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a + b

Subtraction

operator fun Expression<Long>.minus(other: Expression<Long>): Expression<Long>

Overloads:

operator fun Expression<Long>.minus(other: Int): Expression<Long>
operator fun Expression<Long>.minus(other: Long): Expression<Long>
operator fun Int.minus(other: Expression<Long>): Expression<Long>
operator fun Long.minus(other: Expression<Long>): Expression<Long>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a - b

operator fun Expression<Double>.minus(other: Expression<Double>): Expression<Double>

Overloads:

operator fun Expression<Double>.minus(other: Double): Expression<Double>
operator fun Expression<Double>.minus(other: Float): Expression<Double>
operator fun Expression<Double>.minus(other: Int): Expression<Double>
operator fun Expression<Double>.minus(other: Long): Expression<Double>
operator fun Double.minus(other: Expression<Double>): Expression<Double>
operator fun Float.minus(other: Expression<Double>): Expression<Double>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a - b

Multiplication

operator fun Expression<Long>.times(other: Expression<Long>): Expression<Long>

Overloads:

operator fun Expression<Long>.times(other: Int): Expression<Long>
operator fun Expression<Long>.times(other: Long): Expression<Long>
operator fun Int.times(other: Expression<Long>): Expression<Long>
operator fun Long.times(other: Expression<Long>): Expression<Long>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a * b

operator fun Expression<Double>.times(other: Expression<Double>): Expression<Double>

Overloads:

operator fun Expression<Double>.times(other: Double): Expression<Double>
operator fun Expression<Double>.times(other: Float): Expression<Double>
operator fun Expression<Double>.times(other: Int): Expression<Double>
operator fun Expression<Double>.times(other: Long): Expression<Double>
operator fun Double.times(other: Expression<Double>): Expression<Double>
operator fun Float.times(other: Expression<Double>): Expression<Double>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a * b

Division

operator fun Expression<Long>.div(other: Expression<Long>): Expression<Long>

Overloads:

operator fun Expression<Long>.div(other: Int): Expression<Long>
operator fun Expression<Long>.div(other: Long): Expression<Long>
operator fun Int.div(other: Expression<Long>): Expression<Long>
operator fun Long.div(other: Expression<Long>): Expression<Long>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a / b

operator fun Expression<Double>.div(other: Expression<Double>): Expression<Double>

Overloads:

operator fun Expression<Double>.div(other: Double): Expression<Double>
operator fun Expression<Double>.div(other: Float): Expression<Double>
operator fun Expression<Double>.div(other: Int): Expression<Double>
operator fun Expression<Double>.div(other: Long): Expression<Double>
operator fun Double.div(other: Expression<Double>): Expression<Double>
operator fun Float.div(other: Expression<Double>): Expression<Double>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a / b

Remainder

operator fun Expression<Long>.rem(other: Expression<Long>): Expression<Long>

Overloads:

operator fun Expression<Long>.rem(other: Int): Expression<Long>
operator fun Expression<Long>.rem(other: Long): Expression<Long>
operator fun Int.rem(other: Expression<Long>): Expression<Long>
operator fun Long.rem(other: Expression<Long>): Expression<Long>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result  = a % b

operator fun Expression<Double>.rem(other: Expression<Double>): Expression<Double>

Overloads:

operator fun Expression<Double>.rem(other: Double): Expression<Double>
operator fun Expression<Double>.rem(other: Float): Expression<Double>
operator fun Expression<Double>.rem(other: Int): Expression<Double>
operator fun Expression<Double>.rem(other: Long): Expression<Double>
operator fun Double.rem(other: Expression<Double>): Expression<Double>
operator fun Float.rem(other: Expression<Double>): Expression<Double>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result  = a % b

String concatenation

operator fun Expression<String>.plus(other: Expression<String>): Expression<String>

Example:

val hello = "Hello, ".string()
val username = "username".stringVariable()

val result = hello + username

Logical operations

Prefix negation

operator fun Expression<Boolean>.not(): Expression<Boolean>

Example:

val flag = "flag".booleanVariable()
val result = !flag

Logical AND

infix fun Expression<Boolean>.and(other: Expression<Boolean>): Expression<Boolean>

Overloads:

infix fun Expression<Boolean>.and(other: Boolean): Expression<Boolean>
infix fun Boolean.and(other: Expression<Boolean>): Expression<Boolean>

Example:

val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a and b

Logical OR

infix fun Expression<Boolean>.or(other: Expression<Boolean>): Expression<Boolean>

Overloads:

infix fun Expression<Boolean>.or(other: Boolean): Expression<Boolean>
infix fun Boolean.or(other: Expression<Boolean>): Expression<Boolean>

Example:

val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a or b

Comparison operations

Equality

infix fun Expression<Long>.equalTo(other: Expression<Long>): Expression<Boolean>

Overloads:

infix fun Expression<Long>.equalTo(other: Int): Expression<Boolean>
infix fun Expression<Long>.equalTo(other: Long): Expression<Boolean>
infix fun Int.equalTo(other: Expression<Long>): Expression<Boolean>
infix fun Long.equalTo(other: Expression<Long>): Expression<Boolean>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a equalTo b

infix fun Expression<Double>.equalTo(other: Expression<Double>): Expression<Boolean>

Overloads:

infix fun Expression<Double>.equalTo(other: Double): Expression<Boolean>
infix fun Expression<Double>.equalTo(other: Float): Expression<Boolean>
infix fun Expression<Double>.equalTo(other: Int): Expression<Boolean>
infix fun Expression<Double>.equalTo(other: Long): Expression<Boolean>
infix fun Double.equalTo(other: Expression<Double>): Expression<Boolean>
infix fun Float.equalTo(other: Expression<Double>): Expression<Boolean>
infix fun Int.equalTo(other: Expression<Double>): Expression<Boolean>
infix fun Long.equalTo(other: Expression<Double>): Expression<Boolean>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a equalTo b

infix fun Expression<String>.equalTo(other: Expression<String>): Expression<Boolean>

Overloads:

infix fun Expression<String>.equalTo(other: String): Expression<Boolean>
infix fun String.equalTo(other: Expression<String>): Expression<Boolean>

Example:

val a = "a".stringVariable()
val b = "b".stringVariable()

val result = a equalTo b

infix fun Expression<Boolean>.equalTo(other: Expression<Boolean>): Expression<Boolean>

Overloads:

infix fun Expression<Boolean>.equalTo(other: Boolean): Expression<Boolean>
infix fun Boolean.equalTo(other: Expression<Boolean>): Expression<Boolean>

Example:

val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a equalTo b

Inequality

infix fun Expression<Long>.notEqualTo(other: Expression<Long>): Expression<Boolean>

Overloads:

infix fun Expression<Long>.notEqualTo(other: Int): Expression<Boolean>
infix fun Expression<Long>.notEqualTo(other: Long): Expression<Boolean>
infix fun Int.notEqualTo(other: Expression<Long>): Expression<Boolean>
infix fun Long.notEqualTo(other: Expression<Long>): Expression<Boolean>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a notEqualTo b

infix fun Expression<Double>.notEqualTo(other: Expression<Double>): Expression<Boolean>

Overloads:

infix fun Expression<Double>.notEqualTo(other: Double): Expression<Boolean>
infix fun Expression<Double>.notEqualTo(other: Float): Expression<Boolean>
infix fun Expression<Double>.notEqualTo(other: Int): Expression<Boolean>
infix fun Expression<Double>.notEqualTo(other: Long): Expression<Boolean>
infix fun Double.notEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Float.notEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Int.notEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Long.notEqualTo(other: Expression<Double>): Expression<Boolean>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a notEqualTo b

infix fun Expression<String>.notEqualTo(other: Expression<String>): Expression<Boolean>

Overloads:

infix fun Expression<String>.notEqualTo(other: String): Expression<Boolean>
infix fun String.notEqualTo(other: Expression<String>): Expression<Boolean>

Example:

val a = "a".stringVariable()
val b = "b".stringVariable()

val result = a notEqualTo b

infix fun Expression<Boolean>.notEqualTo(other: Expression<Boolean>): Expression<Boolean>

Overloads:

infix fun Expression<Boolean>.notEqualTo(other: Boolean): Expression<Boolean>
infix fun Boolean.notEqualTo(other: Expression<Boolean>): Expression<Boolean>

Example:

val a = "a".booleanVariable()
val b = "b".booleanVariable()

val result = a notEqualTo b

More than

infix fun Expression<Long>.moreThan(other: Expression<Long>): Expression<Boolean>

Overloads:

infix fun Expression<Long>.moreThan(other: Int): Expression<Boolean>
infix fun Expression<Long>.moreThan(other: Long): Expression<Boolean>
infix fun Int.moreThan(other: Expression<Long>): Expression<Boolean>
infix fun Long.moreThan(other: Expression<Long>): Expression<Boolean>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a moreThan b

infix fun Expression<Double>.moreThan(other: Expression<Double>): Expression<Boolean>

Overloads:

infix fun Expression<Double>.moreThan(other: Double): Expression<Boolean>
infix fun Expression<Double>.moreThan(other: Float): Expression<Boolean>
infix fun Expression<Double>.moreThan(other: Int): Expression<Boolean>
infix fun Expression<Double>.moreThan(other: Long): Expression<Boolean>
infix fun Double.moreThan(other: Expression<Double>): Expression<Boolean>
infix fun Float.moreThan(other: Expression<Double>): Expression<Boolean>
infix fun Int.moreThan(other: Expression<Double>): Expression<Boolean>
infix fun Long.moreThan(other: Expression<Double>): Expression<Boolean>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a moreThan b

More than or equal to

infix fun Expression<Long>.moreThanOrEqualTo(other: Expression<Long>): Expression<Boolean>

Overloads:

infix fun Expression<Long>.moreThanOrEqualTo(other: Int): Expression<Boolean>
infix fun Expression<Long>.moreThanOrEqualTo(other: Long): Expression<Boolean>
infix fun Int.moreThanOrEqualTo(other: Expression<Long>): Expression<Boolean>
infix fun Long.moreThanOrEqualTo(other: Expression<Long>): Expression<Boolean>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a moreThanOrEqualTo b

infix fun Expression<Double>.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>

Overloads:

infix fun Expression<Double>.moreThanOrEqualTo(other: Double): Expression<Boolean>
infix fun Expression<Double>.moreThanOrEqualTo(other: Float): Expression<Boolean>
infix fun Expression<Double>.moreThanOrEqualTo(other: Int): Expression<Boolean>
infix fun Expression<Double>.moreThanOrEqualTo(other: Long): Expression<Boolean>
infix fun Double.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Float.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Int.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Long.moreThanOrEqualTo(other: Expression<Double>): Expression<Boolean>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a moreThanOrEqualTo b

Less than

infix fun Expression<Long>.lessThan(other: Expression<Long>): Expression<Boolean>

Overloads:

infix fun Expression<Long>.lessThan(other: Int): Expression<Boolean>
infix fun Expression<Long>.lessThan(other: Long): Expression<Boolean>
infix fun Int.lessThan(other: Expression<Long>): Expression<Boolean>
infix fun Long.lessThan(other: Expression<Long>): Expression<Boolean>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a lessThan b

infix fun Expression<Double>.lessThan(other: Expression<Double>): Expression<Boolean>

Overloads:

infix fun Expression<Double>.lessThan(other: Double): Expression<Boolean>
infix fun Expression<Double>.lessThan(other: Float): Expression<Boolean>
infix fun Expression<Double>.lessThan(other: Int): Expression<Boolean>
infix fun Expression<Double>.lessThan(other: Long): Expression<Boolean>
infix fun Double.lessThan(other: Expression<Double>): Expression<Boolean>
infix fun Float.lessThan(other: Expression<Double>): Expression<Boolean>
infix fun Int.lessThan(other: Expression<Double>): Expression<Boolean>
infix fun Long.lessThan(other: Expression<Double>): Expression<Boolean>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a lessThan b

Less than or equal to

infix fun Expression<Long>.lessThanOrEqualTo(other: Expression<Long>): Expression<Boolean>

Overloads:

infix fun Expression<Long>.lessThanOrEqualTo(other: Int): Expression<Boolean>
infix fun Expression<Long>.lessThanOrEqualTo(other: Long): Expression<Boolean>
infix fun Int.lessThanOrEqualTo(other: Expression<Long>): Expression<Boolean>
infix fun Long.lessThanOrEqualTo(other: Expression<Long>): Expression<Boolean>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()

val result = a lessThanOrEqualTo b

infix fun Expression<Double>.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>

Overloads:

infix fun Expression<Double>.lessThanOrEqualTo(other: Double): Expression<Boolean>
infix fun Expression<Double>.lessThanOrEqualTo(other: Float): Expression<Boolean>
infix fun Expression<Double>.lessThanOrEqualTo(other: Int): Expression<Boolean>
infix fun Expression<Double>.lessThanOrEqualTo(other: Long): Expression<Boolean>
infix fun Double.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Float.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Int.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>
infix fun Long.lessThanOrEqualTo(other: Expression<Double>): Expression<Boolean>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()

val result = a lessThanOrEqualTo b

Conditional operations

Ternary operator

fun Expression<Boolean>.ifElse(onMatch: Expression<Long>, onMismatch: Expression<Long>): Expression<Long>

Overloads:

fun Expression<Boolean>.ifElse(onMatch: Expression<Long>, onMismatch: Int): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Expression<Long>, onMismatch: Long): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Int, onMismatch: Expression<Long>): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Long, onMismatch: Expression<Long>): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Int, onMismatch: Int): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Long, onMismatch: Long): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Int, onMismatch: Long): Expression<Long>
fun Expression<Boolean>.ifElse(onMatch: Long, onMismatch: Int): Expression<Long>

Example:

val a = "a".integerVariable()
val b = "b".integerVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(a + 20, b - a)

fun Expression<Boolean>.ifElse(onMatch: Expression<Double>, onMismatch: Expression<Double>): Expression<Double>

Overloads:

fun Expression<Boolean>.ifElse(onMatch: Expression<Double>, onMismatch: Float): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Expression<Double>, onMismatch: Double): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Expression<Double>): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Expression<Double>): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Int): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Long): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Float): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Float, onMismatch: Double): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Int): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Long): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Float): Expression<Double>
fun Expression<Boolean>.ifElse(onMatch: Double, onMismatch: Double): Expression<Double>

Example:

val a = "a".numberVariable()
val b = "b".numberVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(a + 20, b - a)

fun Expression<Boolean>.ifElse(onMatch: Expression<String>, onMismatch: Expression<String>): Expression<String>

Overloads:

fun Expression<Boolean>.ifElse(onMatch: String, onMismatch: Expression<String>): Expression<String>
fun Expression<Boolean>.ifElse(onMatch: Expression<String>, onMismatch: String): Expression<String>
fun Expression<Boolean>.ifElse(onMatch: String, onMismatch: String): Expression<String>

Example:

val a = "a".booleanVariable()
val b = "b".booleanVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(a and b, a or b)

fun Expression<Boolean>.ifElse(onMatch: Expression<Boolean>, onMismatch: Expression<Boolean>): Expression<Boolean>

Overloads:

fun Expression<Boolean>.ifElse(
  onMatch: Boolean,
  onMismatch: Expression<Boolean>
): Expression<Boolean>

fun Expression<Boolean>.ifElse(
  onMatch: Expression<Boolean>,
  onMismatch: Boolean
): Expression<Boolean>

fun Expression<Boolean>.ifElse(onMatch: Boolean, onMismatch: Boolean): Expression<Boolean>

Example:

val success_message = "success_message".stringVariable()
val error_message = "error_message".stringVariable()
val condition = "condition".booleanVariable()

val result = condition.ifElse(success_message, error_message)

Try operator

Returns the left operand’s value; if its evaluation fails, returns the right operand’s value.

infix fun Expression<Long>.tryExpression(Expression<Long>): Expression<Long>

Overloads:

infix fun Expression<Long>.tryExpression(Int): Expression<Long>
infix fun Expression<Long>.tryExpression(Long): Expression<Long>
infix fun Int.tryExpression(Expression<Long>): Expression<Long>
infix fun Long.tryExpression(Expression<Long>): Expression<Long>
infix fun Int.tryExpression(Int): Expression<Long>
infix fun Long.tryExpression(Long): Expression<Long>

Example:

val missingInt = "missing_int".integerVariable()
val result = missingInt tryExpression 0

infix fun Expression<Double>.tryExpression(Expression<Double>): Expression<Double>

Overloads:

infix fun Expression<Double>.tryExpression(Double): Expression<Double>
infix fun Expression<Double>.tryExpression(Float): Expression<Double>
infix fun Double.tryExpression(Expression<Double>): Expression<Double>
infix fun Float.tryExpression(Expression<Double>): Expression<Double>
infix fun Float.tryExpression(Float): Expression<Double>
infix fun Double.tryExpression(Double): Expression<Double>

Example:

val missingNumber = "missing_number".numberVariable()
val result = missingNumber tryExpression 0.0

infix fun Expression<String>.tryExpression(Expression<String>): Expression<String>

Overloads:

infix fun Expression<String>.tryExpression(String): Expression<String>
infix fun String.tryExpression(Expression<String>): Expression<String>
infix fun String.tryExpression(String): Expression<String>

Example:

val missingString = "missing_string".stringVariable()
val result = missingString tryExpression "<missing>"

infix fun Expression<Boolean>.tryExpression(Expression<Boolean>): Expression<Boolean>

Overloads:

infix fun Expression<Boolean>.tryExpression(Boolean): Expression<Boolean>
infix fun Boolean.tryExpression(Expression<Boolean>): Expression<Boolean>
infix fun Boolean.tryExpression(Boolean): Expression<Boolean>

Example:

val missingBoolean = "missing_boolean".booleanVariable()
val result = missingBoolean tryExpression false

Function calls

Built-in DivKit functions are documented on a separate page..

function<T>(functionName: String, vararg args: Expression<*>): Expression<T>

Allows you to use an arbitrary function, including one declared in the layout.

Type-safe classes for colors and URLs

The Expression DSL uses specialized value classes Color and Url for working with colors and URLs, rather than strings. This ensures type safety and prevents passing incorrect values.

Note

Important: Use the color("...") and url("...") constructors to create color and URL values in expressions.

Color and URL variables

val backgroundColor = "bg_color".colorVariable()
val imageUrl = "image_url".urlVariable()

val card = divan {
    data(
        logId = "color_url_test",
        variables = listOf(
            divkitVariable(
                variable = backgroundColor,
                value = color("#FF0000")
            ),
            divkitVariable(
                variable = imageUrl,
                value = url("https://example.com/image.png")
            )
        ),
        div = text(
            fontSize = 16
        ).evaluate(
            textColor = backgroundColor.divanExpression(),
            background = image(
                imageUrl = imageUrl.divanExpression()
            )
        )
    )
}

Samples

Accessing a variable

val username = "username".stringVariable()

val card = divan {
    data(
        logId = "variable_test",
        variables = listOf(
            divkitVariable(
                variable = username,
                value = "User"
            )
        ),
        div = text(
            fontSize = 16
        ).evaluate(
            text = ("Hello, ".string() + username).divanExpression()
        )
    )
}

Serialization result:

{
  "card": {
    "log_id": "variable_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "@{'Hello, ' + greeting}",
          "font_size": 16
        }
      }
    ],
    "variables": [
      {
        "type": "string",
        "name": "username",
        "value": "User"
      }
    ]
  },
  "templates": {}
}

Theme support

const val THEME_LIGHT = "light"
const val THEME_DARK = "dark"

val theme = "theme".stringVariable()

val card = divan {
    data(
        logId = "theme_test",
        div = text(
            text = "Lorem ipsum",
            fontSize = 16
        ).evaluate(
            textColor = (theme equalTo THEME_LIGHT).ifElse(
                onMatch = color("#000000"),
                onMismatch = color("#FFFFFF")
            ).divanExpression()
        )
    )
}

Serialization result:

{
  "card": {
    "log_id": "theme_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "Lorem ipsum",
          "font_size": 16,
          "text_color": "@{(theme == 'light') ? '#000000' : '#FFFFFF'}"
        }
      }
    ]
  },
  "templates": {}
}

Calling a function

val priceFormat = "#,###.##".string()
val locale = "ru-RU".string()
val price = "price".integerVariable()

val card = divan {
    data(
        logId = "function_call_test",
        variables = listOf(
            divkitVariable(
                variable = price,
                value = 1000
            )
        ),
        div = text(
            fontSize = 16
        ).evaluate(
            text = (decimalFormat(price, priceFormat, locale) + " ₽".string()).divanExpression()
        )
    )
}

Serialization result:

{
  "card": {
    "log_id": "function_call_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "@{decimalFormat(price, '#,###.##', 'ru-RU') + ' ₽'}",
          "font_size": 16
        }
      }
    ],
    "variables": [
      {
        "type": "integer",
        "name": "price",
        "value": 1000
      }
    ]
  },
  "templates": {}
}

Updating variable values

val complexData = "complex_data".dictVariable<Any>()

val card = divan {
  data(
          logId = "variable_change_test",
          variables = listOf(
                  divkitVariable(
                          variable = complexData,
                          value = mapOf(
                                  "integer_param" to 10,
                                  "number_param" to 10.0,
                                  "string_param" to "Lorem ipsum",
                                  "boolean_param" to false
                          )
                  )
          ),
          div = text(
                  text = "Update data",
                  fontSize = 16,
                  actions = listOf(
                          action(
                                  logId = "update_integer_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "integer_param",
                                          value = integerValue(value = 20)
                                  )
                          ),
                          action(
                                  logId = "update_number_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "number_param",
                                          value = numberValue(value = 20.0)
                                  )
                          ),
                          action(
                                  logId = "update_string_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "string_param",
                                          value = stringValue(value = "Dolor sit amet")
                                  )
                          ),
                          action(
                                  logId = "update_boolean_param",
                                  typed = actionDictSetValue(
                                          variableName = complexData.name,
                                          key = "boolean_param",
                                          value = booleanValue(value = true)
                                  )
                          )
                  )
          )
  )
}

Serialization result:

{
  "card": {
    "log_id": "variable_change_test",
    "states": [
      {
        "state_id": 0,
        "div": {
          "type": "text",
          "text": "Update data",
          "actions": [
            {
              "log_id": "update_integer_param",
              "typed": {
                "type": "dict_set_value",
                "key": "integer_param",
                "value": {
                  "type": "integer",
                  "value": 20
                },
                "variable_name": "complex_data"
              }
            },
            {
              "log_id": "update_number_param",
              "typed": {
                "type": "dict_set_value",
                "key": "number_param",
                "value": {
                  "type": "number",
                  "value": 20.0
                },
                "variable_name": "complex_data"
              }
            },
            {
              "log_id": "update_string_param",
              "typed": {
                "type": "dict_set_value",
                "key": "string_param",
                "value": {
                  "type": "string",
                  "value": "Dolor sit amet"
                },
                "variable_name": "complex_data"
              }
            },
            {
              "log_id": "update_boolean_param",
              "typed": {
                "type": "dict_set_value",
                "key": "boolean_param",
                "value": {
                  "type": "boolean",
                  "value": 1
                },
                "variable_name": "complex_data"
              }
            }
          ],
          "font_size": 16
        }
      }
    ],
    "variables": [
      {
        "type": "dict",
        "name": "complex_data",
        "value": {
          "integer_param": 10,
          "number_param": 10.0,
          "string_param": "Lorem ipsum",
          "boolean_param": false
        }
      }
    ]
  },
  "templates": {}
}

Learn more

You can discuss topics of interest in the DivKit user community in Telegram: https://t.me/divkit_community_en.

DivKit Repository

Was the article helpful?

iOS

Built-in functions