NAME
        operators

DESCRIPTION

        These are the operators availailable in LPC. They are listed
        in the order of precedence (low priority first):


        expr1 , expr2        Evaluate 'expr1' and then 'expr2'. The
                        returned value is the result of 'expr2'. The
                        returned value of 'expr1' is thrown away.

        var = expr        Evaluate 'expr', and assign the value to
                        'var'. The new value of 'var' is the result.

        var += expr        Assign the value of 'expr' + 'var' to 'var'.
                        This is mostly equivalent to "var = var + expr".

        var -= expr        Similar to '+=' above.
        var &= expr
        var |= expr
        var ^= expr
        var <<= expr
        var >>= expr
        var >>>= expr
        var *= expr
        var %= expr
        var /= expr
        var &&= expr
        var ||= expr

        expr1 ? expr2 : expr3
                        Evaluates 'expr1' and branches according to
                        its truth value. If it is true, the 'expr2' is
                        evaluated and returned as result, else
                        'expr3'.

        expr1 || expr2        The result is true if 'expr1' or 'expr2' is
                        true. 'expr2' is not evaluated if 'expr1' was
                        true.

        expr1 && expr2        The result is true i 'expr1' and 'expr2' is
                        true. 'expr2' is not evaluated if 'expr1' was
                        false.

        expr1 | expr2        The result is the bitwise or of 'expr1' and
                        'expr2'.
                        For arrays, the union set is computed: all elements
                        from <expr1> plus all those from <expr2> which
                        are not in <expr1>.

        expr1 ^ expr2        The result is the bitwise xor of 'expr1' and
                        'expr2'.
                        For arrays, the symmetric difference is computed:
                        all elements from <expr1> which are not in <expr2>,
                        plus all those from <expr2> which are not in <expr1>.

        expr1 & expr2        The result is the bitwise and of 'expr1' and
                        'expr2'.

                        For arrays and strings, the intersection set
                        (all elements resp. characters from expr1 which
                        which are also in the expr2) is computed.
                        Note: "aab" & "a" -> "aa"
                         but  ({ 'a','a','b' }) & ({ 'a' }) -> ({ 'a' })
                        Eventually the array behaviour will be changed
                        to match the string behaviour.

                        Intersecting an array with a mapping is equivalent
                        to intersecting the array with the indices of the
                        mapping: array & mapping = array & m_indices(mapping)

                        Mappings can be intersected with another mapping
                        or an array. The resulting mapping holds all
                        those entries from the first mapping, which are
                        also mentioned in the second mapping (as index)
                        resp. in the array.

        expr1 == expr2        Compare values. Valid for strings, numbers,
                              objects and closures.

        expr1 != expr1        Compare values. Valid for strings, numbers,
                              objects and closures.

        expr1 > expr2        Valid for strings and numbers.

        expr1 >= expr2        Valid for strings and numbers.

        expr1 < expr2        Valid for strings and numbers.

        expr1 <= expr2        Valid for strings and numbers.

        expr1 << expr2        Shift 'expr1' left by 'expr2' bits; the sign
                              bit is not preserved.

        expr1 >> expr2        Shift 'expr1' right by 'expr2' bits.
                        This shift preserves the sign of 'expr1'.

        expr1 >>> expr2        Shift 'expr1' right by 'expr2' bits.
                        This shift does not preserve the sign of 'expr1',
                        instead it shifts in 0 bits.

        expr1 + expr2        Add 'expr1' and 'expr2'. If numbers, then
                        arithmetic addition is used. If one of the
                        expressions are a string, then that string is
                        concatenated with the other value.
                        If the expressions are arrays, the result is
                        the right array appended to the left.
                        If the expressions are mappings of equal width,
                        the result is merger of the two mappings. If one
                        key exists in both mappings, the element from the
                        right mapping appears in the result. If the two
                        mappings are of different width, the result is
                        <expr1> if non-empty, and <expr2> otherwise.

        expr1 - expr2        Subtract 'expr2' from 'expr1'. Valid for
                        numbers, strings, arrays, mappings.
                        For arrays and strings, all occurrences of the
                        elements resp. characters in 'expr2' are removed
                        from 'expr1', and the result is returned.
                        For mapping, all occurances of elemens in 'expr1'
                        which have a matching key in 'expr2' are removed, and
                        the result is returned.

        expr1 * expr2        Multiply 'expr1' with 'expr2'.
                        If strings or arrays are multiplied with a number
                        (zero or positive), the result is a repetition of the
                        original string or array.

        expr1 % expr2        The modulo operator of numeric arguments.

        expr1 / expr2        Integer division.

        ++ var                Increment the value of variable 'var', and
                        return the new value.

        -- var                Decrement the value of variable 'var', and
                        return the new value.

        - var                Compute the negative value of 'var'.

        ! var                Compute the logical 'not' of an integer.

        ~ var                The boolean 'not' of an integer.

        ( type ) var    Return the value of <var> converted to <type>.
                        <type> can be 'string', 'int', 'object', 'float'
                        or 'int*'. <var> must be of a specific type
                        for a conversion to take place; if <var> is 'mixed'
                        or unknown, the cast is purely declarative.
                        Also, if the declared type of <var> is that of <type>,
                        the value is not changed.

                        NB. The literal number 0 is of unknown type, as
                        it doubles as 'not initialized' for strings, objects,
                        and arrays.

                        The operator acts like the efuns
                        to_string(), to_int(), to_object(), to_float()
                        and to_array(). It is advisable to use the
                        efuns directly instead of the cast.

        ({ type }) var  <var> is now assumed to have the type <type>.
                        This is purely declarative, the actual value
                        of <var> is not changed.

        var ++                Increment the value of variable 'var', and
                        return the old value.

        var --                Decrement the value of variable 'var', and
                        return the old value.

        expr1[expr2]        The array or mapping given by 'expr1' is
                        indexed by 'expr2'.

        expr1[expr2..expr3] Extracts a
                        piece from an array or string.
                        expr2 or expr3 may be omitted, default is the begin
                        or end of expr1.
                        Negative numbers for expr2 or expr3
                        mean ``count from before the beginning'', i.e.
                        foo[-2..-1] is an empty array or string.
                        foo[<2..<1] gives the 2nd and last element of
                        the array resp. chars of the string.

        expr1->name(...) The symbolic form of call_other(). 'expr1'
                        gives either an object or a string which is
                        used as the file_name of an object, and calls
                        the function 'name' in this object.

        ident::name(...)
                        Call the inherited function 'name' with the
                        given parameters in the parent 'ident'.
                        'ident' may be given as string containing the
                        full pathname, or as identifier containing the
                        pure basename.
                        If 'ident' is omitted, the last inherited
                        function of this 'name' is called.

        ({ })                Array constructor.
        ([ ])                Mapping constructor.

NOTE
        The closure operators are not described here.

HISTORY
        LDMud 3.2.9 added '>>>', '>>>=', '&&=' and '||='.
        LDMud 3.2.10 extended '&' to mappings.
        LDMud 3.3 extended '|' and '^' to arrays.

SEE ALSO
        arrays(LPC), alists(LPC), mappings(LPC), closures(LPC)