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