def test_unify_lists_zero_to_many_list_vars(canonicalize):
equations = unify([
([], [ListExpansion('y'), ListExpansion('z')]),
], canonicalize)
assert equations == {
'y...': '[]',
'z...': '[]',
}
def test_unify_lists_many_to_many_list_vars_ok_if_same(canonicalize):
equations = unify([
([ListExpansion('x'),
Term('f', []), ListExpansion('y')],
[ListExpansion('x'),
Term('f', []), ListExpansion('y')]),
], canonicalize)
assert equations == {}
def test_unify_lists_many_to_many_list_vars(canonicalize):
with pytest.raises(UnificationAmbiguousException):
unify([
([ListExpansion('x'),
Term('f', []),
ListExpansion('y')
], [ListExpansion('z'),
Term('f', []),
ListExpansion('k')]),
], canonicalize)
def test_unify_lists_one_to_many_list_vars(canonicalize):
equations = unify([
([ListExpansion('x')], [
Term('f', []),
ListExpansion('y'),
Term('g', []),
ListExpansion('z'),
Term('h', [])
]),
], canonicalize)
assert equations == {'x...': '[f(), y..., g(), z..., h()]'}
def _unpack_if_variable(
expr: ir.Expr, var_names: Set[str],
literal_expr_by_unique_name: MutableMapping[str,
ir.AtomicTypeLiteral]):
if isinstance(expr, ir.VariadicTypeExpansion):
return ListExpansion(
_unpack_if_variable(expr.expr, var_names,
literal_expr_by_unique_name))
if isinstance(expr, ir.AtomicTypeLiteral) and expr.cpp_type in var_names:
# We keep track of the expr so that we can re-pack this later.
# If there are multiple they must be the same.
if expr.cpp_type in literal_expr_by_unique_name:
assert expr == literal_expr_by_unique_name[
expr.cpp_type], '%s vs %s. Detailed:\n%s\n-- vs --\n%s' % (
expr_to_cpp_simple(expr),
expr_to_cpp_simple(
literal_expr_by_unique_name[expr.cpp_type]),
ir_to_string(expr),
ir_to_string(literal_expr_by_unique_name[expr.cpp_type]))
else:
literal_expr_by_unique_name[expr.cpp_type] = expr
return expr.cpp_type
else:
return expr
def test_unify_lists_common_suffix(canonicalize):
equations = unify([
([ListExpansion('z'), 'x', 'y'], [
Term('f', []),
'k',
'x',
'y',
]),
], canonicalize)
assert equations == {'z...': '[f(), k]'}
def replace_variables_in_expr(
self, expr: UnificationStrategy.Expr,
replacements: Dict[str, List[UnificationStrategy.Expr]],
expanded_var_replacements: Dict[str, List[UnificationStrategy.Expr]]
) -> UnificationStrategy.Expr:
if isinstance(expr, str):
if expr in replacements:
return replacements[expr]
if expr in expanded_var_replacements:
return expanded_var_replacements[expr]
return expr
if isinstance(expr, ListExpansion):
return ListExpansion(
self.replace_variables_in_expr(expr.expr, replacements,
expanded_var_replacements))
return self.term_copy_with_args(expr, [
self.replace_variables_in_expr(arg, replacements,
expanded_var_replacements)
for arg in self.get_term_args(expr)
])
def test_unify_lists_common_prefix(canonicalize):
equations = unify([
(['x', 'y', ListExpansion('z')], ['x', 'y',
Term('f', []), 'k']),
], canonicalize)
assert equations == {'z...': '[f(), k]'}
def test_unify_list_var_with_term(canonicalize):
equations = unify([
(ListExpansion('x'), [Term('f', ['y'])]),
], canonicalize)
assert equations == {'x...': '[f(y)]'}
def test_unify_list_var_with_empty_list(canonicalize):
equations = unify([
(ListExpansion('x'), []),
], canonicalize)
assert equations == {'x...': '[]'}
def test_unify_list_var_with_list_var(canonicalize):
equations = unify([
(ListExpansion('x'), ListExpansion('y')),
], canonicalize)
assert equations == {'x': 'y'}