def _eval(self, strategy, verbose, branch_id):
if strategy == 'eager':
e1 = self.operator.eval(strategy, verbose, branch_id + ['a'])
z1 = self.operand.eval(strategy, verbose, branch_id + ['b'])
z = e1.reach.replace(Delta({e1.bind: z1}))
return z.eval(strategy, verbose, branch_id + ['c'])
else:
e = self.operator.eval(strategy, verbose, branch_id + ['a'])
z = e.reach.replace(Delta({e.bind: self.operand}))
return z.eval(strategy, verbose, branch_id + ['b'])
def _eval(self, strategy, verbose, branch_id):
if strategy == 'eager':
abstraction = Abstraction(self.e1.bind,
Letrec(self.v, self.e1, self.e1.reach))
delta = Delta({self.v: abstraction})
else:
abstraction = Abstraction(self.v, self.e1)
rec = Rec(abstraction)
delta = Delta({self.v: rec})
new_expr = self.e2.replace(delta)
return new_expr.eval(strategy, verbose, branch_id + ['a'])
def replace(self, delta):
forbidden = set(sum((list(delta(w).fv()) for w in self.fv()), []))
vnew = self.bind
while vnew in forbidden:
vnew = next(vnew)
newdelta = Delta(delta)
newdelta[self.bind] = vnew
return Abstraction(vnew, self.reach.replace(newdelta))
def _replace(self, delta, strict):
forbidden = set(sum((list(delta(w).fv()) for w in self.fv()), []))
vnew = self.binding
while vnew in forbidden:
vnew = next(vnew)
newdelta = Delta(delta)
newdelta[self.binding] = vnew
return self.__class__(vnew, self.reach.replace(newdelta, strict))
def _replace(self, delta, strict):
forbidden = set([delta(w) for w in self.c.fv() - {self.var}])
vnew = self.var
while vnew in forbidden:
vnew = next(vnew)
newdelta = Delta(delta)
newdelta[self.var] = vnew
return NewVar(vnew, self.intexp.replace(delta, strict=True),
self.c.replace(newdelta, strict=True))
def replace(self, delta):
forbidden = set(sum((list(delta(w).fv()) for w in self.fv()), []))
vnew = self.v
while vnew in forbidden:
vnew = next(vnew)
newdelta = Delta(delta)
newdelta[self.v] = vnew
return Letrec(vnew, self.e1.replace(newdelta),
self.e2.replace(newdelta))
def inner(expr):
if verbose:
print(expr)
while True:
path = get_path_to_outermost_leftmost_redex(expr)
if path is None:
break
redex = eval('expr{}'.format(path))
delta = Delta({redex.operator.bind: redex.operand})
beta_contraction = redex.operator.reach.replace(delta)
path = path.split('.')[1:]
elem = expr
while len(path) > 1:
attr = path.pop(0)
elem = getattr(elem, attr)
if path:
setattr(elem, path[0], beta_contraction)
else:
expr = beta_contraction
if verbose:
print('→', expr)
return expr
def rename(self, newbind):
if newbind in (self.reach.fv() - {self.bind}):
raise ValueError('{} is free in {}'.format(newbind, self.reach))
return Abstraction(newbind,
self.reach.replace(Delta({self.bind: newbind})))
def __eq__(self, other):
if self.__class__ != other.__class__:
return False
return self.reach == other.reach.replace(Delta({other.bind:
self.bind}))
from boolexp import *
from utils import concat
from state import State
from replace import Delta
program = concat([
Assign(Var('x'), Const(10)),
While(
Geq(Var('x'), Const(0)),
Concat(
Assign(Var('x'), Plus(Var('x'), Const(-1))),
NewVar(Var('x'), Const(200), Assign(Var('x2'), Plus(Var('x'), Const(2))))))
])
print('Programa:')
print(program)
result = program.sem(State())
print(result)
delta = Delta()
delta[Var('x')] = Var('x7')
delta[Var('x2')] = Var('x5')
print('Programa aplicando el reemplazo', delta)
newprogram = program.replace(delta)
print(newprogram)
result = newprogram.sem(State())
print(result)