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)))