<<<, >>>, and |> should be left associative.

The bit shift operators are left associative in every language
I can think of where they exist. Similarly, the pipe operator is
left associative in F# which is where we seem to have taken
inspiration from.
The |> operator should sit between shift and relational operators in terms of precedence.

This most closely matches the way F# does it without breaking
a ton of already-written Elixir code.

* http://msdn.microsoft.com/en-us/library/dd233228.aspx
Equality operators should have lower precedence than other relational operators.

This is in line with C-like languages and has the benefit
that one can write the somewhat useful pattern:

    a > b == c < d
Bring precedence of bitwise operators in line with C.

These are inspired by C both in syntax and semantics, so
we should really try to make them act like the equivalent
operators in C.

In particular, &&& > ^^^ > ||| in terms of precedence.

Unlike C, however, we place these operators in the table
such that they have higher precedence than the relational
operators. This is to deal with an all-too-common mistake:

    if a &&& c != 0 do
        ...
    end

If we placed the operators the same place in the table as
C does, this would be interpreted as

    a &&& (c != 0)

which is clearly not what was intended!
Make the xor operator have lower precedence than ||.

It's important to realize that xor has wildly different
evaluation semantics than the other logical operators. It
will *always* evaluate the LHS and RHS. Therefore, it's a
bad idea to group it with the || operator.