def test_objects_full():
_unify.add((Foo, Foo, dict), unify_object)
_unify.add((Bar, Bar, dict), unify_object)
_reify.add((Foo, dict), reify_object)
_reify.add((Bar, dict), reify_object)
assert unify_object(Foo(1, Bar(2)), Foo(1, Bar(var(3))), {}) == {var(3): 2}
assert reify(Foo(var('a'), Bar(Foo(var('b'), 3))),
{var('a'): 1, var('b'): 2}) == Foo(1, Bar(Foo(2, 3)))
def test_objects_full():
_unify.add((Foo, Foo, dict), unify_object)
_unify.add((Bar, Bar, dict), unify_object)
_reify.add((Foo, dict), reify_object)
_reify.add((Bar, dict), reify_object)
assert unify_object(Foo(1, Bar(2)), Foo(1, Bar(var(3))), {}) == {var(3): 2}
assert reify(Foo(var('a'), Bar(Foo(var('b'), 3))),
{var('a'): 1, var('b'): 2}) == Foo(1, Bar(Foo(2, 3)))
def test_unify_isinstance_list():
class Foo2(Foo): pass
x = var('x')
y = var('y')
f, g = Foo2(1, 2), Foo2(x, y)
_unify.add((Foo, Foo, dict), unify_object)
_reify.add((Foo, dict), reify_object)
assert unify(f, g, {})
assert reify(g, {x: 1, y: 2}) == f
def test_objects_full():
_unify.add((Foo, Foo, Mapping), _unify_object)
_unify.add((Bar, Bar, Mapping), _unify_object)
_reify.add((Foo, Mapping), _reify_object)
_reify.add((Bar, Mapping), _reify_object)
x, y = var(), var()
assert unify(Foo(1, 2), Bar(1), {}) is False
assert unify(Foo(1, Bar(2)), Foo(1, Bar(x)), {}) == {x: 2}
assert reify(Foo(x, Bar(Foo(y, 3))), {
x: 1,
y: 2
}) == Foo(1, Bar(Foo(2, 3)))
class SubFoo(Foo):
pass
assert unify(Foo(1, 2), SubFoo(1, 2), {}) is False
lcons_ = lcons
rcons_ = rcons
if isinstance(lcons, Iterator):
lcons, lcons_ = tee(lcons)
if isinstance(rcons, Iterator):
rcons, rcons_ = tee(rcons)
try:
s = yield _unify(car(lcons), car(rcons), s)
if s is not False:
s = yield _unify(cdr(lcons_), cdr(rcons_), s)
except ConsError:
yield False
else:
yield s
_unify.add((ConsPair, (ConsPair, MaybeCons), Mapping), _unify_Cons)
_unify.add((MaybeCons, ConsPair, Mapping), _unify_Cons)
@_reify.register(ConsPair, Mapping)
def _reify_Cons(lcons, s):
rcar = yield _reify(car(lcons), s)
rcdr = yield _reify(cdr(lcons), s)
yield construction_sentinel
yield cons(rcar, rcdr)
# Unfortunately, `multipledispatch` doesn't use `isinstance` on the arguments,
# so it won't use our fancy setup for `isinstance(x, ConsPair)` and we have to
# specify--and check--each `cons`-amenable type explicitly.
def _cons_unify(lcons, rcons, s):
if not is_cons(lcons) or not is_cons(rcons):
# One of the arguments is necessarily a `ConsPair` object,
# but the other could be an empty iterable, which isn't a
# `cons`-derivable object.
return False
s = unify(car(lcons), car(rcons), s)
if s is not False:
return unify(cdr(lcons), cdr(rcons), s)
return False
_unify.add((ConsPair, (ConsPair, list, tuple, Iterator, OrderedDict), dict),
_cons_unify)
_unify.add(((list, tuple, Iterator, OrderedDict), ConsPair, dict),
_cons_unify)
@_reify.register(ConsPair, dict)
def reify_cons(lcons, s):
rcar = reify(car(lcons), s)
rcdr = reify(cdr(lcons), s)
return cons(rcar, rcdr)
try: # noqa: C901
import unification
from packaging import version
if version.parse(unification.__version__) < version.parse("0.4.0"):
raise ModuleNotFoundError()
from unification.core import _reify, _unify, construction_sentinel, isvar
except ModuleNotFoundError:
pass
else:
def _unify_ExpressionTuple(u, v, s):
yield _unify(getattr(u, "_tuple", u), getattr(v, "_tuple", v), s)
_unify.add((ExpressionTuple, ExpressionTuple, Mapping), _unify_ExpressionTuple)
_unify.add((tuple, ExpressionTuple, Mapping), _unify_ExpressionTuple)
_unify.add((ExpressionTuple, tuple, Mapping), _unify_ExpressionTuple)
def _unify_KwdPair(u, v, s):
s = yield _unify(u.arg, v.arg, s)
if s is not False:
s = yield _unify(u.value, v.value, s)
yield s
_unify.add((KwdPair, KwdPair, Mapping), _unify_KwdPair)
def _reify_ExpressionTuple(u, s):
# The point of all this: we don't want to lose the expression
# tracking/caching information.
res = yield _reify(u._tuple, s)
def unifiable_with_term(cls):
_reify.add((cls, dict), reify_term)
_unify.add((cls, cls, dict), unify_term)
return cls
import theano.tensor as tt
from kanren.term import term, operator, arguments
from unification.core import _reify, _unify, reify
from ..meta import metatize
from ..unify import unify_MetaSymbol
from ..etuple import ExpressionTuple, etuplize
from .meta import TheanoMetaSymbol
tt_class_abstractions = tuple(c.base for c in TheanoMetaSymbol.base_subclasses())
_unify.add(
(TheanoMetaSymbol, tt_class_abstractions, dict),
lambda u, v, s: unify_MetaSymbol(u, metatize(v), s),
)
_unify.add(
(tt_class_abstractions, TheanoMetaSymbol, dict),
lambda u, v, s: unify_MetaSymbol(metatize(u), v, s),
)
_unify.add(
(tt_class_abstractions, tt_class_abstractions, dict),
lambda u, v, s: unify_MetaSymbol(metatize(u), metatize(v), s),
)
def _reify_TheanoClasses(o, s):
meta_obj = metatize(o)
return reify(meta_obj, s)
elif u != v:
return False
if s:
# If these two meta objects unified, and one has a logic
# variable as its base object, consider the unknown base
# object unified by the other's base object (if any).
# This way, the original base objects can be recovered during
# reification (preserving base object equality and such).
if isinstance(u.obj, Var) and v.obj:
s[u.obj] = v.obj
elif isinstance(v.obj, Var) and u.obj:
s[v.obj] = u.obj
return s
_unify.add((MetaSymbol, MetaSymbol, dict), unify_MetaSymbol)
_unify.add((MetaSymbol, tt_class_abstractions, dict),
lambda u, v, s: unify_MetaSymbol(u, MetaSymbol.from_obj(v), s))
_unify.add((tt_class_abstractions, MetaSymbol, dict),
lambda u, v, s: unify_MetaSymbol(MetaSymbol.from_obj(u), v, s))
_unify.add((tt_class_abstractions, tt_class_abstractions, dict),
lambda u, v, s: unify_MetaSymbol(MetaSymbol.from_obj(u),
MetaSymbol.from_obj(v), s))
def _reify_MetaSymbol(o, s):
if isinstance(o.obj, Var):
obj = s.get(o.obj, o.obj)
else:
obj = None
elif u != v:
return False
if s:
# If these two meta objects unified, and one has a logic
# variable as its base object, consider the unknown base
# object unified by the other's base object (if any).
# This way, the original base objects can be recovered during
# reification (preserving base object equality and such).
if isinstance(u.obj, Var) and v.obj:
s[u.obj] = v.obj
elif isinstance(v.obj, Var) and u.obj:
s[v.obj] = u.obj
return s
_unify.add((MetaSymbol, MetaSymbol, Mapping), unify_MetaSymbol)
def _reify_MetaSymbol(o, s):
if isinstance(o.obj, Var):
# We allow reification of the base object field for
# a meta object.
# TODO: This is a weird thing that we should probably reconsider.
# It's part of the functionality that allows base objects to fill-in
# as logic variables, though.
obj = s.get(o.obj, o.obj)
else:
# Otherwise, if there's a base object, it should indicate that there
# are no logic variables or meta terms.
# TODO: Seems like we should be able to skip the reify and comparison
# below.
def test_unify_nonstandard_object():
_unify.add((ast.AST, ast.AST, Mapping), _unify_object)
x = var()
assert unify(ast.Num(n=1), ast.Num(n=1), {}) == {}
assert unify(ast.Num(n=1), ast.Num(n=2), {}) is False
assert unify(ast.Num(n=1), ast.Num(n=x), {}) == {x: 1}
return res.outputs
apply.add((Op, ExpressionTuple), apply_Op_ExpressionTuple)
def _unify_etuplize_first_arg(u, v, s):
try:
u_et = etuplize(u, shallow=True)
yield _unify(u_et, v, s)
except TypeError:
yield False
return
_unify.add((Op, ExpressionTuple, Mapping), _unify_etuplize_first_arg)
_unify.add((ExpressionTuple, Op, Mapping),
lambda u, v, s: _unify_etuplize_first_arg(v, u, s))
_unify.add((Type, ExpressionTuple, Mapping), _unify_etuplize_first_arg)
_unify.add((ExpressionTuple, Type, Mapping),
lambda u, v, s: _unify_etuplize_first_arg(v, u, s))
def _unify_Variable_Variable(u, v, s):
# Avoid converting to `etuple`s, when possible
if u == v:
yield s
return
if not u.owner and not v.owner:
from kanren.term import operator, arguments
from unification.core import _reify, _unify, reify
from cons.core import _car, _cdr
from etuples import etuplize
from .meta import TFlowMetaSymbol
from ..meta import metatize
from ..dispatch import unify_MetaSymbol
tf_class_abstractions = tuple(c.base for c in TFlowMetaSymbol.base_subclasses())
_unify.add(
(TFlowMetaSymbol, tf_class_abstractions, Mapping),
lambda u, v, s: unify_MetaSymbol(u, metatize(v), s),
)
_unify.add(
(tf_class_abstractions, TFlowMetaSymbol, Mapping),
lambda u, v, s: unify_MetaSymbol(metatize(u), v, s),
)
_unify.add(
(tf_class_abstractions, tf_class_abstractions, Mapping),
lambda u, v, s: unify_MetaSymbol(metatize(u), metatize(v), s),
)
def _reify_TFlowClasses(o, s):
meta_obj = metatize(o)
return reify(meta_obj, s)
elif u != v:
return False
if s:
# If these two meta objects unified, and one has a logic
# variable as its base object, consider the unknown base
# object unified by the other's base object (if any).
# This way, the original base objects can be recovered during
# reification (preserving base object equality and such).
if isinstance(u.obj, Var) and v.obj:
s[u.obj] = v.obj
elif isinstance(v.obj, Var) and u.obj:
s[v.obj] = u.obj
return s
_unify.add((MetaSymbol, MetaSymbol, dict), unify_MetaSymbol)
_tuple__unify = _unify.dispatch(tuple, tuple, dict)
_unify.add((ExpressionTuple, (tuple, ExpressionTuple), dict),
lambda x, y, s: _tuple__unify(x, y, s))
_unify.add((tuple, ExpressionTuple, dict),
lambda x, y, s: _tuple__unify(x, y, s))
def _reify_MetaSymbol(o, s):
if isinstance(o.obj, Var):
# We allow reification of the base object field for
# a meta object.
# TODO: This is a weird thing that we should probably reconsider.
# It's part of the functionality that allows base objects to fill-in
def unifiable_with_term(cls):
_reify.add((cls, Mapping), reify_term)
_unify.add((cls, cls, Mapping), unify_term)
return cls
return False
# Unfortunately, `multipledispatch` doesn't use `isinstance` on the arguments,
# so it won't use our fancy setup for `isinstance(x, ConsPair)` and we have to
# specify--and check--each `cons`-amenable type explicitly.
def _cons_unify(lcons, rcons, s):
if not is_cons(lcons) or not is_cons(rcons):
# One of the arguments is necessarily a `ConsPair` object,
# but the other could be an empty iterable, which isn't a
# `cons`-derivable object.
return False
s = unify(car(lcons), car(rcons), s)
if s is not False:
return unify(cdr(lcons), cdr(rcons), s)
return False
_unify.add((ConsPair, (ConsPair, list, tuple, Iterator, OrderedDict), dict),
_cons_unify)
_unify.add(((list, tuple, Iterator, OrderedDict), ConsPair, dict), _cons_unify)
@_reify.register(ConsPair, dict)
def reify_cons(lcons, s):
rcar = reify(car(lcons), s)
rcdr = reify(cdr(lcons), s)
return cons(rcar, rcdr)