connective | agent-based reactive programming library for typescript | Reactive Programming library

You cannot define syntactic synonyms this way. When you define something like

There's no real answer possible here, other than: because that is how the author of the grammar defined the rules :)

Let's look at the following very simple grammar:

As you already surmised in a comment, your problem is that your token names clash with C keywords. Defining a token if in your yacc file will cause the generated C file to contain both a line like if = 258 (where 258 could of course be a different number) inside an enum declaration and #define if 258 afterwards. if = 258 is a syntax error of course and #define if 258 will cause errors anywhere where if is used as part of an actual if statement anywhere in the following code (because something like if(cond) would become 42(cond), which is a type error). The same goes for any other keywords.

The convention is for token names to be written in ALL_CAPS to avoid exactly this problem.

These problems all go away if you use a clean representation of your data.

In this case, it means that you shall, in complete analogy to how you represent all other entities systematically via different functors, also use a dedicated functor to represent (modal) variables.

For example, let us use the functor v/1 to represent variables. This means that we use v(1), v(7) etc. to represent the modal variables 1, 7 etc.

Instead of your "catch all" clause, I add the following clauses that state what holds about modal variables:

You problem seems a good fit for a recursive solution:

Suppose I write instead:

The meaning of equality constructed this way can be seen as a proof of existence of two functions: ∀ {A B : Set} (w : A × B) → ⟨ proj₁ w , proj₂ w ⟩ and ∀ {A B : Set} (w : A × B) → w, which must be proven to produce equal output for the same inputs.

In the first case the statement requires a proof that \ w -> ⟨ proj₁ w , proj₂ w ⟩ ≡ \ w -> w. Agda tells you there are no definitional equalities to conclude this from. One could argue that for a single-constructor types it would be possible to work out automatically, but you can see this is not so simple in general.

In the second case, given that pattern matching proves w ≡ ⟨ x , x₁ ⟩, you only need a proof that proj₁ ≡ \ ⟨ x , x₁ ⟩ -> x and proj₂ ≡ \ ⟨ x , x₁ ⟩ -> x₁, which are definitional equalities.

FParsec can handle infix operators using the OperatorPrecedenceParser class where you just need to specify which operators with which associativity and precedence you have, without having to actually write a grammar for your infix expressions. The rest of this answer will explain how to solve the problem without this class for cases where the class doesn't apply, for parser combinators that don't have an equivalent class or in case you just plain don't want to use it or are at least interested in how you'd solve the problem without it.

Parser combinators tend to not support left-recursion, but they do tend to support repetition. Luckily, a left-recursive rule of the form ::= | can be rewritten using the * repetition operator to ::= *. If you then left-fold over the resulting list, you can construct a tree that looks just like the parse tree you'd have gotten from the original grammar.

Although the return in the for loop in rec() is the specific issue, I believe the overall issue is you're making the problem harder than it needs to be. You're also being inconsistent in your handling of connectives, sometimes its a collection of characters, range(len(connectives)), sometimes its a single character, wff[i] == connectives[j]. Here's my simplification of your code: