SPECIAL TOPIC

        SCL Operators

        SCL supports a wide range of expression operators.  The following
        table shows their relative precedence.  The closer to the top of the
        table an operator appears, the higher its precedence.

            ---------------------------------------------+---------------
                             operators                   |  associativity
            ---------------------------------------------+---------------
            !  ~  ++  --  -  #                           |  left to right      
            *  ?  %                                      |  left to right      
            +  -                                         |  left to right      
            <<  >>                                       |  left to right      
            <  <=  >  >=                                 |  left to right      
            ==  !=                                       |  left to right      
            &                                            |  left to right      
            ^                                            |  left to right      
            |                                            |  left to right      
            &&                                           |  left to right      
            ^^                                           |  left to right      
            ||                                           |  left to right      
            =  +=  -=  *=  /=  %=  &=  ^=  |=  <<=  >>=  |  right to left
            ---------------------------------------------+---------------

        Operator Functions

        Unary operators appear prefixed to the operand (i.e. on the
        immediate left hand of the operand to which it applies).  The
        exceptions are the increment (++) and decrement (--) operators which
        can appear as prefix or postfix operators.  

        Binary operators appear between operands.  All of the binary
        operators in SCL are left associative with the exception of the
        assignment operators.  This means that operators of like precedence
        are evaluated from left to right.  Parentheses can be used to alter
        the evaluation order.

        Operators are binary unless specifically noted as being unary.

                Arithmetic Operators:
                        -   unary negation
                        +   addition
                        -   subtraction
                        *   multiplication
                        /   division
                        %   mod
                        ++  unary increment (postfix or prefix)
                        --  unary decrement (postfix or prefix)

                Logical Operators
                        !   unary logical negation
                        &&  logical and
                        ^^  logical xor (exclusive or)
                        ||  logical or

                Bitwise operators
                        ~   unary inversion
                        <<  bitwise left shift
                        >>  bitwise right shift
                        &   bitwise and
                        ^   bitwise xor (exclusive or)
                        |   bitwise or

                Relational Operators
                        ==  equal
                        !=  not equal
                        <   less than
                        <=  less than or equal
                        >   greater than
                        >=  greater than or equal

                Assignment Operators
                        =   assignment
                        +=  add assignment
                        -=  subtract assignment
                        *=  multiply assignment
                        /=  divide assignment
                        %=  mod assignment
                        &=  bitwise and assignment
                        ^=  bitwise exclusive or assignment
                        |=  bitwise or assignment
                        <<= bitwise left shift assignment
                        >>= bitwise right shift assignment
