boolexpr | Boolean Expressions | Cron Utils library

Personally, I'd just modify the grammar so that it has only one type of expression and therefore one type of parenthesis. I'm not convinced that the OData grammar is actually correct; it is certainly not usable in an LL(1) (or recursive descent) parser for exactly the reason you mention.

Specifically, if the goal is boolCommonExpr, there are two productions which can match the ( lookahead token:

This is precisely why people build high-level interfaces to SMT solvers. There are many choices here for z3:

• Official Python interface to z3: https://ericpony.github.io/z3py-tutorial/guide-examples.htm This is supported by Microsoft directly, and is probably the easiest to use.

• PySMT, which aims to cover as many SMT solvers as they can: https://github.com/pysmt/pysmt

• Scala bindings: https://github.com/epfl-lara/ScalaZ3

• Haskell SBV: http://hackage.haskell.org/package/sbv

• Many others at various maturity levels for Racket, Go, Lisp.. You name it. You can find many of them on github.

The goal of these "wrappers" is to precisely save the end-user from all the details of intricate bindings, and provide something much easier and less-error prone to use. On the flip side, they require you to learn yet another library. In my experience, if the host language of your choice has such an implementation, it'd pay off nicely to use it. If not, you should build one!

Your pattern matching is too specific. For example you write a clause:

The fundamental issue is that you're doing your simplify(tt ∧ b) test on unsimplified expressions.

The logic you're looking for would be more like:

This sounds very much like https://github.com/Z3Prover/z3/issues/1882

You might have to recompile/reinstall. Follow the instructions in that ticket.

You ask of your function to return a type T, then your pattern-match against Int and Boolean. Except your function has no evidence that Int and Boolean are also of type T: when you pattern-match, you introduce the constraint that Int <: T and Boolean <: T. You could either replace the return type T by a fixed type like String and return a String, or introduce a constraint that will satisfy both the case Int and Boolean.

Full join returns inner join tuples union unmatched left table tuples extended by nulls union unmatched right table tuples extended by nulls.

Currently your code outputs left join tuples. Each iteration of the outer loop outputs more tuples that are in the inner join or it outputs the null-extension of a left table tuple that did not match any right table tuple. To output full join tuples you must also output the null-extension of each right table tuple that did not match any left table tuple. You can do this as follows: Define a set variable before the loops. It will eventually contain all positions/indices for right table tuples that did not match any left table tuple. Immediately before the if compare, if it is the first iteration of the outer loop then insert the right tuple position/index into the set. Inside the if compare's nested block remove the right tuple position/index from the set.

For anyone coming across this problem in the future:
As rmunn said, the fact that I wanted the classes in different files was simply not good design. Also I did not need different AST nodes for BoolTerm, BoolAtom and BoolExpr as they could all be described as the same node BoolExpr.

My solution was to merge all of the boolean expression visitors into the same class (and merge all files for expression visitors into a single file):

If at the end of your program you add: