Chapter 6

Working With Operators, Variables, and Assignments

When you create an object through an operator expression, or through other means such as a literal expression or a constructor expression, you lose access to that object for the rest of your program unless you use it as an operation argument, assign it to an attribute, or assign it to a variable. You've already learned about operations and attributes, so this chapter goes on to show you how to work with variables. You'll find detailed information about the syntax of declaration and assignment. You'll also get a close look at specifying a variable's type and determining the scope of a variable.

Operator Expressions

Arithmetic Operators

Some examples of operator expressions using arithmetic operators:

-872
6.43 + 9
92 - 3
25 * 4
7 / 3.5

-872
15.43
89
100
2.0.

Comparison Operators

Comparison operator expressions evaluate to a boolean, so they are either true or false.

Operator	Description
<	Less-than operator. Use it between two values to compare the first value to the second value. If the first value is before (less than) the second value, the expression evaluates to true. If the first value is equal to, after (greater than), or unordered with respect to to the second value, the expression evaluates to false.
>	Greater-than operator. Use it between two values to compare the first value to the second value. If the first value is after (greater than the second value, the expression evaluates to true. If the first value is equal to, before, or unordered with respect to the second value, the expression evaluates to false.
<=	Less-than-or-equal-to operator. Use it between two values to compare the first value to the second value. If the first value is before, equal to, or unordered with respect to the second value, the expression evaluates to true. If the first value is after the second value, the expression evaluates to false.
>=	Greater-than-or-equal-to operator. Use it between two values to compare the first value to the second value. If the first value is after, equal to, or unordered with respect to the second value, the expression evaluates to true. If the first value is before the second value, the expression evaluates to false.
==	Equal-to operator. Use it between two values to compare the first value to the second value. If the two values are equal, the expression evaluates to true. If the two values aren't equal, the expression evaluates to false. This operator isn't limited to ordered objects; it can check equality (as defined by the operation isEqual) between unordered objects. (Note that Telescript reserves a single equal sign (=) for assignments; you must use double equal signs as the equal-to operator.)
!=	Does-not-equal operator. Use it between two values to compare the first value to the second value. If the two values are not equal, the expression evaluates to true. If the two values are equal, the expression evaluates to false. This operator, like the equal-to operator, isn't limited to ordered objects.

Some examples of operator expressions using comparison operators:

3 < 8
3 > 8
3.14 <= 3.14
9 >= -5
9 == -5
9 != -5

true
false
true
true
false
true

Type-Checking Operator

An example of an operator expression using the is operator:

9 is Number

Another example:

9 is Number!

Logical Operators

Some examples of operator expressions using Boolean operators:

!(5 == 5)
4 < 5 && 5 < 2
4 < 5 || 5 < 2

The second expression evaluates to false because the expression on the left side of the operator evaluates to true, but the expression on the right side evaluates to false.

The third expression evaluates to true because the expression on the left side of the operator evaluates to true, and only one expression needs to be true for a true evaluation.

The expressions on the right side of the logical operator && or || are not evaluated if the expression on the left side is all that's needed to determine the result. In other words, if the left expression of && is false, the full expression must be false so the right expression isn't evaluated. And if the left expression of || is true, the full expression must be true so the right expression isn't evaluated. This is important to remember if you've called an operation in the right expression; it won't be called in some cases.

Operator Precedence

Operators with the highest priority within an expression are applied before operators with lower priorities. Once these operators are applied, operators of the next highest priority are applied. This continues until all the operators are applied.

To see how this works, consider the following expression:

6 + -8 * 2 == 12 / 2 - 10

6 + -16 == 6 - 10

-10 == -4

Using Parentheses

To see how this works, consider the following expression:

-((2+6)/2)

-2+6/2

An important note: Telescript doesn't specify the application order of equal-priority operators within parentheses. This means that you can't safely assume that one operator expression will be evaluated before another operator expression of equal priority--unless you enclose one of those operator expressions in parentheses.

An Overview of Variables

A variable is, simply put, an identifier that refers to an object. It's supported by Telescript's variable mechanism, which allows you--within a block of code--to first declare a variable and then assign a value to the variable. When you declare a variable, you create a unique identifier and specify the type of the objects to which the identifier can refer. You may then assign a value (an object) to the variable--as long as the value is a member of the specified type. Once assigned, you can reassign a new value to the variable any time, replacing the old value. You can use the variable within an expression; the expression is evaluated using the variable's current value.

Let's take a closer look at the mechanism that supports variables.

The Telescript Language's Unique Variables

C variables are declared to be one type or another because--among other things--the amount of memory allocated for the variable is important. If you declare a variable to be a type that requires only a single byte of memory (a character, for example) and then write a value that requires four bytes (a long integer, for example), only a single byte will be stored (if the compiler lets it pass). Chances are good that the value of the variable won't be at all what you intended it to be.

In Telescript, a variable does not have an address of a specific piece of memory; it has a reference to a value, which is an object that may be located anywhere in memory. The value object's location is of no concern to the programmer. You declare a type for a variable not to allocate memory, but to assure that you know what type of object you're working with when you use the object in later statements. If you assign a new value to the variable, the Telescript engine simply changes the variable's reference from the old value to the new value.

The power of the Telescript variable is that it can handle simple values in assignments such as cost = 3.45 and sum = cost + tax, and it can also handle more complex objects such as keeping track of and working with members of the classes Place, Agent, and other similar objects. In these cases a single variable refers to a complex value that contains many objects within.

<<<Note: The current version of the Telescript engine ignores type in variable assignment. If the compiler misses a conflict of type on variable assignment, the engine will let the assignment pass. So--for example--an Integer variable may refer to a real number without any squawks.>>>

Assignment

sahara = RainRecord();

sahara.addTally(.01);

Scope

(When an object is "dropped"--that is, it's no longer referred to--it eventually disappears. The Telescript engine's garbage-collection mechanism automatically deletes any unreferred-to objects from memory--a topic discussed in more advanced chapters of this book.)

Consider the sahara variable created in the previous example. When the variable is declared within a block, it's stored with that block as long as the block executes. Any statements that follow the declaration can use the variable. When the block finishes execution, the identifier sahara is dropped, as is the RainRecord object to which the variable refers. Because the identifier and the RainRecord object aren't processes, and because they aren't referred to by anything outside of the block, these two objects are deleted by the Telescript engine's garbage-collection mechanism, and can't be used outside of the block.

The Syntax of Declaration

Remember that the scope of a variable is the block within which it's declared. If you try to declare the same variable a second time within that block, the compiler will object.

Telescript declarations come in two varieties: explicit and implicit.

Explicit Type

temperature: Real;

Multiple Identifiers

temperature, speed, volume: Real;

Value Assignment

temperature: Real = 102 - 3.4;

You may only assign a single object in a declaration. You may, however, assign that single object to more than one variable if you use more than one identifier in the declaration as shown here:

temperature, speed, volume: Real = 98.6;

Implicit Type

temperature: = 98.6;

In a declaration with implicit type, you use identifiers and objects just as you do in the declarations with explicit type. That is, you can use multiple identifiers if you wish such as

temperature, speed, volume: = 98.6;

A declaration with implicit type is a convenient form of declaration that allows you to declare a variable without knowing exactly what type you need to specify. For example, this declaration of the variable price

price: = estimate

Explicit type declarations, on the other hand, allow you to specify a superclass of the value you assign, something you can't do with implicit type. For example, in this declaration

price: Number = 98.6;

Note that one drawback to using implicit type in an assignment is that it makes your code a little harder to read--you can't easily tell what type is specified for each variable. A second drawback is that if you get in the habit of using ": =" in declaration assignment, you may accidentally use it for a simple assignment and declare a new variable when you meant to use an existing variable.

Specifying a Type

When you explicitly specify a type, you use a class expression--a text string that gives the class name. If the class you specify is defined by a class family (such as List, for example), you must supply actuals in square braces ([]) following the class family name: List[Integer, Equal], for example. (Don't worry about class families for now; you'll read more details about families, formals, and actuals in Chapter 9.) The class you specify can be any of the built-in Telescript classes listed at the back of this book, or any custom classes that are in use when you declare the variable.

Because a variable's type may allow reference to objects of the type's subclasses, it's important to consider inheritance when you specify type. A good place to start is the beginning of Part Four of the Telescript Language Reference, which shows a class tree of built-in Telescript classes. Notice that if you specify the type Object, the variable you declare can refer to any object because Object is the root class of all other classes (except mix-ins, of course, which can't be instantiated anyway).

