def read_tail(t, tokens):
if len(tokens) == 0:
raise SyntaxError("unexpected end of line")
if is_post(tokens[0]):
tokens.pop(0)
return Pair(t, nil)
first = t
read_first = read(tokens)
rest = read_tail(read_first, tokens)
return Pair(first, rest)
def read_tail(tokens, bracket):
if not tokens:
raise SyntaxError('unexpected end of line')
token = tokens[0]
n = coerce_to_number(token)
if token == bracket:
tokens.pop(0)
return nil
elif n != None:
tokens.pop(0)
return Pair(n, read_tail(tokens, bracket))
else:
return Pair(brack_read(tokens), read_tail(tokens, bracket))
def scheme_append(*vals): # 参数是多个Pair表示的list。
if len(vals) == 0:
return nil
result = vals[-1]
for i in range(len(vals) - 2, -1, -1): # 从后往前遍历传入的list。
v = vals[i]
if v is not nil:
check_type(v, scheme_pairp, i, 'append')
r = p = Pair(v.first, result)
v = v.rest
while scheme_pairp(v):
p.rest = Pair(v.first, result) # 头插法。
p = p.rest
v = v.rest
result = r
return result
def scheme_append(*vals):
if len(vals) == 0:
return nil
result = vals[-1]
for i in range(len(vals) - 2, -1, -1):
v = vals[i]
if v is not nil:
validate_type(v, scheme_pairp, i, 'append')
r = p = Pair(v.first, result)
v = v.rest
while scheme_pairp(v):
p.rest = Pair(v.first, result)
p = p.rest
v = v.rest
result = r
return result
def read_tail(tokens):
if not tokens:
raise SyntaxError('unexpected end of line')
if tokens[0] in LEFT_RIGHT.values():
return nil
else:
return Pair(brack_read(tokens), read_tail(tokens))
def map(self, fn):
"""Return a Scheme list after mapping Python function FN to SELF."""
mapped = fn(self.first)
if self.second is nil or isinstance(self.second, Pair):
return Pair(mapped, self.second.map(fn))
else:
raise TypeError("ill-formed list")
def scheme_append(*vals):
if len(vals) == 0:
return nil
result = vals[-1]
for i in range(len(vals) - 2, -1, -1):
v = vals[i]
if v is not nil:
check_type(v, scheme_pairp, i, 'append')
r = p = Pair(v.first, result)
v = v.second
while scheme_pairp(v):
p.second = Pair(v.first, result)
p = p.second
v = v.second
result = r
return result
def read_tail(src):
if src.current() is None:
raise SyntaxError("unexpected end of file")
if tokens[0] in LEFT_RIGHT.values():
return nil
first = brack_read(tokens)
rest = read_tail(tokens)
return Pair(first, rest)
def read_tail(tokens):
if not tokens:
raise SyntaxError('unexpected end of line')
if tokens[0] in LEFT_RIGHT.values():
return nil
first = brack_read(tokens)
rest = read_tail(tokens)
return Pair(first, rest)
def as_scheme_list(*args):
""" Return a recursive list of Pairs that contains the elements of args.
>>> as_scheme_list(1, 2, 3)
Pair(1, Pair(2, Pair(3, nil)))
"""
if len(args) == 0:
return nil
return Pair(args[0], as_scheme_list(*args[1:]))
def read_tail(tokens):
if len(tokens) == 0:
raise SyntaxError("unexpected end of line")
if tokens[0] == ")":
tokens.pop(0)
return nil
first = read(tokens)
rest = read_tail(tokens)
return Pair(first, rest)
def read_tail(tokens, key):
if not tokens:
raise SyntaxError('unexpected end of line')
if tokens[0] == left_to_right[key]:
tokens.pop(0)
return nil
first = brack_read(tokens)
rest = read_tail(tokens, key)
return Pair(first, rest)
def as_scheme_list(*args):
"""Возвращает рекурсивный список пар, содержащий элементы аргументов.
>>> as_scheme_list(1, 2, 3)
Pair(1, Pair(2, Pair(3, nil)))
"""
if len(args) == 0:
return nil
return Pair(args[0], as_scheme_list(*args[1:]))
def read_tail(tokens):
if tokens == []:
raise SyntaxError("unexpected end of line")
if tokens[0] in left_to_right.values():
return nil
else:
first = brack_read(tokens)
rest = read_tail(tokens)
return Pair(first, rest)
def rename_variables(expr, n):
"""Rename all variables in expr with an identifier N."""
if isvar(expr):
return expr + '_' + str(n)
elif scheme_pairp(expr):
return Pair(rename_variables(expr.first, n),
rename_variables(expr.second, n))
else:
return expr
def ground(expr, env):
"""Replace all variables with their values in expr."""
if scheme_symbolp(expr):
resolved = lookup(expr, env)
if expr != resolved:
return ground(resolved, env)
else:
return expr
elif scheme_pairp(expr):
return Pair(ground(expr.first, env), ground(expr.second, env))
else:
return expr
def brack_read(tokens):
"""Return an expression tree for the first well-formed Brackulator
expression in tokens. Tokens in that expression are removed from tokens as
a side effect.
>>> brack_read(tokenize('100'))
100
>>> brack_read(tokenize('([])'))
Pair('-', Pair(Pair('+', nil), nil))
>>> print(brack_read(tokenize('<[2{12 6}](3 4 5)>')))
(* (+ 2 (/ 12 6)) (- 3 4 5))
>>> brack_read(tokenize('(1)(1)')) # More than one expression is ok
Pair('-', Pair(1, nil))
>>> brack_read(tokenize('[])')) # Junk after a valid expression is ok
Pair('+', nil)
>>> brack_read(tokenize('([]')) # Missing right bracket
Traceback (most recent call last):
...
SyntaxError: unexpected end of line
>>> brack_read(tokenize('[)]')) # Extra right bracket
Traceback (most recent call last):
...
SyntaxError: unexpected )
>>> brack_read(tokenize('([)]')) # Improper nesting
Traceback (most recent call last):
...
SyntaxError: unexpected )
>>> brack_read(tokenize('')) # No expression
Traceback (most recent call last):
...
SyntaxError: unexpected end of line
"""
if not tokens:
raise SyntaxError('unexpected end of line')
token = tokens.pop(0)
n = coerce_to_number(token)
if n != None:
return n
elif token in LEFT_RIGHT:
"*** YOUR CODE HERE ***"
expression = read_tail(tokens)
right_closing = tokens.pop(0)
if LEFT_RIGHT[token] != right_closing:
raise SyntaxError('unexpected ' + right_closing)
else:
return Pair(BRACKETS[(token, right_closing)], expression)
else:
raise SyntaxError('unexpected ' + token)
def helper(tokens):
translation = []
if tokens == []:
raise SyntaxError("unexpected end of line")
val = tokens.pop(0)
if type(val) in (int, float): return val
try:
if LEFT_RIGHT[val] in tokens:
while tokens[0] != LEFT_RIGHT[val]:
translation.append(helper(tokens))
tokens.pop(0)
return Pair(BRACKETS[(val, LEFT_RIGHT[val])],
enlist(translation))
else:
raise SyntaxError('unexpected end of line')
except KeyError:
raise SyntaxError('unexpected ' + val)
def tscheme_pos():
"""Current position"""
pos = turtle.pos()
return Pair(pos[0], Pair(pos[1], nil))
def scheme_list(*vals):
result = nil
for e in reversed(vals):
result = Pair(e, result)
return result
def scheme_cons(x, y):
return Pair(x, y)
def scheme_list(*vals):
result = nil
for i in range(len(vals)-1, -1, -1):
result = Pair(vals[i], result)
return result
def enlist(alist):
if alist == []:
return nil
else:
return Pair(alist[0], enlist(alist[1:]))
def as_scheme_list(*args):
"""Return a recurisive list of Pairs that contains the elements of args."""
if len(args) == 0:
return nil
return Pair(args[0], as_scheme_list(*args[1:]))
def complex_to_list(z):
"""Transforms a complex number to the scheme list (a . b)."""
return Pair(z.real, z.imag)