|
| 1 | +################ Lispy: Scheme Interpreter in Python 3.3+ |
| 2 | + |
| 3 | +## (c) Peter Norvig, 2010-18; See http://norvig.com/lispy.html |
| 4 | + |
| 5 | +################ Imports and Types |
| 6 | + |
| 7 | +import math |
| 8 | +import operator as op |
| 9 | +from collections import ChainMap as Environment |
| 10 | + |
| 11 | +Symbol = str # A Lisp Symbol is implemented as a Python str |
| 12 | +List = list # A Lisp List is implemented as a Python list |
| 13 | +Number = (int, float) # A Lisp Number is implemented as a Python int or float |
| 14 | + |
| 15 | +class Procedure(object): |
| 16 | + "A user-defined Scheme procedure." |
| 17 | + def __init__(self, parms, body, env): |
| 18 | + self.parms, self.body, self.env = parms, body, env |
| 19 | + def __call__(self, *args): |
| 20 | + env = Environment(dict(zip(self.parms, args)), self.env) |
| 21 | + for exp in self.body: |
| 22 | + result = eval(exp, env) |
| 23 | + return result |
| 24 | + |
| 25 | + |
| 26 | +################ Global Environment |
| 27 | + |
| 28 | +def standard_env(): |
| 29 | + "An environment with some Scheme standard procedures." |
| 30 | + env = {} |
| 31 | + env.update(vars(math)) # sin, cos, sqrt, pi, ... |
| 32 | + env.update({ |
| 33 | + '+':op.add, '-':op.sub, '*':op.mul, '/':op.truediv, |
| 34 | + '>':op.gt, '<':op.lt, '>=':op.ge, '<=':op.le, '=':op.eq, |
| 35 | + 'abs': abs, |
| 36 | + 'append': op.add, |
| 37 | + 'apply': lambda proc, args: proc(*args), |
| 38 | + 'begin': lambda *x: x[-1], |
| 39 | + 'car': lambda x: x[0], |
| 40 | + 'cdr': lambda x: x[1:], |
| 41 | + 'cons': lambda x,y: [x] + y, |
| 42 | + 'eq?': op.is_, |
| 43 | + 'equal?': op.eq, |
| 44 | + 'length': len, |
| 45 | + 'list': lambda *x: list(x), |
| 46 | + 'list?': lambda x: isinstance(x,list), |
| 47 | + 'map': lambda *args: list(map(*args)), |
| 48 | + 'max': max, |
| 49 | + 'min': min, |
| 50 | + 'not': op.not_, |
| 51 | + 'null?': lambda x: x == [], |
| 52 | + 'number?': lambda x: isinstance(x, Number), |
| 53 | + 'procedure?': callable, |
| 54 | + 'round': round, |
| 55 | + 'symbol?': lambda x: isinstance(x, Symbol), |
| 56 | + }) |
| 57 | + return env |
| 58 | + |
| 59 | +global_env = standard_env() |
| 60 | + |
| 61 | +################ Parsing: parse, tokenize, and read_from_tokens |
| 62 | + |
| 63 | +def parse(program): |
| 64 | + "Read a Scheme expression from a string." |
| 65 | + return read_from_tokens(tokenize(program)) |
| 66 | + |
| 67 | +def tokenize(s): |
| 68 | + "Convert a string into a list of tokens." |
| 69 | + return s.replace('(',' ( ').replace(')',' ) ').split() |
| 70 | + |
| 71 | +def read_from_tokens(tokens): |
| 72 | + "Read an expression from a sequence of tokens." |
| 73 | + if len(tokens) == 0: |
| 74 | + raise SyntaxError('unexpected EOF while reading') |
| 75 | + token = tokens.pop(0) |
| 76 | + if '(' == token: |
| 77 | + L = [] |
| 78 | + while tokens[0] != ')': |
| 79 | + L.append(read_from_tokens(tokens)) |
| 80 | + tokens.pop(0) # pop off ')' |
| 81 | + return L |
| 82 | + elif ')' == token: |
| 83 | + raise SyntaxError('unexpected )') |
| 84 | + else: |
| 85 | + return atom(token) |
| 86 | + |
| 87 | +def atom(token): |
| 88 | + "Numbers become numbers; every other token is a symbol." |
| 89 | + try: return int(token) |
| 90 | + except ValueError: |
| 91 | + try: return float(token) |
| 92 | + except ValueError: |
| 93 | + return Symbol(token) |
| 94 | + |
| 95 | +################ Interaction: A REPL |
| 96 | + |
| 97 | +def repl(prompt='lis.py> '): |
| 98 | + "A prompt-read-eval-print loop." |
| 99 | + while True: |
| 100 | + val = eval(parse(input(prompt))) |
| 101 | + if val is not None: |
| 102 | + print(lispstr(val)) |
| 103 | + |
| 104 | +def lispstr(exp): |
| 105 | + "Convert a Python object back into a Lisp-readable string." |
| 106 | + if isinstance(exp, List): |
| 107 | + return '(' + ' '.join(map(lispstr, exp)) + ')' |
| 108 | + else: |
| 109 | + return str(exp) |
| 110 | + |
| 111 | +################ eval |
| 112 | + |
| 113 | +def eval(x, env=global_env): |
| 114 | + "Evaluate an expression in an environment." |
| 115 | + if isinstance(x, Symbol): # variable reference |
| 116 | + return env[x] |
| 117 | + elif not isinstance(x, List): # constant literal |
| 118 | + return x |
| 119 | + elif x[0] == 'quote': # (quote exp) |
| 120 | + (_, exp) = x |
| 121 | + return exp |
| 122 | + elif x[0] == 'if': # (if test conseq alt) |
| 123 | + (_, test, conseq, alt) = x |
| 124 | + exp = (conseq if eval(test, env) else alt) |
| 125 | + return eval(exp, env) |
| 126 | + elif x[0] == 'define': # (define var exp) |
| 127 | + (_, var, exp) = x |
| 128 | + env[var] = eval(exp, env) |
| 129 | + elif x[0] == 'lambda': # (lambda (var...) body) |
| 130 | + (_, parms, *body) = x |
| 131 | + return Procedure(parms, body, env) |
| 132 | + else: # (proc arg...) |
| 133 | + proc = eval(x[0], env) |
| 134 | + args = [eval(exp, env) for exp in x[1:]] |
| 135 | + return proc(*args) |
0 commit comments