return asker.reply(answer=object)
@fast_updater(become.head)
def become_update(asker, object, target):
return asker.reply(answer=target)
#Reintroducing modifiers--------------------------
@builtin("of [property], what property should be removed from [object] before applying [update] (and restored after), "
"and which should be kept during the update?")
def modifiers_to_strip(asker, update, property, object):
return modifier_stripper.dispatch(asker, update, property, object)
modifier_stripper = Dispatcher("modifier stripper", ("update", "property", "object"))
to_keep = fields.atomic_field("the function that sends a question to the property that should be retained in the referenced situation")
to_strip = fields.atomic_field("the function that sends a question to the property "
"that should be restored later in the referenced situation")
def keep_strip(keep=None, strip=None):
if keep is None:
keep = properties.trivial()
if strip is None:
strip = properties.trivial()
return properties.both(
fields.field_value(to_keep(), keep),
fields.field_value(to_strip(), strip)
)
#TODO in the long run we should do something more sophisticated
@modifier_stripper()
#which I think can be done by having a translator that pulls "will have children"
#across the toggl expanded update
@builtin("what is the outline, collapsed to its root, that best expresses [quoted_term]?")
def node_from_term(asker, quoted_term):
head = asker.ask(fields.get_field(representations.head(), quoted_term)).firm_answer
bindings = asker.ask(fields.get_field(representations.bindings(), quoted_term)).firm_answer
return asker.reply(answer=properties.simple_add_modifier(
node(head, T.empty_list()),
children_on_expanded(bindings)
))
#Outlines to lines--------------------------------
#TODO I should implement caching in a generic way...
cached_lines = fields.atomic_field(
"the function that maps a node to a sequence of lines that represents it"
)
to_lines_Q = "what sequence of lines should represent the outline with root [root]"
@builtin(to_lines_Q)
def outline_to_lines(asker, root):
debug()
result = asker.ask(fields.get_field(cached_lines(), root)).answer
if result is not None:
return asker.reply(answer=result)
base_headline = asker.ask(fields.get_field(headline(), root)).firm_answer
root = asker.refresh(root)
prefix = "* " if convert.check_hard(asker, is_pointer(), root) else " "
full_headline = strings.string_concat(T.from_str(prefix), base_headline)
root = asker.refresh(root)
children = asker.ask(fields.get_field(visible_children(), root)).firm_answer