def eval_expr(exp, env, out):
return conde(
(
eq([quote, out], exp),
no_item(out, is_internal),
missing(quote, env),
),
fresh(lambda lst: conjp(
eq([list_, lst, ...], exp),
missing(list_, env),
eval_list(lst, env, out),
)),
fresh(
5, lambda fn, arg, var, body, cenv: conj(
eval_list(exp, env, [fn, arg]),
conde(
eval_builtin(fn, arg, out),
(
eq(Closure(var, body, cenv), fn),
eval_expr(body, Env(var, arg, cenv), out),
),
))),
fresh(
2, lambda var, body: conjp(
eq([lambda_, [var], body], exp),
eq(Closure(var, body, env), out),
eqt(var, Symbol),
missing(lambda_, env),
)),
(eqt(exp, Symbol), lookup(exp, env, out)),
(builtin(exp, out), missing(exp, env)),
)
def generate_fn():
q = Var()
a = Symbol("a")
env = Env(Symbol("cadr"), Closure(a, [car, [cdr, a]], ()), ())
p = conj(no_item(q, lambda a: isinstance(a, int)),
eval_expr([q, [quote, [1, 2, 3]]], env, [1, 2]))
for s in run(5, q, p):
print(format_sexpr(s))
def lookup(o, v, x):
return fresh(
3, lambda a, b, t: conj(
eq(o, ((a, b), t)),
conde(
[eq(a, v), eq(b, TMono(x))],
fresh(
3, lambda po, pb, pm: conjp(
eq(a, v),
eq(b, TPoly(po, pb)),
infer(pb, po, x, pm),
)),
[neq(a, v), lookup(t, v, x)],
)))
def main():
states = Var()
big = Var()
small = Var()
_ = Var()
__ = Var()
for i in range(1, BIG + 1):
p = conjp(eq([(big, small, _), __, ...], states),
disj(
eq(big, i),
conj(neq(big, i), eq(small, i)),
), jugs(states))
for answer in run(1, states, p):
print("{}:".format(i))
for b, s, a in reversed(answer):
print(b, s, a)
print()
def solve():
solutions = {}
states = Var()
big = Var()
small = Var()
_ = Var()
__ = Var()
for i in range(1, BIG + 1):
p = conjp(
eq([(big, small, _), __, ...], states),
disj(
eq(big, i),
conj(neq(big, i), eq(small, i)),
),
jugs(states)
)
for answer in run(1, states, p):
solutions[i] = list(reversed(answer))
return solutions
from mk.core import conj, eq
from mk.dsl import conjp
from mk.ext.tuples import no_item
from mk.run import initial, reify
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
Tuple = namedtuple("Tuple", "x, y")
GOALS_DATA = [
(eq(a, ()), a, [()]),
(eq(a, (1, )), a, [(1, )]),
(conj(eq(a, (b, )), eq(b, 1)), a, [(1, )]),
(eq(a, (a, )), a, []),
(conjp(eq(a, (1, )), eq(b, (1, )), eq(a, b)), a, [(1, )]),
(conjp(eq(a, (1, )), eq(b, (2, )), eq(a, b)), a, []),
(conjp(eq(a, (1, )), eq(b, (1, 2)), eq(a, b)), a, []),
(conjp(eq(a, (1, )), eq(b, ()), eq(a, b)), a, []),
(conj(eq(a, Tuple(1, 2)), eq(a, Tuple(1, 2))), a, [Tuple(1, 2)]),
(conj(eq(a, Tuple(1, 1)), eq(a, Tuple(1, 2))), a, []),
(conj(eq(a, Tuple(1, 2)), eq(a, (1, 2))), a, []),
(no_item((1, 2, 3), lambda v: v == 0), None, [None]),
(no_item((1, 2, 3), lambda v: v == 1), None, []),
(conj(no_item(a, lambda v: v == 0), eq(a, (1, 2, 3))), None, [None]),
(conj(no_item(a, lambda v: v == 1), eq(a, (1, 2, 3))), None, []),
(no_item((1, (1, 2), (1, 2, (1, 2, 3))), lambda v: v == 0), None, [None]),
(no_item((1, (1, 2), (1, 2, (1, 2, 3))), lambda v: v == 3), None, []),
]
a = Var()
b = Var()
c = Var()
GOALS_DATA = [
(add(1, 2, a), [{
a: 3
}]),
(add(1, a, 3), [{
a: 2
}]),
(add(a, 2, 3), [{
a: 1
}]),
(conj(add(1, a, b), eq(a, 2)), [{
a: 2,
b: 3
}]),
(conj(add(a, 2, b), eq(a, 1)), [{
a: 1,
b: 3
}]),
(conj(add(a, b, 3), eq(a, 1)), [{
a: 1,
b: 2
}]),
(conj(conj(add(a, b, c), eq(a, 1)), eq(b, 2)), [{
a: 1,
b: 2,
c: 3
import pytest
from mk.core import conj, eq
from mk.dsl import conjp
from mk.ext.lists import no_item
from mk.run import initial, reify
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
GOALS_DATA = [
(eq(a, []), a, [[]]),
(eq(a, [1]), a, [[1]]),
(conj(eq(a, [b]), eq(b, 1)), a, [[1]]),
(eq(a, [a]), a, []),
(conj(eq(a, [b]), eq(b, [1, 2])), a, [[[1, 2]]]),
(conj(eq(a, [0, b]), eq(b, [1, 2])), a, [[0, [1, 2]]]),
(conj(eq(a, [b, ...]), eq(b, [1, 2])), a, [[1, 2]]),
(conj(eq(a, [0, b, ...]), eq(b, [1, 2])), a, [[0, 1, 2]]),
(conjp(eq(a, [1]), eq(b, [1]), eq(a, b)), a, [[1]]),
(conjp(eq(a, [1]), eq(b, [2]), eq(a, b)), a, []),
(conjp(eq(a, [1]), eq(b, [1, 2]), eq(a, b)), a, []),
(conjp(eq(a, [1]), eq(b, []), eq(a, b)), a, []),
(eq([1], [1]), None, [None]),
(conj(eq(a, [1]), eq(a, [1])), a, [[1]]),
(conj(eq(a, [1]), eq([1], a)), a, [[1]]),
(eq(a, 1), zzz(lambda: zzz_goal(2, b))),
(eq(a, 2), zzz(lambda: zzz_goal(3, b)), eq(a, b))
)
@delay
def delay_goal(a, b):
return conde(
eq(b, (1, a)),
(eq(a, 1), delay_goal(2, b)),
(eq(a, 2), delay_goal(3, b), eq(a, b))
)
GOALS_DATA = [
(conj(eq(a, 1), fresh(lambda x: conj(eq(a, x), eq(x, c)))), c, [1]),
(
conj(
eq(a, 1),
fresh(2, lambda x, y: conj(eq((x, y), (a, 2)), eq(c, (x, y))))
),
c,
[(1, 2)]
),
(conjp(eq(a, 1), eq(b, 2), eq(c, (a, b))), c, [(1, 2)]),
(conjp(disjp(eq(a, 1), eq(a, 2), eq(a, 3)), eq(c, a)), c, [1, 3, 2]),
(
conde(
(eq(a, 1), eq(b, 2), eq(c, a)),
(eq(a, 2), eq(b, 3), eq(c, b)),
eq(c, 5),
import pytest
from mk.core import conj, disj, eq, eqt
from mk.run import initial
from mk.stream import unfold
from mk.unify import Var, convert
a = Var()
b = Var()
GOALS_DATA = [
(eq(a, 1), [{a: 1}]),
(disj(eq(a, 1), eq(a, 2)), [{a: 1}, {a: 2}]),
(conj(eq(a, 1), eq(a, 1)), [{a: 1}]),
(conj(eq(a, 1), eq(a, 2)), []),
(eqt(a, int), [{}]),
(conj(eq(a, 1), eqt(a, int)), [{a: 1}]),
(conj(eqt(a, int), eq(a, 1)), [{a: 1}]),
(conj(eq(a, 1), eqt(a, str)), []),
(conj(eqt(a, str), eq(a, 1)), []),
(conj(eqt(a, int), eqt(a, int)), [{}]),
(conj(eqt(a, int), eqt(a, str)), []),
(conj(conj(eqt(a, int), eqt(b, int)), eq(a, b)), [{a: b}]),
(conj(conj(eqt(a, int), eqt(b, str)), eq(a, b)), []),
(conj(conj(eq(a, [1]), eq(b, 1)), eq(a, [b])), [{a: convert([1]), b: 1}]),
(conj(conj(eq(a, [b]), eq(b, 1)), eq(a, [1])), [{a: convert([b]), b: 1}]),
(conj(conj(eq(a, [b]), eq(b, 1)), eq(a, [2])), [])
import pytest
from mk.core import conj, eq, eqt
from mk.disequality import neq, neqt
from mk.run import initial
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
GOALS_DATA = [
(neq(a, 1), [{}]),
(conj(eq(a, 1), neq(a, 2)), [{a: 1}]),
(conj(eq(a, 1), neq(a, 1)), []),
(conj(neq(a, 1), eq(a, 1)), []),
(conj(conj(eq(a, 1), neq(a, b)), eqt(b, str)), [{a: 1}]),
(neqt(a, int), [{}]),
(conj(eq(a, 1), neqt(a, str)), [{a: 1}]),
(conj(eqt(a, int), neqt(a, str)), [{}]),
(conj(eq(a, 1), neqt(a, int)), []),
(conj(eqt(a, int), neqt(a, int)), []),
(conj(neqt(a, int), eq(a, 1)), []),
(conj(neqt(a, int), eqt(a, int)), []),
]
@pytest.mark.parametrize("goal, expected", GOALS_DATA)
def test_disequality(goal, expected):
assert [s for s, _, _ in unfold(goal(initial()))] == expected
def lookup(var, env, out):
return fresh(
3, lambda rest, sym, val: conj(
eq(Env(sym, val, rest), env),
conde((eq(sym, var), eq(val, out)),
(neq(sym, var), lookup(var, rest, out)))))
import pytest
from mk.core import conj, eq
from mk.deferred import predicate, relation
from mk.dsl import conjp
from mk.run import initial
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
GOALS_DATA = [
(conj(eq(a, 1), predicate(a, lambda a: a > 0)), [{
a: 1
}]),
(conj(predicate(a, lambda a: a > 0), eq(a, 1)), [{
a: 1
}]),
(conj(eq(a, 0), predicate(a, lambda a: a > 0)), []),
(conj(predicate(a, lambda a: a > 0), eq(a, 0)), []),
(predicate(a, lambda a: a > 0), [{}]),
(conjp(eq(a, 1), eq(b, 0), relation(a, b, lambda a, b: a > b)), [{
a: 1,
b: 0
}]),
(conjp(relation(a, b, lambda a, b: a > b), eq(a, 1), eq(b, 0)), [{
a: 1,
b: 0
}]),
(conjp(eq(a, 1), relation(a, b, lambda a, b: a > b), eq(b, 0)), [{
a: 1,