diff --git a/doc/LPC/operators b/doc/LPC/operators
new file mode 100644
index 0000000..18406a3
--- /dev/null
+++ b/doc/LPC/operators
@@ -0,0 +1,213 @@
+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 occurences 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)