def unquote(asker, value):
#FIXME more circular dependencies
import dictionaries, strings
if isinstance(value, representations.Representation):
return value.represents
#FIXME all of this should be done with requirements embedded in questions
#rather than asking and then converting
bindings = asker.ask(fields.get_field(representations.bindings(), value)).firm_answer
proto_literal_bindings = dictionaries.to_dict(asker, bindings)
literal_bindings = frozendict({strings.to_str(asker, k):unquote(asker, v)
for k, v in proto_literal_bindings.iteritems()})
head = asker.ask(fields.get_field(representations.head(), value)).firm_answer
literal_head = strings.to_str(asker, head)
return T(literal_head, literal_bindings)
def exposed_modifier(asker, rep):
head = asker.ask(fields.get_field(representations.head(), rep)).answer
if head is None:
return asker.reply(answer=T.no())
else:
result = strings.to_str(asker, head) not in hidden_modifier_heads
return asker.reply(answer=T.from_bool(result))
def print_view(asker, view):
clear()
lines = fields.get(asker, lines_field(), view)
for line in lists.iterator(asker, lines):
s = strings.to_str(asker, line)
print(s)
return asker.reply()
def update_view(asker, view, input):
relayer = asker.pass_through(should_return.head)
#FIXME using the name view_in is a hack to keep view from being locally scoped...
@relayer(should_print.head)
def print_string(s):
view_in = asker.refresh(view)
asker.update(add_line(input), view_in)
#FIXME more things going wrong with representation levels...
s = convert.unquote(asker, s)
line = asker.ask_firmly(render(s))
asker.update(add_line(line), view_in)
return properties.trivial()
@relayer(should_dispatch.head)
def dispatch(x):
view_in = asker.refresh(view)
asker.update(add_line(input), view_in)
head = fields.get(asker, representations.head(), x)
bindings = fields.get(asker, representations.bindings(), x)
view_in = asker.refresh(view_in)
asker.update(add_line(head), view_in)
for p in dictionaries.item_iterator(asker, bindings):
var, val = pairs.to_pair(asker, p)
view_in = asker.refresh(view_in)
asker.update(bind_variable(var, val), view_in)
return properties.trivial()
@relayer(should_assign.head)
def assign(s, x):
view_in = asker.refresh(view)
asker.update(add_line(input), view_in)
view_in = asker.refresh(view_in)
asker.update(bind_variable(s, x), view_in)
return properties.trivial()
interpret_response = asker.ask(interpret_input(view, input), handler=relayer)
if interpret_response.has_answer():
bindings = dictionaries.to_dict(asker, fields.get(asker, bindings_field(), view))
bindings_str = {strings.to_str(asker, k):v for k, v in bindings.items()}
for char in "xyzw" + string.letters:
if char not in bindings_str:
break
asker.update(bind_variable(T.from_str(char), interpret_response.answer), view)
new_line = strings.concat(
T.from_str("{} = ".format(char)),
input
)
asker.update(add_line(new_line), view)
return asker.reply()
def make_term(asker, computation_bindings, head, bindings):
return asker.reply(answer=representations.make(
strings.to_str(asker, head),
dictionaries.to_term_bindings(asker, bindings)
))
def askQ(asker, computation_bindings, head, bindings):
return asker.ask_tail(T(strings.to_str(asker, head), dictionaries.to_term_bindings(asker,bindings)))
def incoming_update(self, source, Q, update, repr_change=None):
if source.head == in_question.head:
referenced = Q.question[strings.to_str(self, source['s'])]
self.update(update, referenced, repr_change)
def to_term_bindings(asker, d):
return frozendict({
strings.to_str(asker, k):v
for k, v in to_dict(asker, d).iteritems()
})
def expose_modifier(asker, object):
rep = representations.quote(object)
head = strings.to_str(asker, fields.get(asker, representations.head(), rep))
if head not in hidden_modifier_heads:
new_modifier = convert.reduce(asker, object.modifier)
return asker.reply(answer=object.simple_update(_modifier=new_modifier))
def irreducible(asker, rep):
head = asker.ask(fields.get_field(representations.head(), rep)).firm_answer
result = strings.to_str(asker, head) not in reducible_heads
return asker.reply(answer=T.from_bool(result))
#FIXME this is much cleaner, but too slow; at any rate could remove duplicate code
return asker.ask_tail(properties.check(opposite(reducible()), rep))
def reducible(asker, rep):
head = asker.ask(fields.get_field(representations.head(), rep)).firm_answer
result = strings.to_str(asker, head) in reducible_heads
return asker.reply(answer=T.from_bool(result))
def parse_string(asker, s):
return asker.reply(answer=parsing.parse(strings.to_str(asker,s)))
