APL Data-Binding Syntax

Data-binding expressions

APL data binding expressions occur inside JSON strings and take the form "${expression}". Any number of expressions may occur inside a string, such as "${2}+${2} = ${2+2}". Expressions are evaluated within the current data-binding context. The data-binding context is a global dictionary that supports booleans, numbers, strings, arrays, objects, null, and references to defined resources.

Supported value types

String literals

Strings are defined using either single or double quotes. The starting and ending quote must match. Quotes, carriage returns, and line-feeds may be escaped.

	${"Double-quoted string"}
	${'Single-quoted string'}
	${"Inner quote: \" or '"}

Expressions may be nested inside of a string.

	${"Two plus two is ${2+2}"}

Numbers

Positive, negative, and floating point numbers are supported. Scientific notation is not supported. In JavaScript, all numbers are doubles.

Booleans

Boolean values of true and false are supported.

	${true}
	${false}

null

The null constant is supported.

	${null}

Resources

Resources defined in the data-binding context use the reserved character "@". For example:

${@myBlue}
${@isLandscape ? @myWideValue : @myNarrowValue}

APL packages define resources exposed in data-binding.

Truthy and Coercion

A truthy value is a value that is considered true when evaluated in a boolean context. All values are truthy except for false, 0, "", and null.

Operators

Arithmetics operators

The standard arithmetic operations for addition, subtraction, multiplication, division, and remainder are supported:

${1+2}  // 3
${1-2}  // -1
${1*2}  // 2
${1/2}  // 0.5
${1%2}  // 1.

The addition operator also acts as a string-concatenation operator if either the left or right operand is a string.

${27+""}      // '27'
${1+" dog"}   // '1 dog'
${"have "+3}  // 'have 3'

The remainder operator behaves as in JavaScript. That is,

${10 % 3}  // 1
${-1 % 2}  // -1
${3 % -6}  // 3
${6.5 % 2} // 0.5

Logical operators

The standard logical and/or/not operators are supported.

${true || false}   // true
${true && false}   // false
${!true}           // false

The && returns the first operand if it is not truthy and the second otherwise. The || operator returns the first operand if it is truthy and the second otherwise.

${7 && 2}    // 2
${null && 3} // null
${7 || 2}    // 7
${0 || -16}  // 0

Comparison Operators

Comparison operators return boolean values.

${1 < 2}
${75 <= 100}
${3 > -1}
${4 >= 4}
${myNullValue == null}
${(2>1) == true}
${1 != 2}

The comparison operators do not apply to arrays and objects.

The ?? operator is the null-coalescing operator. It returns the left-hand operand if the operand is not null, and otherwise it returns the right-hand operand.

${person.name ?? person.surname ?? 'Hey, you!'}

Ternary Operator

The ternary conditional operator ${a ? b : c} evaluates the left-hand operand. If it evaluates to true, the middle operand is returned. Otherwise the right-hand operand is returned.

${person.rank > 8 ? 'General' : 'Private'}

Array and Object access

Array

Array access uses the [] operator, where the operand should be an integer. Arrays also support the .length operator to return the length of the array. Accessing an element outside of the array bounds returns null.

${myArray[4]}     // 5th element in the array (0-indexed)
${myArray.length} // Length of the array
${myArray[-1])}   // Last element in the array

Passing a negative index counts backwards through the array.

${a[-1] == a[a.length - 1]}  // True

Object

Objects support the . operator and the [] array access operator with string values.

${myObject.name}    // The 'name' property of myObject
${myObject['name']} // The 'name' property of myObject

If the property is not defined, null is returned.

Calling the . or [] operator on null returns null.

${myNullObject.address.zipcode}  // Returns null