What would happen when lisp meets prolog in python? Dao and Dinpy arises!

[Simeon Chaos]

Dao is the new generation programming system implemented by a
functional logic solver,
unifying code with data, grammar with program, logic with functional,
compiling with running.

Would you please to have a look at my dao and dinpy?
http://pypi.python.org/pypi/daot
https://github.com/chaosim/dao

The feature of dao and dinpy:
* Mix functional and logic programming like prolog and lisp in python.
* A most powerful parser is provided, which have the power all of the
other parsers do not have. below is the list of some parser and
algorithms: parsec(haskell), packrat, earley parser, glr parser,
antlr, lex/yacc.
What's the magic behind the dao? See samples\sexpression.py and
testsexpression.py for a sample.

this is the key tips to the dao's dynamic grammar, which will become
a most powerful tool:

(sexpression, function(
# dynamic grammar arises!
([Result], and_p(char('{'), sexpression(Expr2), char('}'),
setvalue(Result,
eval_(pycall(sexpression2daoexpression, Expr2))))),

([Expr], atom_expression(Expr)),
([Expr], bracketExpression(Expr)),
([Expr], puncExpression(Expr))),

# the kernel of dynamic grammar
(eval_parse_result, function(
([Result], and_p(sexpression(Expr2), eoi,
is_(Result, eval_(pycall(sexpression2daoexpression,
Expr2))))))),