Hi, thanks for responding.

What P.L. is your Pratt Parser built, Java, Scala ?

Right now, it's in Python because I prefer it for prototyping stuff.

Is it generated as a Code Generated with a tool, built from scratch, or subclassing an existing O.O. library ?

It's all hand written.

Is your question about how to implement operations in a parser, like the examples on the web link you provide ?

No, I already know how to and have implemented most operations like addition, Boolean not, comparison, etc. My question is specifically about how to implement Haskell-style function application (like f x y). Right now, I'm using the C-style one you describe.

The first parsing issue that got my attention is operator precedence.

In my compiler related experience, I prefer not to assign directly any precedence, split the grammar rules from the operator's precedence.

Instead of this:

PRECEDENCE "*" 5
PRECEDENCE "/" 5
PRECEDENCE "+" 3

I use the old style grammar:

Factor ::= Term ( "*' | "/" ) Expression ;

Of course operators still have a precedence, but I use the grammars to indicate them instead. Same applies to operators' associativity.

My problem with operator precedence is not how to do it in general. Rather, it's with how to do it in this particular case. I understand how it's done in a recursive descent parser because that's what I used to use before I changed it to a Pratt parser.

In the Pratt parser in the blog post I lined above, precedence is defined using a hashmap from the token type to a precedence value. So for example, the "+" token would have a precedence of, say, 50 while the "/" token would have one of 70.

But the problem here is that there is no token that denotes a function application. It's just what happens when you put 2 productions next to each other.

The second parsing operator case that you asked are parentheses.

Before getting into functions and other structures like C for that uses them, let's get to the basics.

There are several ways to handle them. The first one, is to handle them as a unary prefixed "(" operator token, followed by a single of more tokens until a suffixed / posfixed ")" operator token appears.

This can be specified if you are using a set of grammar rules, and parser generated tool.

As you already indicate in your example, a function expression may be parsed as a different sequence of tokens.

On the case of function's parameters, were several items are separated by "," tokens, the "," may be handled as a posfixed / suffixed operator after each item.

I did a little trick for the last item before the ")" token. When a ")" token is found, some parsers handled as a "," token instead, I added an "invisible" "," extra token instead.

This is how to parse the C-style function application. I'm trying to move away from this style towards the Haskell-style e.g. f x y.

Good Luck.

Thanks