def _ensure_parsed_expression(self, expr):
languages = self._languages
if isinstance(expr, basestring):
answer = self._cur_parser().parse_expression(expr, languages)
if isinstance(answer, basestring):
# Was a symbol; wrap it in a stack dict to prevent it
# from being processed again.
return {'type': 'symbol', 'value': answer}
else:
return answer
elif isinstance(expr, list) or isinstance(expr, tuple):
return [self._ensure_parsed_expression(e) for e in expr]
elif isinstance(expr, dict):
# A literal value as a stack dict. These are all assumed
# fully parsed.
return expr
elif isinstance(expr, int):
return v.integer(expr)
elif isinstance(expr, numbers.Number):
return v.number(expr)
elif isinstance(expr, VentureValue):
# A literal value as a Venture Value
return expr.asStackDict(None)
else:
raise Exception("Unknown partially parsed expression type %s" %
expr)
def Assume_valuesExpand(exp):
if len(exp[1]) == 1: # base case
pattern = ["assume_values", ["datum-1"], "datum-2"]
template = [
"_assume", ["quasiquote", "datum-1"],
["quasiquote", ["deref", ["first", "datum-2"]]]
]
else:
names = exp[1]
name_vars = ["name_%d" % i for i in range(len(names))]
lst_name = "__lst_%d__" % random.randint(10000, 99999)
pattern = ["assume_values", name_vars, "lst_exp"]
name_exps = [[
"assume", name, ["deref", ["lookup", lst_name,
v.integer(i)]]
] for (i, name) in enumerate(names)]
template = ["do", ["assume", lst_name, "lst_exp"]] + name_exps
return SyntaxRule(pattern, template).expand(exp)
def DoExpand(exp):
if len(exp) == 2:
# One statement
pattern = ["do", "stmt"]
template = "stmt"
else:
(_do, statement, rest) = (exp[0], exp[1], exp[2:])
rest_vars = ["rest_%d" % i for i in range(len(rest))]
if (type(statement) is list
and len(statement) == 3 and v.basic_val_of_type_content(
"symbol", statement[1]) == "<-"):
# Binding statement, regular form
pattern = ["do", ["var", "<-", "expr"]] + rest_vars
template = [
"bind", "expr", ["lambda", ["var"], ["do"] + rest_vars]
]
elif (type(statement) is list and len(statement) == 3
and v.basic_val_of_type_content("symbol", statement[0]) == "<-"):
# Binding statement, venturescript form
pattern = ["do", ["<-", "var", "expr"]] + rest_vars
template = [
"bind", "expr", ["lambda", ["var"], ["do"] + rest_vars]
]
elif (type(statement) is list
and len(statement) == 3 and v.basic_val_of_type_content(
"symbol", statement[0]) == "let"):
# Let statement
pattern = ["do", ["let", "var", "expr"]] + rest_vars
template = ["let", [["var", "expr"]], ["do"] + rest_vars]
elif (type(statement) is list
and len(statement) == 3 and v.basic_val_of_type_content(
"symbol", statement[0]) == "let_values"):
# Let_values statement
n = len(statement[1])
lst_name = "__lst_%d__" % random.randint(10000, 99999)
let_vars = ["var_%d" % i for i in range(n)]
let_exps = [[var, ["deref", ["lookup", lst_name,
v.integer(i)]]]
for (i, var) in enumerate(let_vars)]
pattern = ["do", ["let_values", let_vars, "lst_expr"]] + rest_vars
template = [
"let", [[lst_name, "lst_expr"]] + let_exps, ["do"] + rest_vars
]
elif (type(statement) is list
and len(statement) == 3 and v.basic_val_of_type_content(
"symbol", statement[0]) == "letrec"):
# Letrec statement
mutrec = 0
for next_statement in rest:
if (type(next_statement) is list and len(next_statement) == 3
and v.basic_val_of_type_content(
"symbol", next_statement[0]) == "mutrec"):
mutrec += 1
else:
break
mutrec_vars = [["var_%d" % i, "expr_%d" % i]
for i in range(mutrec)]
pattern = (["do", ["letrec", "var", "expr"]] +
[["mutrec"] + e
for e in mutrec_vars] + rest_vars[mutrec:])
template = [
"letrec", [["var", "expr"]] + mutrec_vars,
["do"] + rest_vars[mutrec:]
]
else:
# Non-binding statement
pattern = ["do", "stmt"] + rest_vars
template = ["bind_", "stmt", ["lambda", [], ["do"] + rest_vars]]
return SyntaxRule(pattern, template).expand(exp)
def observe(i, d):
r.observe(expr.app(expr.symbol("datum"), expr.integer(i), d), dataset[i][d])