Exemple #1
0
import handlers
import properties
from builtins import builtin
import fields
import relayer
import updates
import context

state = term.simple("a state of the interpeter where [history] maps "
    "strings to the user's historical response to those strings, "
    "and where [computation] is invoked to handle computations",
    'history', 'computation')

history = fields.named_binding(
    "the function that maps an interpreter state to the history of commands that "
    "have been entered in that state",
    state.head,
    'history'
)

handler = fields.named_binding(
    "the function that maps an interpreter state to the computation invoked "
    "to handle questions in that state",
    state.head,
    'computation'
)

def starting_state():
    return state(T.from_dict({}), handlers.view_handler())

#TODO it seems like somehow history should be a composite resource locator
#(almost a composite field, but there is no object you are accessing it on...)
Exemple #2
0
import term
from term import Term as T
import fields
import termtypes

pair_type = termtypes.new_type("the type of pairs")

termtypes.set_type(pair_type, T.pair)

def to_pair(asker, p):
    return (fields.get(asker, first(), p), fields.get(asker, second(), p))

first = fields.named_binding(
    "the function that maps a pair to its first element",
    T.pair.head,
    'a'
)

second = fields.named_binding(
    "the function that maps a pair to its second element",
    T.pair.head,
    'b'
)
#Representing terms--------------------------------

#TODO I could probably make Representation a function,
#then make a decorator that turns any such function into a "held"
#version...


quoted_term = term.simple("a term with head [head] head and bindings [bindings]",
        'head', 'bindings')
term_type = termtypes.new_type("the type of terms")
termtypes.set_type(term_type, quoted_term)

head = fields.named_binding(
    "the function that maps a term to its head",
    quoted_term.head,
    'head'
)

bindings = fields.named_binding(
    "the function that maps a term to its bindings",
    quoted_term.head,
    'bindings'
)

#referent_of = term.simple("the function that maps a term to the referent of [s] in that term's head", "s")
#FIXME this is a dumb hack to cut down on computational time
#(though I think that in the real thing these changes would propagate back to the computations)
@term.as_head("the function that maps a term to the referent of [s] in that term's head")
def referent_of(s):
    import dictionaries
Exemple #4
0
@list_iterator(snoc.head)
def iterate_snoc(asker, init, last):
    for x in iterator(asker, init):
        yield x
    yield last

@list_iterator(concat.head)
def iterate_concat(asker, a, b):
    for x in iterator(asker, a):
        yield x
    for y in iterator(asker, b):
        yield y

first = fields.named_binding(
    "the function that maps a list to its first element",
    cons.head,
    'head'
)

#FIXME should probably assert that the length is 1 or something?
#also maybe there should be a singleton type?
only = first

tail = fields.named_binding(
    "the function that maps a list to all but its first element",
    cons.head,
    'tail'
)

#Properties---------------------------------------
def visible_children(asker, object):
    expanded = convert.check_hard(asker, is_expanded(), object)
    object = asker.refresh(object)
    if not expanded:
        return asker.reply(answer=T.from_list([]))
    else:
        children = asker.ask(fields.get_field(all_children(), object)).firm_answer
        return asker.reply(answer=children)

@setter(visible_children.head)
def set_visibile_children(asker, object, new_value):
    return asker.ask_tail(fields.set_field(all_children(), object, new_value))

all_children = fields.named_binding(
    "the function that maps a node of an outline to the list of nodes which are its children",
    node.head,
    'children'
)


#Printing lines-----------------------------------

#FIXME this should probably emit a string or list of strings rather than just print them...
#FIXME this should probably use the conversions machinery
line_printer = Dispatcher("line printer", ("lines", "k", "tab"))
#tab: the string to use for a tab
#k: the number of tabs to use for the outermost line

@builtin("print the lines [lines]")
def print_lines_simple(asker, lines):
    return asker.ask_tail(print_lines(lines, T.from_int(0), T.from_str("  ")))
Exemple #6
0
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(
    "the function that maps a view to the sequence of lines rendered in that view",
    view.head,
    'lines'
)

bindings_field = fields.named_binding(
    "the function that maps a view to the variable bindings that should be applied in that view",
    view.head,
    'bindings'
)

@builtin("what value will ultimately be returned if the user interacts with [view]?")
def predict_output(asker, view):
    input = asker.ask(predict_input(view)).firm_answer
    class context:
        result = None
    else:
        chars = fields.get(asker, list_of_chars(), s)
        return ''.join(to_char(c) for c in lists.iterator(asker, chars))

literalizer = Dispatcher("string literalizer", ("string",))

#FIXME characters might not be literal, should probably have a character literalizer as well
@is_type(string_type)
@literalizer(T.simple_string.head)
def literalize_simple(asker, list):
    import lists
    return ''.join(to_char(asker, c) for c in lists.to_list(asker, list))

list_of_chars = fields.named_binding(
    "the function that maps a string to its list of characters",
    T.simple_string.head,
    'list'
)

@is_type(string_type)
@literalizer("the string formed by concatenating [a] with [b]")
def concat(asker, a, b):
    return to_str(asker, a) + to_str(asker, b)


#Converting to chars------------------------------

def to_char(asker, c):
    if c.to_char() is not None:
        return c.to_char()
    result = char_literalizer.dispatch(asker, c)