sync with O'Reilly Atlas

Author: ramalho

02-array-seq/lispy/examples_test.py

@@ -0,0 +1,109 @@
+"""
+Doctests for `parse`:
+
+>>> from lis import parse
+
+# tag::PARSE_DEMO[]
+>>> parse('1.5')  # <1>
+1.5
+>>> parse('set!')  # <2>
+'set!'
+>>> parse('(gcd 18 44)')  # <3>
+['gcd', 18, 44]
+>>> parse('(- m (* n (// m n)))')  # <4>
+['-', 'm', ['*', 'n', ['//', 'm', 'n']]]
+
+# end::PARSE_DEMO[]
+
+"""
+
+import math
+
+from lis import run
+
+
+fact_src = """
+(define (! n)
+    (if (< n 2)
+        1
+        (* n (! (- n 1)))
+    )
+)
+(! 42)
+"""
+def test_factorial():
+    got = run(fact_src)
+    assert got == 1405006117752879898543142606244511569936384000000000
+    assert got == math.factorial(42)
+
+
+gcd_src = """
+(define (mod m n)
+    (- m (* n (// m n))))
+(define (gcd m n)
+    (if (= n 0)
+        m
+        (gcd n (mod m n))))
+(gcd 18 45)
+"""
+def test_gcd():
+    got = run(gcd_src)
+    assert got == 9
+
+
+quicksort_src = """
+(define (quicksort lst)
+    (if (null? lst)
+        lst
+        (begin
+            (define pivot (car lst))
+            (define rest (cdr lst))
+            (append
+                (quicksort
+                    (filter (lambda (x) (< x pivot)) rest))
+                (list pivot)
+                (quicksort
+                    (filter (lambda (x) (>= x pivot)) rest)))
+        )
+    )
+)
+(quicksort (list 2 1 6 3 4 0 8 9 7 5))
+"""
+def test_quicksort():
+    got = run(quicksort_src)
+    assert got == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+
+# Example from Structure and Interpretation of Computer Programs
+# https://mitpress.mit.edu/sites/default/files/sicp/full-text/sicp/book/node12.html
+
+newton_src = """
+(define (sqrt x)
+    (sqrt-iter 1.0 x))
+(define (sqrt-iter guess x)
+    (if (good-enough? guess x)
+        guess
+        (sqrt-iter (improve guess x) x)))
+(define (good-enough? guess x)
+    (< (abs (- (* guess guess) x)) 0.001))
+(define (improve guess x)
+    (average guess (/ x guess)))
+(define (average x y)
+    (/ (+ x y) 2))
+(sqrt 123454321)
+"""
+def test_newton():
+    got = run(newton_src)
+    assert math.isclose(got, 11111)
+
+
+closure_src = """
+(define (make-adder increment)
+    (lambda (x) (+ increment x))
+)
+(define inc (make-adder 1))
+(inc 99)
+"""
+def test_newton():
+    got = run(closure_src)
+    assert got == 100

18-context-mngr/lispy/py3.10/lis.py renamed to 02-array-seq/lispy/lis.py

@@ -1,15 +1,16 @@
-################ Lispy: Scheme Interpreter in Python 3.9
+################ Lispy: Scheme Interpreter in Python 3.10
 
 ## (c) Peter Norvig, 2010-18; See http://norvig.com/lispy.html
 ## Minor edits for Fluent Python, Second Edition (O'Reilly, 2021)
 ## by Luciano Ramalho, adding type hints and pattern matching.
 
-################ Imports and Types
+################ imports and types
 
 import math
 import operator as op
 from collections import ChainMap
-from collections.abc import MutableMapping
+from collections.abc import MutableMapping, Iterator
+from itertools import chain
 from typing import Any, TypeAlias
 
 Symbol: TypeAlias = str
@@ -23,41 +24,44 @@ class Procedure:
     "A user-defined Scheme procedure."
 
     def __init__(self, parms: list[Symbol], body: Expression, env: Environment):
-        self.parms, self.body, self.env = parms, body, env
+        self.parms = parms
+        self.body = body
+        self.env = env
 
     def __call__(self, *args: Expression) -> Any:
         local_env = dict(zip(self.parms, args))
         env: Environment = ChainMap(local_env, self.env)
         return evaluate(self.body, env)
 
 
-################ Global Environment
+################ global environment
 
 
 def standard_env() -> Environment:
     "An environment with some Scheme standard procedures."
     env: Environment = {}
     env.update(vars(math))   # sin, cos, sqrt, pi, ...
-    env.update(
-        {
+    env.update({
             '+': op.add,
             '-': op.sub,
             '*': op.mul,
             '/': op.truediv,
+            '//': op.floordiv,
             '>': op.gt,
             '<': op.lt,
             '>=': op.ge,
             '<=': op.le,
             '=': op.eq,
             'abs': abs,
-            'append': op.add,
+            'append': lambda *args: list(chain(*args)),
             '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,
+            'filter': lambda *args: list(filter(*args)),
             'length': len,
             'list': lambda *x: list(x),
             'list?': lambda x: isinstance(x, list),
@@ -70,12 +74,11 @@ def standard_env() -> Environment:
             'procedure?': callable,
             'round': round,
             'symbol?': lambda x: isinstance(x, Symbol),
-        }
-    )
+    })
     return env
 
 
-################ Parsing: parse, tokenize, and read_from_tokens
+################ parse, tokenize, and read_from_tokens
 
 
 def parse(program: str) -> Expression:
