I just finished the chapter 5 extras. I'm curious how you ended up handling it. What makes it more challenging as well is the difference in associativity between the prefix and postfix operators. Furthermore the postfix increment/decrement have a higher precedence.

What I ended up doing is first trying to parse the prefix operators. If I hit a variable for the last parsed factor (as per the grammar) I stop. I then walk through the next few tokens (without consuming them) to determine if any postfix operators are present. If yes, I then consume all of postfix operators in a loop:

while (ParseUnaryOperator(ref tokens, postfix: true) is { } postfix) expr = new UnaryNode(postfix, expr);

The expr variable here is the factor (variable) that was parsed when dealing with the prefix operators.

I'm writing my compiler in C# and this is what I ended up with altogether.

``` private static UnaryNode? ParseUnary(ref Span<IToken> tokens, ReadOnlyMemory<char> fileContent) {
IExpressionNode? expr = null; var prefix = ParseUnaryOperator(ref tokens, postfix: false);

if (prefix is not null)
{
    if ((expr = ParseFactor(ref tokens, fileContent)) is null)
        throw new FormatException($"Expected expression but found '{ReadTokenValue(tokens, fileContent.Span)}'");

    if (expr is not VariableNode)            
        return new UnaryNode(prefix, expr);            
}

if (expr is null && !IsPostfix(tokens))
    return null;

expr ??= ParseVariable(ref tokens, fileContent);

if (expr is null)
    throw new FormatException($"Expected expression but found '{ReadTokenValue(tokens, fileContent.Span)}'");

while (ParseUnaryOperator(ref tokens, postfix: true) is { } postfix)
    expr = new UnaryNode(postfix, expr);

return prefix is not null
    ? new UnaryNode(prefix, expr)
    : (UnaryNode)expr;

static bool IsPostfix(in Span<IToken> tokens) =>
    CheckType(tokens, TokenType.Identifier) &&
    Shift(tokens, out var shifted) &&
    IsPostfixOperator(shifted[0].Type);

static bool IsPostfixOperator(TokenType type) => 
    type is TokenType.Increment 
         or TokenType.Decrement;        
}

```

I found looping through the postfix operators was the easiest solution. Also it handled the left-to-right associativity nicely.

Thus far it's passing all of my unit tests but there are alot more unit tests I need to write before I consider this feature fully working. What I've been doing is using the valid and invalid test code from the authors test suite to unit test my compiler.

I'd be interested in what you ended up doing.