|| 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 floating-point variables
{let a:float}                    || "a" is a float, initialized to 0.0f (default)
{let b:float=5}                  || "b" is a float, initialized to 5
{let c:float=5.0f}                || "c" is a float, initialized to 5.0f
{let d:float=5.5f}                || "d" is a float, initialized to 5.5f
{let e:float=-5.5f}               || "e" is a float, initialized to -5.5f
{let f:float=1234.1234f}          || "f" is a float, initialized to 1234.1234f
{let g:double}                   || "g" is a double, initialized to 0.0 (default)
{let h:double=123456.123456}     || "h" is a double, initialized to 123456.123456
{let i:double=12345678.12345678} || "i" is a double, initialized to 12345678.12345678

|| Display the floating-point 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}

|| 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}

|| Divide 0 by 0.
{value 0.0 / 0.0}

|| Divide 1 by 0.
{value 1.0 / 0.0}

|| Divide -1 by 0.
{value -1.0 / 0.0}

|| Divide 0 by 1.
{value 0.0 / 1.0}

|| See if 1 divided by 0 is infinity.
{value (1.0 / 0.0) == infinity}

|| 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 a character variable called "foo" that is
|| initialized with the value 'a'.
{let foo:char='a'}

|| Add two to the value of "foo".
{set foo = (foo + 2) asa char}

|| Return the value of "foo".
{value foo}

|| Subtract one from the value of "foo".
{set foo = (foo - 1) asa char}

|| Return the value of "foo".
{value foo}

|| Will cause an error
|| {set foo = '\u0000' - 1 asa char}

|| 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}