This directory contains:

* `original/`:

Norvig's [`lis.py`](https://github.com/norvig/pytudes/blob/c33cd6835a506a57d9fe73e3a8317d49babb13e8/py/lis.py),

[`lispy.py`](https://github.com/norvig/pytudes/blob/c33cd6835a506a57d9fe73e3a8317d49babb13e8/py/lispy.py), and the `lispytest.py` custom test script for testing both;

* `py3.10/`: `lis.py` with type hints, pattern matching, and minor edits—requires Python 3.10.

The `py3.10/` directory also has `lis_test.py` to run with

[pytest](https://docs.pytest.org), including all the

[`lis_tests` suite](https://github.com/norvig/pytudes/blob/60168bce8cdfacf57c92a5b2979f0b2e95367753/py/lispytest.py#L5)

from `original/lispytest.py`,

and additional separate tests for each expression and special form handled by `evaluate`.

`lis.py` is

[published](https://github.com/norvig/pytudes/blob/c33cd6835a506a57d9fe73e3a8317d49babb13e8/py/lis.py)

in the [norvig/pytudes](https://github.com/norvig/pytudes) repository on Github.

The copyright holder is Peter Norvig and the code is licensed under the

[MIT license](https://github.com/norvig/pytudes/blob/60168bce8cdfacf57c92a5b2979f0b2e95367753/LICENSE).

I made small changes to the programs in `original/`:

* In `lis.py`:

* The `Procedure` class accepts a list of expressions as the `body`, and `__call__` evaluates all those expressions in order, returning the value of the last. This is consistent with Scheme's `lambda` syntax and provided a useful example for pattern matching.

* In the `elif` block for `'lambda'`, I added the `*` in front of the `*body` variable in the tuple unpacking to capture the expressions as a list, before calling the `Procedure` constructor.

* In `lispy.py` I made [changes and a pull request](https://github.com/norvig/pytudes/pull/106) to make it run on Python 3.

_Luciano Ramalho<br/>June 29, 2021_

import math

import operator as op

from collections import ChainMap as Environment

Symbol = str # A Lisp Symbol is implemented as a Python str

List = list # A Lisp List is implemented as a Python list

Number = (int, float) # A Lisp Number is implemented as a Python int or float

class Procedure(object):

"A user-defined Scheme procedure."

def __init__(self, parms, body, env):

self.parms, self.body, self.env = parms, body, env

def __call__(self, *args):

env = Environment(dict(zip(self.parms, args)), self.env)

for exp in self.body:

result = eval(exp, env)

return result

def standard_env():

"An environment with some Scheme standard procedures."

env = {}

env.update(vars(math)) # sin, cos, sqrt, pi, ...

env.update({

'+':op.add, '-':op.sub, '*':op.mul, '/':op.truediv,

'>':op.gt, '<':op.lt, '>=':op.ge, '<=':op.le, '=':op.eq,

'abs': abs,

'append': op.add,

'apply': lambda proc, args: proc(*args),

'begin': lambda *x: x[-1],

'car': lambda x: x[0],

'cdr': lambda x: x[1:],

'cons': lambda x,y: [x] + y,

'eq?': op.is_,

'equal?': op.eq,

'length': len,

'list': lambda *x: list(x),

'list?': lambda x: isinstance(x,list),

'map': lambda *args: list(map(*args)),

'max': max,

'min': min,

'not': op.not_,

'null?': lambda x: x == [],

'number?': lambda x: isinstance(x, Number),

'procedure?': callable,

'round': round,

'symbol?': lambda x: isinstance(x, Symbol),

})

return env

global_env = standard_env()

def parse(program):

"Read a Scheme expression from a string."

return read_from_tokens(tokenize(program))

def tokenize(s):

"Convert a string into a list of tokens."

return s.replace('(',' ( ').replace(')',' ) ').split()

def read_from_tokens(tokens):

"Read an expression from a sequence of tokens."

if len(tokens) == 0:

raise SyntaxError('unexpected EOF while reading')

token = tokens.pop(0)

if '(' == token:

L = []

while tokens[0] != ')':

L.append(read_from_tokens(tokens))

tokens.pop(0) # pop off ')'

return L

elif ')' == token:

raise SyntaxError('unexpected )')

else:

return atom(token)

def atom(token):

"Numbers become numbers; every other token is a symbol."

try: return int(token)

except ValueError:

try: return float(token)

except ValueError:

return Symbol(token)

def repl(prompt='lis.py> '):

"A prompt-read-eval-print loop."

while True:

val = eval(parse(input(prompt)))

if val is not None:

print(lispstr(val))

def lispstr(exp):

"Convert a Python object back into a Lisp-readable string."

if isinstance(exp, List):

return '(' + ' '.join(map(lispstr, exp)) + ')'

else:

return str(exp)

def eval(x, env=global_env):

"Evaluate an expression in an environment."

if isinstance(x, Symbol): # variable reference

return env[x]

elif not isinstance(x, List): # constant literal

return x

elif x[0] == 'quote': # (quote exp)

(_, exp) = x

return exp

elif x[0] == 'if': # (if test conseq alt)

(_, test, conseq, alt) = x

exp = (conseq if eval(test, env) else alt)

return eval(exp, env)

elif x[0] == 'define': # (define var exp)

(_, var, exp) = x

env[var] = eval(exp, env)

elif x[0] == 'lambda': # (lambda (var...) body)

(_, parms, *body) = x

return Procedure(parms, body, env)

else: # (proc arg...)

proc = eval(x[0], env)

args = [eval(exp, env) for exp in x[1:]]

return proc(*args)