I'm creating my own external DSL, which I intend to be pretty small and include some basic functionality. When I compile my project, it builds successfully but it shows a lot of shift/reduce and reduce/reduce errors. And most of them are around my binary operators. Here is part of my code:

**ast.fs**

```
and Statement =
| ExpressionStatement of ExpressionStatement
| IfStatement of IfStatement
| IfElseStatement of IfElseStatement
and ExpressionStatement =
| Expression of Expression
| Nop
and Expression =
| ScalarAssignmentExpression of IdentifierRef * Expression
| Or of Expression * Expression
| And of Expression * Expression
| Equal of Expression * Expression
| NotEqual of Expression * Expression
| LessEqual of Expression * Expression
| Less of Expression * Expression
| GreaterEqual of Expression * Expression
| Greater of Expression * Expression
| Add of Expression * Expression
| Subtract of Expression * Expression
| Multiply of Expression * Expression
| Divide of Expression * Expression
| Modulus of Expression * Expression
| Exponent of Expression * Expression
| LeftShift of Expression * Expression
| RightShift of Expression * Expression
| RotateLeft of Expression * Expression
| RotateRight of Expression * Expression
| Xor of Expression * Expression
| IdentifierExpression of IdentifierRef
| FunctionCallExpression of Identifier * Arguments
// rest removed for brevity
```

**lexer.fsl**

```
// rest removed for brevity
rule tokenize = parse
| whitespace { tokenize.lexbuf }
| newline { lexbuf.EndPos <- lexbuf.EndPos.NextLine; tokenize lexbuf }
// rest removed for brevity
// Operators
| "==" { EQ }
| "!=" { NE }
| "<=" { LE }
| "<" { LT }
| ">=" { GE }
| ">" { GT }
| "&&" { AND }
| "||" { OR }
| "+" { PLUS }
| "-" { MINUS }
| "*" { TIMES }
| "/" { DIV }
| "%" { MOD }
| "**" { EXP }
| "<<" { LSHIFT }
| ">>" { RSHIFT }
| "<<<" { LROTATE }
| ">>>" { RROTATE }
| "^" { XOR }
// rest removed for brevity
```

Lastly, in my parser I have something like this:

```
// rest removed for brevity
%right ASSIGN
%left OR
%left AND
%left EQ NE
%nonassoc GT LT GE LE
%left RSHIFT LSHIFT RROTATE LROTATE XOR
%left PLUS MINUS
%left TIMES DIV MOD EXP
%nonassoc LBRACK
Statement:
| ExpressionStatement { ExpressionStatement($1) }
| IfStatement { IfStatement($1) }
| IfElseStatement { IfElseStatement($1) }
ExpressionStatement:
| Expression { Expression($1) }
Expression:
| IDENTIFIER ASSIGN Expression { ScalarAssignmentExpression($1, $3) }
| IDENTIFIER { IdentifierExpression($1) }
| IDENTIFIER Arguments { FunctionCallExpression($1, $2) }
| Expression EQ Expression { Equal($1, $2) }
| Expression NE Expression { NotEqual($1, $2) }
| Expression LE Expression { LessEqual($1, $2) }
| Expression LT Expression { Less($1, $2) }
| Expression GE Expression { GreaterEqual($1, $2) }
| Expression GT Expression { Greater($1, $2) }
| Expression AND Expression { And($1, $2) }
| Expression OR Expression { Or($1, $2) }
| Expression PLUS Expression { Add($1, $2) }
| Expression MINUS Expression { Subtract($1, $2) }
| Expression TIMES Expression { Multiply($1, $2) }
| Expression DIV Expression { Divide($1, $2) }
| Expression MOD Expression { Modulus($1, $2) }
| Expression EXP Expression { Exponent($1, $2) }
| Expression LSHIFT Expression { LeftShift($1, $2) }
| Expression RSHIFT Expression { RightShift($1, $2) }
| Expression LROTATE Expression { RotateLeft($1, $2) }
| Expression RROTATE Expression { RotateRight($1, $2) }
| Expression XOR Expression { Xor($1, $2) }
```

Any idea what might be the problem and how to solve it?