Once a variable is declared, you must be careful that you only assign it values that satisfy its type. If you try to assign a value that doesn't satisfy the type, the compiler won't accept the assignment.

Restricting a Type to Instance

route: Map;
locations: Map!

Declaring a Nil Option

cobalt: Real|Nil

One reason that a nil option is useful in declaration is that it allows you to check the value of a variable before it has been assigned. When the Telescript engine first creates a declared variable, it assigns the variable a nil value until you assign a value later. If you haven't declared the variable with a nil option, and then try to read the variable's pre-assignment value, the compiler will object so you won't be able to read its nil value.

The Syntax of Assignment

Assignment has a simple syntax: you give the variable's identifier, follow it with an equal sign, follow that with a value for assignment, and end with a semicolon. For example, this assignment statement sets the variable spot to refer to the character "Z":

spot = 'Z';

spot = point = location = 'Z';

It's important to make sure that the variables in an assignment are all declared somewhere in the code block before the assignment statement. It's also important to make sure that the object you assign to a variable satisfies the variable's type. If you forget either of these rules, the compiler will return errors when you try to compile your code.

When you use an assignment to assign an object to a variable, you can create a new object for the assignment, or you can use an existing object.

Creating an Object For Assignment

A constructor expression is simply a class name followed by a set of zero or more values within parentheses. A constructor expression asks the engine to create an instance of the class; the values in parentheses, called initialization values, are used to define the attributes of the newly initialized object. Initialization is a topic discussed in more detail in Chapter 8. For now, it's enough to know that the class descriptions in the Telescript Language Reference describe just what initialization values are necessary for instantiating each class. You'll find that many classes require no initialization values, in which case the parentheses are empty as in this assignment example:

