from dispatch import Dispatcher

import term

from term import Term as T

from collections import defaultdict

import properties

from properties import checker

import builtins

from builtins import builtin

import fields

import representations

from ipdb import set_trace as debug

try:

from pytest import set_trace as test_debug

except ImportError:

pass

from frozendict import frozendict

import booleans

import strings

converter = Dispatcher("converter", ('value', 'requirement'))

#req: a desired property for the post-conversion representation

#FIXME I would prefer incorporate this into the interpreter state rather than using global state

#it seems somewhat plausible that the interpeter state should be a MetaTerm rather than a Term?

#that would make this significantly easier

#at the very least I can construct it by making a metaterm and then quoting it

#maps id --> a set of equivalent forms that have been produced by conversions

synonyms = defaultdict(set)

#maps (id, req.id) --> a satisfying form

conversion_cache = {}

#FIXME I think that something is wrong here with respect to quoting

#FIXME I want to be able to take small diffs from things that heve ids

@builtin("what is [value]? the representation of the result should satisfy [req]")

def convert(asker, value, req):

return asker.reply(answer=properties.simple_add_modifier(result, old_modifier))

#FIXME the real semantics here is that "_modifier" is missing, not "missing some properties"

#I don't know how to express that right now...

@builtin("what is an object that is the same as [value], but potentially missing "

"some of the properties of [value]? "

"the representation of the result should satisfy [req]")

def raw_convert(asker, value, req):

return converter.dispatch(asker, value, req)

@builtin("is [repr2] a better representation to us than [repr1], "

"given [repr2] satisfies [req] but [repr1] does not?")

def nicer_representation(asker, repr1, repr2, req):

return asker.deny()

#Conversion to literal types----------------------

#FIXME these have been superseded by real conversions in the appropriate files

def is_literal_term():

return T(is_literal_term.head)

is_literal_term.head = "is a canonical representation of a term"

#FIXME I think that this belongs in representations area probably?

def unquote(asker, value):

return T(literal_head, literal_bindings)

reducible_heads = set()

def is_reducible(f):

return f

@checker("can probably be reduced to a simpler form")

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

@checker("cannot be reduced to a manifestly simpler form by computing")

def irreducible(asker, rep):

return asker.ask_tail(properties.check(opposite(reducible()), rep))

#FIXME I should somehow handle a conversion fail gracefully

def reduce(asker, object):

return asker.ask(convert(object, irreducible())).firm_answer

makermaker = Dispatcher("dummy", ("thing",))

def reducer(name):

return simplify

#Applications of reduction--------------

#TODO I can probably do the equality tests in a more intelligent way...

@builtins.builtin(builtins.equal.head)

def equal(asker, a, b):

return asker.deny()

@properties.trivial_checker()

def check_trivial_default(asker, property):

if properties.check_firmly(asker, irreducible(), property):

return asker.reply(answer=T.from_bool(False))

#Properties---------------------------------------

hidden_modifier_heads = set()

def hides_modifiers(f):

hidden_modifier_heads.add(f.head)

return f

#TODO in the long run I want to be able to just define what a property is...

#and then have the conversions be handled for me

@checker("is a representation with most easily accessible properties of the represented object in '_modifier'")

def exposed_modifier(asker, rep):

return asker.reply(answer=T.from_bool(result))

@converter((None, exposed_modifier.head))

def expose_modifier(asker, object):

return asker.reply(answer=object.simple_update(_modifier=new_modifier))

#FIXME in general things seem to live in really awkward places because of dependency issues

#there is no way this belongs in conversions...

@fields.getter(fields.modifier.head)

def get_modifier(asker, object):

reduced_object = asker.ask(convert(object, exposed_modifier())).firm_answer

return asker.reply(answer=reduced_object.modifier)

@fields.setter(fields.modifier.head)

def set_modifier(asker, object, new_value):

reduced_object = asker.ask(convert(object, exposed_modifier())).firm_answer

return asker.reply(answer=reduced_object.simple_update(_modifier=new_value))

#Booleans-----------------------------------------

@checker(properties.both.head)

def check_both(asker, object, a, b):

return asker.reply(answer=both(*[reply.answer for reply in replies]))

@checker("does not satisfy [x]")

def opposite(asker, object, x):

underlying = asker.ask(properties.check(x, object)).firm_answer

return asker.reply(answer=booleans.opposite(underlying))

@reducer(booleans.either.head)

def either(asker, a, b):

return asker.reply(answer=T.from_bool(False))

@reducer(booleans.both.head)

def both(asker, a, b):

return asker.reply(answer=T.from_bool(True))

@reducer(booleans.opposite.head)

def convert_opposite(asker, a):

return opposite_converter.dispatch(asker, a)

opposite_converter = Dispatcher("opposite converter", ('x',))

@opposite_converter(T.yes.head)

def yes_to_no(asker):

return asker.reply(answer=T.no())

@opposite_converter(T.no.head)

def no_to_yes(asker):

return asker.reply(answer=T.yes())

#Fields-------------------------------------------

#FIXME in a terrible place...

#maybe I should just merge representations and convert?

#TODO should irreducible use the same format? I need to think about that

@reducer(representations.referent_of.head)

def reduce_referent_of(asker, s):

import dictionaries

return asker.reply(answer=fields.compose(representations.bindings(), dictionaries.image(s)))