Expressions

Expressions combine values using various operators to yield new values. For example, the very simple expression 1+2 uses the "+" operator to produce the value 3. SenseTalk provides a wide range of operators which serve many different needs.

The values used as components in expressions can be of many different types. They may be simple values, such as numbers or text strings (as described in Values), or they may be values that are the contents of containers (Containers). Still another type of value is one provided by a "function". A function is a source of value that retrieves information that may vary. SenseTalk provides many functions for a wide variety of purposes. This section describes how to use functions in SenseTalk expressions.

SenseTalk is a "typeless" language, so containers can store any type of value: numbers, text, dates, lists, etc. Values are automatically converted as needed, so, for example, if you perform a mathematical operation on a text value, SenseTalk will convert that value to a number internally. For converting internal values back into a text format, SenseTalk provides mechanisms that allow you to control the format used.

Precedence of Operators

Operators in complex expressions are evaluated in a specific order based on their precedence. The precedence of operators, from highest (those that are evaluated first) to lowest (those evaluated last) is as follows:

1st

( ) (expressions enclosed in parentheses are evaluated first)

2nd

(implicit concatenation – see below)

3rd

not - (unary minus, or negation)

4th

^ squared cubed % ago hence as

5th

* / div rem modulo joined by split by rounded to rounded to nearest

6th

+ - adding replacing removing retaining

7th

& && is a multiple of is divisible by

8th

&&&

9th

> < >= <= between contains is in is among is a is within

10th

= <> begins with ends with

11th

and and if

12th

or or if

When operators at the same level of precedence are used together in an expression, they are evaluated from left to right. In any case, parentheses can be used around a sub-expression to force that group to be evaluated before other parts of the expression (see Uses of Parentheses, below).

Implicit Concatenation

Implicit concatenation occurs when string literals, constants and certain predefined variables appear sequentially in an expression with no intervening operator. For example, this expression:

"Line 1" return "This is " "Line 2"

will produce the same result as:

"Line 1" & return & "This is " & "Line 2"

In addition to the constants (return, true, false, empty, up, down) the predefined variables available for implicit concatenation are: space, tab, quote, comma, slash, backslash, newline, linefeed, lf, carriagereturn, creturn, cr, crlf.

Uses of Parentheses

Parentheses are used for several different purposes in SenseTalk expressions.

Grouping Operations

Parentheses can be used to force operations to be performed in a particular order, or to resolve any ambiguity that might otherwise exist. For example, consider this ambiguous expression:

the square root of nine plus sixteen

If a friend asked you "What is the square root of nine-plus-sixteen?" you would promptly add nine and sixteen to get twenty-five and then take the square root and give the desired answer: "five" (you do that sort of thing all the time, right?). Or, they might ask the question with slightly different emphasis and a brief pause after the word "nine", as "What is the square-root-of-nine, plus sixteen?". In this case you would first take the square root of nine and then add that result to sixteen to get the desired answer: "nineteen".

In the case of a script, there are no vocal clues to tell a reader which of the two possible interpretations to give to this expression. The meaning appears to be ambiguous -- it could be interpreted either way. In fact, SenseTalk's rules of precedence will come into play, and it will evaluate the second way, giving a result of 19. If that wasn't what you intended, you'll need to use parentheses around the part of the expression that you want to be evaluated first:

the square root of (nine plus sixteen)

Readability is important in a script so that a reader of the script (including yourself at a later date) will be able to understand exactly what the script is doing. So even if the built-in rules give the answer you want, it may be a good idea to include parentheses to make it clear what was intended:

(the square root of nine) plus sixteen

Forcing Evaluation as an Expression

In certain contexts, a word will be treated as a literal value (the same as though it were in quotes). Enclosing such a word in parentheses forces it to be evaluated as an expression instead (specifically, as a variable name if it is a single word). This is most commonly used in the case of property names.

account.balance

This expression accesses the "balance" property of the account object. But suppose in your script you sometimes want to access the balance and at other times the availableBalance. Earlier in the script a decision is made about which type of balance to use:

set balanceToUse to "balance" -- use full actual balance unless withdrawing

if action is "withdrawal" then set balanceToUse to "availableBalance"

To access the balance you might try this:

account.balanceToUse

Unfortunately, this expression tries to access the property named "balanceToUse" of the account, which is the wrong name. To use the property name that is stored in the balanceToUse variable, use parentheses around the variable name to force it to be evaluated as an expression:

account.(balanceToUse)

Required Parentheses

Some expressions require the use of parentheses. For example, a list can be made by listing its items in parentheses, separated by commas. Other examples include property lists, function calls with multiple parameters, and the (if...then...else...) selector expression.

Vector Arithmetic with Lists

Vector arithmetic is supported. You can add or subtract two lists of numbers, provided they both have the same number of items. This will add or subtract the corresponding items of the two lists. Vector operations work with nested lists as well, provided that all corresponding sublists are of equal length.

put (1,2,3) + (100,200,300)-- (101,202,303)

Multiplication and division of lists also works for lists of equal length.

put (100,200,300) / (2,10,100)-- (50,20,3)

In addition, you can multiply or divide a list by a single value (sometimes called a ‘scalar’ because it scales all the values in the list).

put (1,2,3) * 6 -- (6,12,18)

Case Sensitivity

Text comparison operators are usually not case-sensitive, as in this example:

put "FLoWeR" is "flower" -- True

You can control the case-sensitivity of operations in two ways. Set the caseSensitive property to true or false to define whether by default uppercase and lowercase letters are treated differently or not. This property, which is local to each handler, is set to false at the beginning of each handler, so case will ordinarily be ignored.

For more information about the caseSensitive property, see Global and Local Properties for Working with Values.

Case-sensitivity can also be customized for each comparison, overriding the setting of thecaseSensitive property. To do this, specify considering case , with case, or case sensitive (to force case to be considered), or ignoring case, without case, or case insensitive (to force case to be ignored) for each operator:

put "FLoWeR" is "flower" considering case -- False

Operators and Functions

To understand how to use specific operators and functions in the expressions you plan to create, see the following topics:

Mathematical Operators

Comparison Operators

Logical Operators

Text Operators

Property List Operators

Date Operators

Miscellaneous Operators

Functions

Conversion of Values

Evaluating Expressions at Runtime

 

This topic was last updated on February 26, 2019, at 10:29:14 AM.

Eggplant icon Eggplant.io | Documentation Home | User Forums | Support | Copyright © 2019 Eggplant