import term

from term import as_head

from term import Term as T

import builtins

from builtins import builtin

import parsing

import termtypes

import pairs

import ints

import strings

import representations

import fields

import properties

import dispatch

from dispatch import Dispatcher

import relayer

import utilities

from utilities import clear

import convert

import lists

import dictionaries

import updates

import strings

import state

import computations

import functions

from ipdb import set_trace as debug

import inspect

from decorator import decorator

import string

@as_head("an interactive environment with sequence of lines [lines] and variable bindings [binding]")

def view(lines, bindings):

return T(view.head, lines=lines, bindings=bindings)

lines_field = fields.named_binding(

)

bindings_field = fields.named_binding(

)

@builtin("what value will ultimately be returned if the user interacts with [view]?")

def predict_output(asker, view):

return asker.ask_tail(predict_output(asker.refresh(view)))

def shell(asker):

current_view = asker.refresh(current_view)

@builtin("prompt the user by displaying the lines of [view]")

def print_view(asker, view):

return asker.reply()

@builtin("prompt the user with [view] and get their input")

def elicit(asker, view):

asker.ask(print_view(view))

return asker.ask_tail(prompt())

@builtin("what would the user type when prompted with [view]?")

def predict_input(asker, view):

return asker.reply(answer=input)

@builtin("what would the user type if prompted right now?")

def prompt(asker):

return asker.reply(answer=T.from_str(raw_input("")))

#TODO: I'm equivocating between questions and queries here...

#I'll need to sort this out, and the logic here will end up being very much

#more complicated

@builtin("what view should be presented to the user to answer [query]?")

def get_starting_view(asker, query):

return asker.reply(answer=view(initial_lines, bindings))

#TODO should probably just have a "should take [action]" item that gets passed through?

@builtin("what does [input] refer to if entered in response to [view]?")

def interpret_input(asker, view, input):

))

@builtin("what expression corresponds to the string [s]?")

def parse_string(asker, s):

return asker.reply(answer=parsing.parse(strings.to_str(asker,s)))

@builtin("what term is [expr] equivalent to when entered in response to [view]?")

def interpret_expression(asker, view, expr):

return interpreter.dispatch(asker, expr, view)

interpreter = Dispatcher("interpreter", ("expr", "context"))

@interpreter(parsing.make_raw_expr.head)

def interpret_raw(asker, view, text, bindings):

return elicit_meaning(text, view, functions.apply(update_bindings, bindings))

@as_head("what term represents the same thing as [text] entered in [view], "

"if variables should refer to the same objects as their images in [bindings]?")

def elicit_meaning(text, view, bindings):

return T(elicit_meaning.head, text=text, view=view, bindings=bindings)

@interpreter(parsing.make_int_expr.head)

def interpret_int(asker, view, k):

return asker.reply(answer=representations.quote(k))

@interpreter(parsing.make_str_expr.head)

def interpret_str(asker, view, s):

return asker.reply(answer=representations.quote(s))

@interpreter(parsing.make_list_expr.head)

def interpret_list(asker, view, l):

return asker.reply(answer=result)

should_print = term.simple("the referent of [s] should be printed in the referenced view", "s")

should_dispatch = term.simple("the head of [x] should be printed and its bindings promoted "

"in the referenced view", "x")

should_return = term.simple("[x] should be returned "

"if the user interacts with the referenced view", "x")

should_assign = term.simple("[s] should refer to [x] in future interactions with the "

"referenced view", "s", "x")

#TODO this is a duplicate of run_arg, I should generalize them

def interpret_arg(name):

return make_interpreted_arg

#FIXME this probably doesn't play nicely with unquoting and the current print routine

@interpreter(parsing.make_print.head)

@interpret_arg('s')

def interpret_print(asker, view, s):

return asker.reply(value=should_print(s))

#FIXME consistency in use of x vs. x.head in dispatches

@interpreter(parsing.make_dispatch.head)

@interpret_arg('x')

def interpret_dispatch(asker, view, x):

return asker.reply(value=should_dispatch(x))

@interpreter(parsing.make_return.head)

@interpret_arg('x')

def interpret_return(asker, view, x):

return asker.reply(value=should_return(x))

@interpreter(parsing.make_assignment)

@interpret_arg('value')

def interpret_assign(asker, view, name, value):

return asker.reply(value=should_assign(name, value))

@builtin("what view should [view] become if the user enters [input]?")

def update_view(asker, view, input):

return asker.reply()

#Rendering----------------------------------------

#FIXME rendering probably belongs in another module...

#TODO add support for more rendering strategies?

@builtins.builtin("what string should be used to render [x] for printing?")

def render(asker, x):

t = asker.ask(termtypes.type(x))

if t.has_answer():

return typed_renderer.dispatch(asker, t.answer, x)

typed_renderer = Dispatcher("renderer with types", ("type", "object"))

renderer = Dispatcher("renderer", ("object",))

@typed_renderer(representations.term_type)

def render_term(asker, term):

))

@typed_renderer(ints.int_type)

def render_int(asker, x):

return asker.reply(answer=T.from_str(str(ints.to_int(asker, x))))

@typed_renderer(strings.char_type)

def render_char(asker, x):

return asker.reply(answer=T.simple_str(T.from_list([c])))

@typed_renderer(strings.string_type)

def render_str(asker, x):

return asker.reply(answer=x)

#FIXME in reality need more flexibility

@typed_renderer(lists.list_type)

def render_list(asker, x):

return asker.reply(answer=result)

#TODO better answer

@typed_renderer(dictionaries.dict_type)

def render_dict(asker, x):

))

#TODO something better than concat... maybe formatting?

@typed_renderer(pairs.pair_type)

def render_pair(asker, x):

))

@updates.updater("the update that binds [name] to [value] in the updated view")

def bind_variable(asker, view, name, value):

))

@updates.updater("the update that adds [new_line] to the updated view")

def add_line(asker, view, new_line):

))