I find myself wanting to do arithmetic operations and bitwise operations on enums all the time. Here's an example from my chess engine:
enum Piece {
Pawn, WhitePawn = Pawn, BlackPawn,
Knight, WhiteKnight = Knight, BlackKnight,
Bishop, WhiteBishop = Bishop, BlackBishop,
Rook, WhiteRook = Rook, BlackRook,
Queen, WhiteQueen = Queen, BlackQueen,
King, WhiteKing = King, BlackKing,
Empty, NPieces = Empty
};
I use this type as index in an array declared something like `uint64_t bb[NPieces]'. This is a bitboard representation of the position, where bb[WhitePawn] is the 64-bit integer whose bits indicate the presence or absence of a white pawn at each location. Then I can refer to the pawns of the side to move as `bb[Pawn + side_to_move]', where `side_to_move' is 0 for white and 1 for black (I have an enum for that too). The result of that sum is an int [I believe] and if I wanted to store it in a variable of type Piece I would have to cast it.
Another operation that I may want to do is loop over the piece types, which also requires arithmetic.
for (Piece piece = WhitePawn; piece != NPieces; piece = Piece(piece + 1))
It would be nice if I didn't have to fight the compiler to accept `++piece' as my increment.
In order to check if a piece is a pawn of either color, I can do `((piece & ~1) == Pawn)'.
I don't have much of a problem working within the language: I either define some operators to return Piece or I sometimes use `int' in places where `Piece' would be more expressive, so the compiler doesn't complain. But I can see how some people might feel that enums are too restrictive.