@@ -94,11 +97,11 @@ def read_from_tokens(tokens: list[str]) -> Expression:
         raise SyntaxError('unexpected EOF while reading')
     token = tokens.pop(0)
     if '(' == token:
-        L = []
+        exp = []
         while tokens[0] != ')':
-            L.append(read_from_tokens(tokens))
-        tokens.pop(0)   # pop off ')'
-        return L
+            exp.append(read_from_tokens(tokens))
+        tokens.pop(0)  # discard ')'
+        return exp
     elif ')' == token:
         raise SyntaxError('unexpected )')
     else:
@@ -116,7 +119,7 @@ def parse_atom(token: str) -> Atom:
             return Symbol(token)
 
 
-################ Interaction: A REPL
+################ interaction: a REPL
 
 
 def repl(prompt: str = 'lis.py> ') -> None:
@@ -138,29 +141,50 @@ def lispstr(exp: object) -> str:
 
 ################ eval
 
-
-def evaluate(x: Expression, env: Environment) -> Any:
+# tag::EVALUATE[]
+def evaluate(exp: Expression, env: Environment) -> Any:
     "Evaluate an expression in an environment."
-    match x:
-        case Symbol(var):                               # variable reference
+    match exp:
+        case int(x) | float(x):
+            return x
+        case Symbol(var):
             return env[var]
-        case literal if not isinstance(x, list):        # constant literal
-            return literal
-        case ['quote', exp]:                            # (quote exp)
+        case []:
+            return []
+        case ['quote', exp]:
             return exp
-        case ['if', test, conseq, alt]:                 # (if test conseq alt)
+        case ['if', test, consequence, alternative]:
             if evaluate(test, env):
-                exp = conseq
+                return evaluate(consequence, env)
             else:
-                exp = alt
-            return evaluate(exp, env)
-        case ['lambda', parms, body]:                   # (lambda (parm...) body)
-            return Procedure(parms, body, env)
-        case ['define', Symbol(var), exp]:              # (define var exp)
-            env[var] = evaluate(exp, env)
-        case ['define', [name, *parms], body]:          # (define (fun parm...) body)
+                return evaluate(alternative, env)
+        case ['define', Symbol(var), value_exp]:
+            env[var] = evaluate(value_exp, env)
+        case ['define', [Symbol(name), *parms], body]:
             env[name] = Procedure(parms, body, env)
-        case [op, *args]:                               # (proc arg...)
+        case ['lambda', [*parms], body]:
+            return Procedure(parms, body, env)
+        case [op, *args]:
             proc = evaluate(op, env)
-            values = (evaluate(arg, env) for arg in args)
+            values = [evaluate(arg, env) for arg in args]
             return proc(*values)
+        case _:
+            raise SyntaxError(repr(exp))
+# end::EVALUATE[]
+
+
+################ non-interactive execution
+
+
+def run_lines(source: str) -> Iterator[Any]:
+    global_env: Environment = standard_env()
+    tokens = tokenize(source)
+    while tokens:
+        exp = read_from_tokens(tokens)
+        yield evaluate(exp, global_env)
+
+
+def run(source: str) -> Any:
+    for result in run_lines(source):
+        pass
+    return result

18-context-mngr/lispy/py3.10/lis_test.py renamed to 02-array-seq/lispy/lis_test.py

@@ -4,6 +4,23 @@
 
 from lis import parse, evaluate, Expression, Environment, standard_env
 
+############################################################# tests for parse
+
+@mark.parametrize( 'source, expected', [
+    ('7', 7),
+    ('x', 'x'),
+    ('(sum 1 2 3)', ['sum', 1, 2, 3]),
+    ('(+ (* 2 100) (* 1 10))', ['+', ['*', 2, 100], ['*', 1, 10]]),
+    ('99 100', 99),  # parse stops at the first complete expression
+    ('(a)(b)', ['a']),  
+])
+def test_parse(source: str, expected: Expression) -> None:
+    got = parse(source)
+    assert got == expected
+
+
+########################################################## tests for evaluate
+
 # Norvig's tests are not isolated: they assume the
 # same environment from first to last test.
 global_env_for_first_test = standard_env()

02-array-seq/lispy/meta_test.py

@@ -0,0 +1,64 @@
+import operator as op
+
+from lis import run
+
+env_scm = """
+(define standard-env (list
+    (list (quote +) +)
+    (list (quote -) -)
+))
+standard-env
+"""
+
+def test_env_build():
+    got = run(env_scm)
+    assert got == [['+', op.add], ['-', op.sub]]
+
+scan_scm = """
+(define l (quote (a b c)))
+(define (scan what where)
+    (if (null? where)
+        ()
+        (if (eq? what (car where))
+            what
+            (scan what (cdr where))))
+)
+"""
+
+def test_scan():
+    source = scan_scm + '(scan (quote a) l )'
+    got = run(source)
+    assert got == 'a'
+
+
+def test_scan_not_found():
+    source = scan_scm + '(scan (quote z) l )'
+    got = run(source)
+    assert got == []
+
+
+lookup_scm = """
+(define env (list
+    (list (quote +) +)
+    (list (quote -) -)
+))
+(define (lookup what where)
+    (if (null? where)
+        ()
+        (if (eq? what (car (car where)))
+            (car (cdr (car where)))
+            (lookup what (cdr where))))
+)
+"""
+
+def test_lookup():
+    source = lookup_scm + '(lookup (quote +) env)'
+    got = run(source)
+    assert got == op.add
+
+
+def test_lookup_not_found():
+    source = lookup_scm + '(lookup (quote z) env )'
+    got = run(source)
+    assert got == []
+