sahara = RainRecord();

heartwood = RingCount(35, nil, 'A');

Using an Existing Object For Assignment

tab = 3;
count = tab;

count = tab = 3;

count = count + 3;

Determining the Scope of a Variable

There are a few wrinkles in the fabric of scope, however, caused by the fact that a block of code can contain nested blocks of code within it. If you declare a variable at the beginning of such a block, what happens to that variable within the nested blocks of code? The answer is that the variable persists within the nested blocks. This means that you can use the variable in expressions, assign it new objects, and treat it as you would in any block--all without redeclaring it. Any new assignments you make to the variable remain in effect when the execution of the nested block is finished. Consider, for example, the following code snippet:

{
	counter: Integer = 0;
	<a statement to make the following block loop 5 times>
	{
		<statements>
		counter = counter + 1;
		<statements>
	}
	executionTimes: = counter;
}

You can, if you wish, redeclare a variable within a nested block--that is, you declare a variable with the same identifier as a variable in the outer block. You can give the redeclared variable a new type and object assignment, and work with it as you wish. When the nested block finishes execution, the redeclared variable is dropped, and the original variable is restored for use in the outer block. To see how this works, consider the following example.

{
	counter: Integer = 73;
	<a statement to make the following block loop 5 times>
	{
		<statements>
		counter: Integer = 0;
		<statements>
	}
	howMany: = counter;
}

Interleaving Variable Declarations and Statements

Because variable declarations may be interleaved throughout a block, it's important to realize that the scope of a declared variable does not include any statements that precede the declaration in the block. If, for example, you declare a variable after five statements in the block, that variable is not available to the preceding five statements.

�����

Now that you understand operators and variables, it's time to move on to the next chapter, where you'll use them to write some real Telescript code.

6 - Working With Operators, Variables, and Assignments

Operator Expressions

Arithmetic Operators

Comparison Operators

Type-Checking Operator

Logical Operators

Operator Precedence

Using Parentheses

An Overview of Variables

The Telescript Language's Unique Variables

Assignment

Scope

The Syntax of Declaration

Explicit Type

Multiple Identifiers

Value Assignment

Implicit Type

Specifying a Type

Restricting a Type to Instance

Declaring a Nil Option

The Syntax of Assignment

Creating an Object For Assignment

Using an Existing Object For Assignment

Determining the Scope of a Variable

Interleaving Variable Declarations and Statements

Generated with Harlequin WebMaker