def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
params = operands[0]
if isinstance(params, Symbol):
verify_exact_callable_length(self, 2, len(operands))
frame.assign(
params,
evaluate(operands[1], frame,
gui_holder.expression.children[2]))
return params
elif isinstance(params, Pair):
name = params.first
operands[0] = params.rest
if (not isinstance(name, Symbol)):
raise OperandDeduceError(''.join(
['Expected a Symbol, not ', '{}'.format(name), '.']))
frame.assign(
name,
Lambda().execute(operands, frame, gui_holder, name.value))
return name
else:
raise OperandDeduceError(''.join([
'Expected a Pair, not ', '{}'.format(params),
', as the first operand of define-macro.'
]))
def execute(self,
operands: List[Expression],
frame: Frame,
gui_holder: Holder,
name: str = "lambda"):
verify_min_callable_length(self, 2, len(operands))
params = operands[0]
if not logger.dotted and not isinstance(params, (Pair, NilType)):
raise OperandDeduceError(
f"Expected Pair as parameter list, received {params}.")
params, var_param = dotted_pair_to_list(params)
for i, param in enumerate(params):
if (logger.dotted
or i != len(params) - 1) and not isinstance(param, Symbol):
raise OperandDeduceError(
f"Expected Symbol in parameter list, received {param}.")
if isinstance(param, Pair):
param_vals = pair_to_list(param)
if len(param_vals) != 2 or \
not isinstance(param_vals[0], Symbol) or \
not isinstance(param_vals[1], Symbol) or \
param_vals[0].value != "variadic":
raise OperandDeduceError(
f"Each member of a parameter list must be a Symbol or a variadic "
f"parameter, not {param}.")
var_param = param_vals[1]
params.pop()
return self.procedure(params, var_param, operands[1:], frame, name)
def execute_evaluated(self, operands: List[Expression], frame: Frame):
verify_min_callable_length(self, 1, len(operands))
assert_all_numbers(operands)
if len(operands) == 1:
return Number(-operands[0].value)
return Number(operands[0].value - sum(operand.value
for operand in operands[1:]))
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_min_callable_length(self, 1, len(operands))
for (cond_i, cond) in enumerate(operands):
if (not isinstance(cond, Pair)):
raise OperandDeduceError(''.join([
'Unable to evaluate clause of cond, as ',
'{}'.format(cond), ' is not a Pair.'
]))
expanded = pair_to_list(cond)
cond_holder = gui_holder.expression.children[(cond_i + 1)]
cond_holder.link_visual(VisualExpression(cond))
eval_condition = SingletonTrue
if ((not isinstance(expanded[0], Symbol))
or (expanded[0].value != 'else')):
eval_condition = evaluate(expanded[0], frame,
cond_holder.expression.children[0])
if ((isinstance(expanded[0], Symbol) and
(expanded[0].value == 'else'))
or (eval_condition is not SingletonFalse)):
out = eval_condition
for (i, expr) in enumerate(expanded[1:]):
out = evaluate(expr, frame,
cond_holder.expression.children[(i + 1)],
(i == (len(expanded) - 2)))
return out
return Undefined
def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
bindings = operands[0]
if not isinstance(bindings, Pair) and bindings is not Nil:
raise OperandDeduceError(f"Expected first argument of let to be a Pair, not {bindings}.")
new_frame = Frame("anonymous let", frame)
bindings_holder = gui_holder.expression.children[1]
bindings = pair_to_list(bindings)
for i, binding in enumerate(bindings):
if not isinstance(binding, Pair):
raise OperandDeduceError(f"Expected binding to be a Pair, not {binding}.")
binding_holder = bindings_holder.expression.children[i]
binding = pair_to_list(binding)
if len(binding) != 2:
raise OperandDeduceError(f"Expected binding to be of length 2, not {len(binding)}.")
name, expr = binding
if not isinstance(name, Symbol):
raise OperandDeduceError(f"Expected first element of binding to be a Symbol, not {name}.")
new_frame.assign(name, evaluate(expr, frame, binding_holder.expression.children[1]))
value = None
for i, (operand, holder) in enumerate(zip(operands[1:], gui_holder.expression.children[2:])):
value = evaluate(operand, new_frame, holder, i == len(operands) - 2)
new_frame.assign(return_symbol, value)
return value
def execute(self,
operands: List[Expression],
frame: Frame,
gui_holder: Holder,
name: str = 'lambda'):
verify_min_callable_length(self, 2, len(operands))
params = operands[0]
if ((not logger.dotted) and (not isinstance(params, (Pair, NilType)))):
raise OperandDeduceError(''.join([
'Expected Pair as parameter list, received ',
'{}'.format(params), '.'
]))
(params, var_param) = dotted_pair_to_list(params)
for (i, param) in enumerate(params):
if ((logger.dotted or (i != (len(params) - 1)))
and (not isinstance(param, Symbol))):
raise OperandDeduceError(''.join([
'Expected Symbol in parameter list, received ',
'{}'.format(param), '.'
]))
if isinstance(param, Pair):
param_vals = pair_to_list(param)
if ((len(param_vals) != 2)
or (not isinstance(param_vals[0], Symbol))
or (not isinstance(param_vals[1], Symbol))
or (param_vals[0].value != 'variadic')):
raise OperandDeduceError(''.join([
'Each member of a parameter list must be a Symbol or a variadic parameter, not ',
'{}'.format(param), '.'
]))
var_param = param_vals[1]
params.pop()
return self.procedure(params, var_param, operands[1:], frame, name)
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_min_callable_length(self, 1, len(operands))
out = None
for i, (operand, holder) in enumerate(
zip(operands, gui_holder.expression.children[1:])):
out = evaluate(operand, frame, holder, i == len(operands) - 1)
return out
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_min_callable_length(self, 1, len(operands))
assert_all_numbers(operands)
if len(operands) == 1:
return Number(1 / operands[0].value)
out = operands[0].value
for operand in operands[1:]:
out /= operand.value
return Number(out)
def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
if len(operands) > 3:
verify_exact_callable_length(self, 3, len(operands))
if evaluate(operands[0], frame, gui_holder.expression.children[1]) is SingletonFalse:
if len(operands) == 2:
return Undefined
else:
return evaluate(operands[2], frame, gui_holder.expression.children[3], True)
else:
return evaluate(operands[1], frame, gui_holder.expression.children[2], True)
def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
params = operands[0]
if not isinstance(params, Pair):
raise OperandDeduceError(f"Expected a Pair, not {params}, as the first operand of define-macro.")
name = params.first
operands[0] = params.rest
if not isinstance(name, Symbol):
raise OperandDeduceError(f"Expected a Symbol, not {name}.")
frame.assign(name, Macro().execute(operands, frame, gui_holder, name.value))
return name
def execute(self,
operands: List[Expression],
frame: Frame,
gui_holder: Holder,
eval_operands=True):
new_frame = Frame(self.name,
self.frame if self.lexically_scoped else frame)
if eval_operands and self.evaluates_operands:
operands = evaluate_all(operands, frame,
gui_holder.expression.children[1:])
if self.var_param:
verify_min_callable_length(self, len(self.params), len(operands))
else:
verify_exact_callable_length(self, len(self.params), len(operands))
if len(self.body) > 1:
body = [Pair(Symbol("begin"), make_list(self.body))]
else:
body = self.body
for param, value in zip(self.params, operands):
new_frame.assign(param, value)
if self.var_param:
new_frame.assign(self.var_param,
make_list(operands[len(self.params):]))
out = None
gui_holder.expression.set_entries([
VisualExpression(expr, gui_holder.expression.display_value)
for expr in body
])
gui_holder.apply()
for i, expression in enumerate(body):
out = evaluate(expression,
new_frame,
gui_holder.expression.children[i],
self.evaluates_operands and i == len(body) - 1,
log_stack=len(self.body) == 1)
new_frame.assign(return_symbol, out)
if not self.evaluates_operands:
gui_holder.expression.set_entries(
[VisualExpression(out, gui_holder.expression.display_value)])
out = evaluate(out, frame, gui_holder.expression.children[i], True)
return out
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_min_callable_length(self, 1, len(operands))
if (len(operands) > 2):
verify_exact_callable_length(self, 2, len(operands))
if (not isinstance(operands[0], Number)):
raise OperandDeduceError(
''.join(['Expected radius to be Number, not ', '{}'.format(operands[0])]))
if ((len(operands) > 2) and (not isinstance(operands[1], Number))):
raise OperandDeduceError(
''.join(['Expected angle to be Number, not ', '{}'.format(operands[1])]))
degs = (360 if (len(operands) == 1) else operands[1].value)
log.logger.get_canvas().arc(operands[0].value, degs)
return Undefined
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_min_callable_length(self, 1, len(operands))
if len(operands) > 2:
verify_exact_callable_length(self, 2, len(operands))
if not isinstance(operands[0], Number):
raise OperandDeduceError(
f"Expected radius to be Number, not {operands[0]}")
if len(operands) > 2 and not isinstance(operands[1], Number):
raise OperandDeduceError(
f"Expected angle to be Number, not {operands[1]}")
degs = 360 if len(operands) == 1 else operands[1].value
log.logger.get_canvas().arc(operands[0].value, degs)
return Undefined
def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder):
verify_min_callable_length(self, 1, len(operands))
for cond_i, cond in enumerate(operands):
if not isinstance(cond, Pair):
raise OperandDeduceError(f"Unable to evaluate clause of cond, as {cond} is not a Pair.")
expanded = pair_to_list(cond)
cond_holder = gui_holder.expression.children[cond_i + 1]
eval_condition = SingletonTrue
if not isinstance(expanded[0], Symbol) or expanded[0].value != "else":
eval_condition = evaluate(expanded[0], frame, cond_holder.expression.children[0])
if (isinstance(expanded[0], Symbol) and expanded[0].value == "else") \
or eval_condition is not SingletonFalse:
out = eval_condition
for i, expr in enumerate(expanded[1:]):
out = evaluate(expr, frame, cond_holder.expression.children[i + 1], i == len(expanded) - 2)
return out
return Undefined
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
bindings = operands[0]
if ((not isinstance(bindings, Pair)) and (bindings is not Nil)):
raise OperandDeduceError(''.join([
'Expected first argument of let to be a Pair, not ',
'{}'.format(bindings), '.'
]))
new_frame = Frame('anonymous let', frame)
gui_holder.expression.children[1].link_visual(
VisualExpression(bindings))
bindings_holder = gui_holder.expression.children[1]
bindings = pair_to_list(bindings)
for (i, binding) in enumerate(bindings):
if (not isinstance(binding, Pair)):
raise OperandDeduceError(''.join([
'Expected binding to be a Pair, not ',
'{}'.format(binding), '.'
]))
binding_holder = bindings_holder.expression.children[i]
binding_holder.link_visual(VisualExpression(binding))
binding = pair_to_list(binding)
if (len(binding) != 2):
raise OperandDeduceError(''.join([
'Expected binding to be of length 2, not ',
'{}'.format(len(binding)), '.'
]))
(name, expr) = binding
if (not isinstance(name, Symbol)):
raise OperandDeduceError(''.join([
'Expected first element of binding to be a Symbol, not ',
'{}'.format(name), '.'
]))
new_frame.assign(
name,
evaluate(expr, frame, binding_holder.expression.children[1]))
value = None
for (i, (operand, holder)) in enumerate(
zip(operands[1:], gui_holder.expression.children[2:])):
value = evaluate(operand, new_frame, holder,
(i == (len(operands) - 2)))
new_frame.assign(return_symbol, value)
return value
