• improve performance by memoizing intermediate results within a transaction
• support anonymous variable '_'
• import pyDatalog files, as in Hy
• use pyrsistent to represent literals and clauses ?
• rewrite Engine using mochi ?
• methods to load facts when needed for a predicate, from csv or SQL data sources
• support for dictionary in expressions
• support pyMongo-like queries on relational databases, using a dictionary of criteria e.g. Employee.find({"salary": {"$lt": 5000}})
• align to open-source best practices
• support for equation solver : (X==Y+Z) <= (Y==X-Z)
• boolean function can be used as predicate in a body
• support active clauses to automatically insert facts, as in statelog :  +head <= body
• transactions with incremental error detection :  +(Employee.salary[X]==Y) => (0 <= Employee.salary[X]) | "Salary of {X} must be positive, not {Y}"
• convert Datalog to SQL when possible, for better performance
• calculated class attributes (with forward chaining)
• support Google Apps Engine's datastore
• use SLG resolution algorithm

• fix 'in' operator in 3.5 by releasing from master branch.

• promote previous release candidate

• upstage the release candidate version

• fix issue #13 : PyPi package wrong case in setup.py

• reset a predicate, for use in interactive consoles : p(X) <= None 

• Several fixes, including:
• issue #4 : max_ aggregate function had side effects on other clauses
• issue #6 : exceptions were raised in expressions that should not be evaluated
• changeset 59cd787: avoid confusion between similar heads of a functional clause
• add support for slices in pyDatalog programs and dynamic queries
• various code, performance and documentation improvements

• added support for unicode
• rank, running_sum now use group_by instead of for_each. Improved speed of aggregation
• literals can now have keyword arguments (e.g. parent(of=X, is_=Y) )

• hot fixes :
• fix the plan of resolution of functional clauses, so that the first, most general rule is always evaluated last
• fix initialization bug in Logic()
• support for python classes (e.g. str() ) in logic clauses.  Allow logic functions f[X] in the argument of python calls within logic clauses
• Examples:
• add graph.py to illustrate graph algorithms
• simplify queens_N.py
• illustrate how to interact with users in the tutorial

• support for calls to standard library in expressions (with bound variables) 
• make queries thread-safe
• support for expert systems, through ordered evaluation of the clauses defining a function (resolution stops after the first match)
• support for multiple logic models, through Logic()
• create_atoms() is replaced by create_terms()
• support for the power operator (e.g. X**2)
• del f[constant] removes any fact for f[constant]
• del f[X] removes any clauses for f[X]
• remove "six" dependency at installation
• small fixes and speed improvements:
• True and 1 should be 2 different constants
• the value extracted by >= X should be the same as X.v()for queries returning True
• add format_ atom 

• add pyDatalog.create_atoms() to support unprefixed inline queries and clauses
• use the _ prefix for _len, _sum, _min, _max to avoid name conflict with Python
• use ._in and ._not_in (instead of in and not in) to avoid name conflict with Python
• update examples to use create_atoms()
• various refactoring and bug fixes

• add example for mongoDB support
• fix issue with unreferenced pyDatalog.Mixin instances, by running garbage collector before accessing them
• fix "subscript out of range" error with some in-line conjunctive queries
• fix typo in console.py, which also broke datalog.py example

rename version 8.1  and 9.0 to 0.8.1 and 0.9.0 on pypi.  Build using these specific versions will need to be updated.

Include "Examples" directory in distribution

None, 0 and "":

• p[X]==None can now return values.  
• fix : p[X]==0 and p[X]=="" now return values

Syntax enhancements:

• support for p[X]<Y+Z, a.p[X]<Y+Z, and y==f[N-1].  Query results will have extra columns though.
• support for X in Y+Z, p[X] in Y+Z, a.p[X] in Y+Z.  Query results will have extra columns though.

Other:

• pyDatalog.variables(n) is a convenience function that creates n pyDatalog Variables (for use in in-line queries)
• raise an error if the right hand side of a comparison is unbound
• fix the issue with version number when importing pyDatalog
• fix: names starting with a '_' are now considered as Variables in pyDatalog program
• fix syntax error in '_example datalog.py" with python 3.2

• support of rank(for_each=X, order_by=Y)
• support of running_sum(N, for_each=X, order_by=Y)
• replace key by more meaningful names : sum(X, for_each=Y), concat(X, order_by=Y, sep=Z), min(X, order_by=Y), max(X, order_by=Y)

• support for conjunctive queries : E.p(X) & E.q(X,Y) 
• convenient access to the first variable value : X.v() and E.p(X) >= X

• 20 ... 25 % speed improvement
• support for predicate resolvers written in python

• detect more syntax errors in clauses and queries
• improved solution to the 8-queens problem

• add hook for other database connectors
• print Datalog error nicely
• fix rare "string indices must be integers, not Symbol" error
• accept "(X==Y)" where both are unbound
• accept empty string as constant
• pyDatalog.__version__ contains the version number

• allow function within expressions; support direct formula : a[X] == b[X]*2
• support 'X in range(n)' literals
• improve documentation
• interactive datalog console
• virtual attributes to python classes (e.g. Mary.salary_class)
• allow customisation of Answer class
• simplify code by eliminating lua engine

• support of function, i.e. predicate with unicity (e.g. father[x] == v is equivalent to father(x,v) with unicity per x)
• support for aggregation predicate (len, sum, concat, min, max)
• properly handle python queries with repeated variables (Employee.manager(X,X)) 
• fix for pyDatalog.clear()

• use the just-in-time compiler of pypy instead of lupa's.  Stop development on lua engine 
• support python objects in literals (python engine only)
• support query of relational database via SQLAlchemy
• support trace mode
• Do not accept python variables (starting with _) in pyDatalog.program anymore
• Equality predicate now accepts that both sides are bound
• Accept upper case for predicate initials
• new assert_fact() accepts python objects for terms

• support for negation

• support multi-line strings in pyDatalog.load()
• go beyond 4 operators in expressions : use lambda

• index the database of facts for improved performance
• make pyDatalog.clear() work

• add the datalog engine written in python. Use it by default
• use numeric type in results (instead of string types)
• tested with python 2.7 and 3.2

• rename "execute()" into "load()"
• avoid stack overflow due to deep recursion
• propose default datalog engine in the decorator, and add pyDatalog.ask(code), 

• add links to download in Pypi