def nicer_representation(asker, repr1, repr2, req):
if (booleans.ask_firmly(asker, builtins.equal(req, irreducible())) or
booleans.ask_firmly(asker, builtins.equal(req, exposed_modifier()))):
return asker.affirm()
else:
#FIXME I should do something much more sophisticated here
return asker.deny()
def set_image(asker, new_value, k, key, value, other):
if booleans.ask_firmly(asker, builtins.equal(k, key)):
return asker.reply(answer=cons(key=key, value=new_value, other=other))
else:
return asker.reply(answer=cons(key=key, value=value,
other=updates.update(updates.set_field(image(k), new_value), other)
))
def orthogonal(asker, field1, field2):
if booleans.ask_firmly(asker, builtins.equal(field1, field2)):
return asker.reply(answer=T.no())
result = orthogonality_tester.dispatch(asker, field1, field2)
if result is not None: return result
result = orthogonality_tester.dispatch(asker, field2, field1)
if result is not None: return result
def cons_image(asker, k, key, value, other):
if booleans.ask_firmly(asker, builtins.equal(k, key)):
return asker.reply(answer=value)
else:
return asker.ask_tail(
fields.get_field(image(k), other),
handler=asker.pass_through(not_found.head)
)
def convert(asker, value, req):
starting_cost = asker.cost
def check(x):
return properties.check_firmly(asker, req, representations.quote(x))
if check(value):
return asker.reply(answer=value)
#TODO in the long run we might want to leave properties in if they can simplify the conversion
old_modifier = value.modifier
stripped = value.simple_update(_modifier=properties.trivial())
id = stripped.id
result = None
if (id, req.id) in conversion_cache:
result = conversion_cache[(id, req.id)]
if result is None:
for form in synonyms[id]:
if check(form):
result = form
if result is None:
response = asker.ask(raw_convert(value, req))
if response.has_answer():
result = response.answer
else:
return asker.reply()
synonyms[id].add(result)
conversion_cache[(id, req.id)] = result
#FIXME what an ugly hack; this sort of thing will hopefully be done automatically
if (asker.cost - starting_cost > 30 and
booleans.ask_firmly(asker, nicer_representation(
representations.quote(value),
representations.quote(result),
req
))):
asker.set_repr(value, representations.quote(result))
return asker.reply(answer=properties.simple_add_modifier(result, old_modifier))
def translate_field_across_setting(asker, to_translate, old_value, old, new, field, new_value):
if booleans.ask_firmly(asker, fields.orthogonal(to_translate, field)):
return asker.reply(answer=old_value)
elif booleans.ask_firmly(asker, builtins.equal(to_translate, field)):
return asker.reply(answer=new_value)
def translate_field_across_application(asker, to_translate, old_value, old, new, field, update):
if booleans.ask_firmly(asker, fields.orthogonal(to_translate, field)):
return asker.reply(answer=old_value)
elif booleans.ask_firmly(asker, builtins.equal(to_translate, field)):
return asker.reply(answer=updates.update(update, field))
def setter_stripper(asker, property, object, field, new_value):
if booleans.ask_firmly(asker, builtins.equal(field, fields.modifier())):
return asker.reply(value=keep_strip(keep=property))
def strip_field_value(asker, property, object, update, field):
property_field = property['field']
if booleans.ask_firmly(asker, builtins.equal(field, property_field)):
return asker.reply(value=keep_strip(keep=property))
def application_stripper(asker, property, object, update, field):
if booleans.ask_firmly(asker, builtins.equal(field, fields.modifier())):
return asker.reply(value=keep_strip(keep=property))
def infer_from_field_value(asker, to_infer, field, value):
if booleans.ask_firmly(asker, builtins.equal(to_infer, field)):
return asker.reply(answer=value)
else:
return asker.reply(value=unknown())
def set_implication(asker, to_set, new_value, field):
if booleans.ask_firmly(asker, builtins.equal(to_set, field)):
return asker.reply(answer=field_value(to_set, new_value))
else:
return asker.reply(value=unknown())
def check_firmly(asker, p, object):
return booleans.ask_firmly(asker, check(p, object))
