|| Declare and initialize integer variables
{let a:int}                 || "a" is an int, initialized to 0 (default)
{let b:int=-5}              || "b" is an int, initialized to -5
{let c:int=5}               || "c" is an int, initialized to 5
{let d:int8=5}              || "d" is an int8, initialized to 5
{let e:int8=256 asa int8}   || "e" is an int8, initialized to 256
{let f:int16=5}             || "f" is an int16, initialized to 5
{let g:int32=5}             || "g" is an int32, initialized to 5
{let h:int64=5}             || "h" is an int64, initialized to 5
{let i:int=(2.7 asa int)}   || "i" is an int, initialized to 2.7

|| Display the integer variables' values
a is ... {value a}{br}
b is ... {value b}{br}
c is ... {value c}{br}
d is ... {value d}{br}
e is ... {value e}{br}
f is ... {value f}{br}
g is ... {value g}{br}
h is ... {value h}{br}
i is ... {value i}

{value
    || Declare an "int" variable called "a" and initialize
    || it with the value 2000000000 (within legal range).
    let a:int32 = 2000000000

    || Declare an "int" variable called "b" and initialize
    || it with the value 2000000000 (within legal range).
    let b:int32 = 2000000000

    || Declare an "int" variable called "c" and initialize
    || it with the sum of "a" and "b" (outside legal range).
    let c:int32 = a + b

    || Display the value of "c"
    c
}

|| Declare and initialize a couple of floating-point
|| numbers.
{let f1:float = 0.1f}
{let f2:float = 0.6f}

|| Remember that internally "f1" is represented by an
|| approximation of 0.1.  However, the display of "f1"
|| shows the approximation rounded up to 0.1
{value f1}

|| Because the numbers are internally represented by
|| approximations of the real numbers, when you add the
|| numbers you will not get the result that you expect.
|| However, because the difference is so small, the
|| display of the result will be rounded to the expected
|| value.
{value f1 + f2}

|| However, if you compare the actual result to the expected
|| result, they are not equal.  The equality operator (==)
|| returns "true" if the values are equal and "false"
|| otherwise.  Remember that the internal representation is not
|| the same as the rounded display of the number.
{value f1 + f2 == 0.7}

|| Declare and initialize Boolean variables
{let a:bool}       || "a" is a bool, initialized to false (default)
{let b:bool = true}  || "b" is a bool, initialized to true

|| Display the Boolean variables
a is ... {value a}{br}
b is ... {value b}

|| Declare and initialize character variables
{let foo:char}           || "foo" is a char, initialized to \u0000
                         || (the default)
{let bar:char='a'}       || "bar" is a char, initialized to 'a'
{let baz:char='\u0061'}  || "baz" is a char, initialized to \u0061

|| Display the character variables
foo is ... {value foo}{br}
bar is ... {value bar}{br}
baz is ... {value baz}

|| Declare "d1" a Distance variable and initialize it with
|| the value four inches.
{let d1:Distance = 4in}

|| Declare "d2" a Distance variable and initialize it with
|| the value ten meters.
{let d2:Distance = 10m}

|| Compare d1 and d2 display the greater value.
{if d1 > d2 then
    d1
 else
    d2
}
|| Note that meters, the default unit for Distance quantities,
|| are use to represent Distance quantities internally.
|| By default, a quantity is displayed with the default unit.

|| Define one speed.
{let s1:Speed = 15m / 2s}
|| Another way to write the same value:
{let s2:Speed = 7.5(m/s)}
|| Let's make a funny new quantity type that has no name.
{let speed-squared:{type-of 1(m^2/s^2)} = s1 * s2}

{value speed-squared}