diff --git a/ipynb/lispy.ipynb b/ipynb/lispy.ipynb index 46af1ec..ab2b2a6 100644 --- a/ipynb/lispy.ipynb +++ b/ipynb/lispy.ipynb @@ -2,65 +2,77 @@ "cells": [ { "cell_type": "markdown", - "id": "61b75f91-0729-4bc0-a107-f77a4a62eb98", + "id": "828d21f7-0a3b-4024-b3d5-306ea56a3214", "metadata": {}, "source": [ "
Peter Norvig
\n", "\n", "# (How to Write a (Lisp) Interpreter (in Python))\n", "\n", - "This notebook describes how to implement computer language interpreters in general, and in particular an interpreter for most of the [**Scheme**](https://www.scheme.org/) dialect of [**Lisp**](https://en.wikipedia.org/wiki/Lisp_(programming_language%29). I call my language and interpreter **Lispy** because it is Lisp implemented in Python (lis.py). Years ago, I showed how to write a semi-practical near-complete Scheme interpreter (one in [Java](https://norvig.com/jscheme.html) and one in [Common Lisp](https://github.com/norvig/paip-lisp/blob/main/docs/chapter22.md)). This time the goal is simplicity. \n", + "This notebook describes how (and why) to implement computer language interpreters in general, and in particular an interpreter for most of the [**Scheme**](https://www.scheme.org/) dialect of [**Lisp**](https://en.wikipedia.org/wiki/Lisp_(programming_language%29). I call my language and interpreter **Lispy** because it is Lisp implemented in Python. \n", "\n", "Why should interpreters and compilers matter to you? As [Steve Yegge said](https://steve-yegge.blogspot.com/2007/06/rich-programmer-food.html?), \"If you don't know how compilers work, then you don't know how computers work.\" Yegge describes 8 problems that can be solved with compilers (or equally well with interpreters, or with Yegge's typical heavy dosage of cynicism).\n", "\n", "## Syntax and Semantics of Programs\n", "\n", - "The syntax of a language is the arrangement of characters to form correct statements or expressions. For example, in the language of mathematical expressions (and in many programming languages), the syntax for adding one plus two is \"1 + 2\". The semantics of a language determines what it means. We say we are evaluating an expression when we determine its value; we would say that \"1 + 2\" evaluates to 3, and write that as \"1 + 2\" ⇒ 3. \n", + "The **syntax** of a language is the arrangement of characters to form correct statements or expressions. For example, in the language of mathematical expressions (and in many programming languages and handheld calculators), the syntax for computing one plus two is \"1 + 2\". The **semantics** of a language determines what it means: what computations it describes, and ultimately what answer(s) it computes. We say that \"1 + 2\" *evaluates* to 3, and write that as \"1 + 2\" ⇒ 3. \n", "\n", - "Scheme syntax is different from most other programming languages. Consider:\n", + "If you are familiar with languages such as Python or Java, you may find Scheme syntax to be unusual. Consider:\n", "\n", - " Java\t \t | Scheme\n", - " ----------------------------------------------+-------------------------------\n", - " if (x.val() > 0) { | (if (> (val x) 0)\n", - " return fn(A[i] + 3 * i, | (fn (+ (aref A i) (* 3 i))\n", - " new String[] {\"one\", \"two\"}); | (quote (one two))))\n", - " } |\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
JavaLisp
\n", + "
if (x.val() > 0) {\n",
+    "    return fn(A[i] + 3 * i,\n",
+    "              new String[] {\"one\", \"two\"});\n",
+    "}
\n", + " 		\n", + "
(if (> (val x) 0)\n",
+    "    (fn (+ (aref A i) (* 3 i))\n",
+    "        (quote (one two))))
\n", + "
\n", "\n", - "Java has a wide variety of syntactic conventions (keywords, infix operators, three kinds of brackets, operator precedence, dot notation, quotes, commas, semicolons), but Scheme syntax is much simpler:\n", + "Java has a wide variety of syntactic conventions (keywords, infix operators, four kinds of brackets, operator precedence, dot notation, quotes, commas, semicolons), but Scheme syntax is much simpler:\n", "Scheme programs consist solely of expressions; there is no statement/expression distinction.\n", - "Numbers (e.g. 1) and symbols (e.g. A) are called atomic expressions; they cannot be broken into pieces. These are similar to their Java counterparts, except that in Scheme, operators such as `+` and `>` are symbols too, and are treated the same way as `A` and `fn`.\n", - "Everything else is a list expression: a \"(\", followed by zero or more expressions, followed by a \")\". The first element of the list determines what it means:\n", + "Numbers (e.g. 1) and symbols (e.g. A) are called **atomic expressions**; they cannot be broken into pieces. These are similar to their Java counterparts, except that in Scheme, operators such as `+` and `>` are symbols too, and are treated the same way as `A` and `fn`.\n", + "Everything else is a **list expression**: a \"(\", followed by zero or more expressions, followed by a \")\". The first element of the list expression determines what it means:\n", "- A list starting with a keyword, e.g. `(if ...)`, is a **special form**; the meaning depends on the keyword.\n", - "- A list starting with a non-keyword, e.g. `(sqrt x)`, is a function call: the function `sqrt` is applied to the argument, `x`, to compute a value.\n", + "- A list starting with a non-keyword, e.g. `(max x y)`, is a function call: the function `max` is applied to the arguments `x` and `y` to compute a value.\n", "\n", - "The beauty of Scheme is that the full language only needs 5 keywords and 8 syntactic forms. In comparison, Python has 33 keywords and 110 syntactic forms, and Java has 50 keywords and 133 syntactic forms. All those parentheses may seem intimidating, but Scheme syntax has the virtues of simplicity and consistency. (Some have joked that \"Lisp\" stands for \"**L**ots of **I**rritating **S**illy **P**arentheses\"; I think it stand for \"**L**isp **I**s **S**yntactically **P**ure\".)\n", + "The beauty of Scheme is that the full language only needs 5 keywords and 8 syntactic forms. In comparison, Python has 35 keywords and 110 syntactic forms, and Java has 50 keywords and 133 syntactic forms. All those parentheses may seem intimidating, but Scheme syntax has the virtues of simplicity and consistency. (Some have joked that \"Lisp\" stands for \"**L**ots of **I**rritating **S**illy **P**arentheses\"; I think it stand for \"**L**isp **I**s **S**yntactically **P**ure\".)\n", "\n", "\n", - "How do we go from syntax to semantics? Here is the traditional approach:\n", - "- **Parsing**: A function called `parse` takes the program (a sequence of characters) as input and transforms it into an internal representation, called an **abstract syntax tree**, that closely mirrors the nested structure of statements or expressions in the program. This will be done in two steps. First, the function`tokenize` breaks up the characters into tokens (symbols such as parentheses, numbers such as `123`, and symbols such as `if`).Second, the function `read_from_tokens` converts the tokens into the abstract syntax tree.\n", - "- **Execution**: A function called `eval` evaluates the syntax tree to produce the value of the program. \n", - "\n", "# Language 1: Lispy Calculator\n", "\n", - "We won't tackle all of Scheme right away; instead we'll start with a subset of Scheme I call **Lispy Calculator**. Lispy Calculator lets you do any computation you could do on a typical calculator—as long as you are comfortable with prefix notation. And you can do two things that are not offered in most calculators: use an `if` to define a conditional expression, and use a `define` to set the value of a new variable. Here's an example program, that computes the area of a circle of radius 10, using the formula π r2\n", + "We won't tackle all of Scheme right away; instead we'll start with a subset of Scheme I call **Lispy Calculator**. Lispy Calculator lets you do any computation you could do on a typical calculator—as long as you are comfortable with prefix notation. And while many calculators let you store and retrieve a value from a fixed set of registers (e.g. A, B, or C), Lispy Calculator let's you define and use any number of variables with any names you choose. Here's an example program that computes the area of a circle of radius 10, using the formula π r2\n", "\n", " (begin\n", " (define r 10)\n", " (* pi (* r r)))\n", "\n", "\n", - "Here is a table of all the allowable expressions in the Lispy Calculator Language. In the Syntax column of this table, *symbol* must be a symbol, *number* must be an integer or floating point number, and the other italicized words can be any expression. The notation *arg...* means zero or more repetitions of *arg*.\n", + "Here is a table of all the allowable expressions in the Lispy Calculator Language. In the Syntax column of this table, *symbol* must be a symbol, *number* must be an integer or floating point number, and the other italicized words can be any expression. The notation *exp...* means zero or more repetitions of *exp*.\n", "\n", "|Expression\t|Syntax\t|Example|Semantics|\n", "|-----------|-------|-------|-------------|\n", - "|constant literal\t|*number*\t|`12` or `-3.45e+6`|A number evaluates to itself.|\n", - "|variable reference|\t*symbol*\t|`r`|A symbol is interpreted as a variable name; its value is the variable's value.|\n", - "|conditional\t|(`if` *test then_part else_part*`)`|`(if (< x 0) (- x) x)`|\tEvaluate test; if true, evaluate and return conseq; otherwise alt.|\n", - "|definition\t|`(define` *symbol exp*`}`\t|`(define r 10)`|Define a new variable and give it the value of evaluating the expression exp.|\n", - "|procedure call\t|`(`*proc arg*...`)`\t|`(sqrt (* 2 8))` ⇒ 4.0|Evaluate proc and all the args, and then the procedure is applied to the list of arg values.|\n", + "|constant \t|*number*\t|`12` or `-3.45e+6`|A number evaluates to itself.|\n", + "|variable |\t*symbol*\t|`r`|A symbol is interpreted as a variable name; its value is the variable's value.|\n", + "|definition\t|`(define` *symbol exp*`}`\t|`(define r 10)`|Define a new variable and give it the value of the expression *exp*.|\n", + "|procedure call\t|`(`*proc exp*...`)`\t|`(sqrt (* 2 8))` ⇒ 4.0|Proc's value (a function) is applied to the argument values.|\n", "\n", "\n", - "Let's get some imports out of the way, and be explicit about our representations for Scheme object types and their representation in Python:" + "Let's get some imports out of the way, and be explicit about how Scheme objects are represented in Python:" ] }, { @@ -70,16 +82,15 @@ "metadata": {}, "outputs": [], "source": [ - "import numbers\n", + "from numbers import Number\n", "import math\n", "import operator as op\n", "\n", - "Number = numbers.Number # A Scheme Number is implemented as a Python number (e.g., int or float)\n", - "Symbol = str # A Scheme Symbol is implemented as a Python str\n", - "List = list # A Scheme List is implemented as a Python list\n", - "Atom = Symbol | Number # A Scheme Atom is a Symbol or Number\n", + "Symbol = str # A Scheme symbol is implemented as a Python str\n", + "Atom = Symbol | Number # A Scheme atom is a Symbol or Number\n", + "List = list # A Scheme list is implemented as a Python list\n", "Exp = Atom | List # A Scheme expression is an Atom or List\n", - "Env = dict[Symbol, Exp] # A Scheme environment is a dictionary mapping of {variable: value}" + "Env = dict # A Scheme environment is a dictionary mapping of {variable: value}" ] }, { @@ -87,9 +98,9 @@ "id": "b5c1ff1c-15e1-47d2-bfc8-a008ecc5ff13", "metadata": {}, "source": [ - "## Evaluation: eval \n", + "## The core of Lisp: eval \n", "\n", - "Here is the core of the interpreter, `eval`. It takes as input an expression, `exp`, and an **environment** that specifies the values of variables. It returns the value of the expression, given the environment. These few lines are what what [Alan Kay called](https://queue.acm.org/detail.cfm?id=1039523) \"the Maxwell's Equations of Software.\"\n" + "Here is the core of the interpreter, `eval`. It takes as input an expression, `exp`, and an **environment** that specifies the values of variables. It returns the value of the expression. These few lines are what what [Alan Kay called](https://queue.acm.org/detail.cfm?id=1039523) \"the Maxwell's Equations of Software.\"\n" ] }, { @@ -102,17 +113,14 @@ "def eval(exp: Exp, env: Env) -> object:\n", " \"\"\"Evaluate an expression in an environment.\"\"\"\n", " match exp:\n", - " case Number(): # number evaluates to itself \n", + " case Number(): # number evaluates to itself \n", " return exp\n", - " case Symbol(): # variable evaluates to its value in environment\n", + " case Symbol(): # variable evaluates to its value in environment\n", " return env[exp]\n", - " case ('if', test, then, els): # conditional evaluates one branch or the other\n", - " branch = (then if eval(test, env) \n", - " else els)\n", - " return eval(branch, env)\n", - " case ('define', name, exp): # definition adds name to the environment\n", - " env[name] = eval(exp, env)\n", - " case (proc, *args): # procedure call\n", + " case ('define', Symbol(name), val): # definition adds name to the environment\n", + " env[name] = eval(val, env)\n", + " return name\n", + " case (proc, *args): # procedure call\n", " func = eval(proc, env)\n", " vals = [eval(arg, env) for arg in args]\n", " return func(*vals)" @@ -120,26 +128,93 @@ }, { "cell_type": "markdown", - "id": "edafbbc3-ae0b-4705-859e-3fcf2f10fdad", + "id": "e9ae14da-9668-405a-8c5c-2a7186e98cb4", "metadata": {}, "source": [ - "## Parsing: parse, tokenize and read_from_tokens\n", + "## Global Environment\n", "\n", - "How do we get from a sequence of characters to the abstract syntax tree that `eval` expects? The function `parse` does the job, in two steps: \n", - "1. **Lexical analysis**: the function `tokenize` breaks the characters into tokens (such as the keyword `\"begin\"` or the number `\"10\"`).\n", - "2. **Syntactic analysis**: the function `read_from_tokens` converts the tokens into an expression.\n", - "\n", - "There are many tools for lexical analysis (such as Mike Lesk and Eric Schmidt's [lex](https://en.wikipedia.org/wiki/Lex_(software%29)), but we will use a very simple tool: Python's `str.split`: " + "We mentioned that an **environment** is a mapping from variable names to their values. We will define a default global environment. `ENV`, containing values for the names of a bunch of standard functions like `sqrt` and `max`, as well as operators like `+` and `>`, which are implemented as procedures in Lisp. (Scheme's name for `print` is `display`; the function `unparse` will be defined later.)" ] }, { "cell_type": "code", "execution_count": 3, + "id": "ce21a511-1089-4d70-9c9a-8825c3d63b17", + "metadata": {}, + "outputs": [], + "source": [ + "ENV = {\n", + " **vars(math), # sqrt, sin, cos, etc.\n", + " '+':op.add, '-':op.sub, '*':op.mul, '/':op.truediv, \n", + " '>':op.gt, '<':op.lt, '>=':op.ge, '<=':op.le, '=':op.eq, \n", + " 'eq?': op.is_, 'equal?': op.eq,\n", + " 'abs': abs,\n", + " 'append': op.add, \n", + " 'apply': lambda proc, args: proc(*args),\n", + " 'begin': lambda *x: x[-1],\n", + " 'cons': lambda x,y: [x] + y,\n", + " 'display': lambda x: print(unparse(x)),\n", + " 'expt': pow,\n", + " 'first': lambda x: x[0],\n", + " 'length': len, \n", + " 'list': lambda *x: List(x), \n", + " 'list?': lambda x: isinstance(x, list), \n", + " 'map': lambda f, *args: list(map(f, *args)),\n", + " 'max': max, \n", + " 'min': min,\n", + " 'not': op.not_,\n", + " 'null?': lambda x: x == [], \n", + " 'number?': lambda x: isinstance(x, Number), \n", + " 'procedure?': callable,\n", + " 'rest': lambda x: x[1:], \n", + " 'round': round,\n", + " 'symbol?': lambda x: isinstance(x, Symbol),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "edafbbc3-ae0b-4705-859e-3fcf2f10fdad", + "metadata": {}, + "source": [ + "(*Note:* because I am not implementing all the features of Scheme (such as [continuations](https://groups.csail.mit.edu/mac/projects/info/schemedocs/ref-manual/html/scheme_122.html)), I can get away with defining `begin` as a function rather than a special form.)\n", + "\n", + "## Parsing\n", + "\n", + "How do we get from a sequence of characters to the abstract syntax tree that `eval` expects? The function `parse` does the job, in two steps: \n", + "1. **Lexical analysis**: the function `tokenize` breaks the characters into tokens (such as the keyword `\"if\"` or the number `\"10\"`).\n", + "2. **Syntactic analysis**: the function `parse_tokens` converts the tokens into an expression." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "209b7574-1cad-469e-b735-06f8e18d699d", + "metadata": {}, + "outputs": [], + "source": [ + "def parse(program: str) -> Exp:\n", + " \"\"\"Read a Scheme expression from a string.\n", + " First split the program into tokens, then read from the token list.\"\"\"\n", + " return parse_tokens(tokenize(program))" + ] + }, + { + "cell_type": "markdown", + "id": "1b6a1fb3-4765-42c2-9278-a374fa30f5af", + "metadata": {}, + "source": [ + "There are many tools for lexical analysis (such as Mike Lesk and Eric Schmidt's [lex](https://en.wikipedia.org/wiki/Lex_%28software%29)), most of which define tokens as a class containing a token kind and a token string. But Lisp is so simple that there are really only three types of tokens: left paren, right paren, and everything else. So `str.split` can do the job (with a little help):" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "id": "48875a7a-3c86-4322-9307-3592ab327924", "metadata": {}, "outputs": [], "source": [ - "def tokenize(chars: str) -> list:\n", + "def tokenize(chars: str) -> list[str]:\n", " \"\"\"Convert a string of characters into a list of tokens.\n", " (Put spaces around parens, then split on spaces.)\"\"\"\n", " return chars.replace('(', ' ( ').replace(')', ' ) ').split()" @@ -150,29 +225,28 @@ "id": "64d2de32-6e7f-43ba-b6db-eb1eff397ff2", "metadata": {}, "source": [ - "`read_from_tokens` looks at the first token; if it is a `)` that's a syntax error. If it is a `(`, then we start building up a list of sub-expressions until we hit a matching ')'. Any non-parenthesis token must be an atom. First try to interpret it as a number, and failing that, it must be a symbol. " + "`parse_tokens` looks at the first token; if it is a `)` that's a syntax error. If it is a `(`, then we start building up a list of sub-expressions until we hit a matching `)`. Any non-parenthesis token must be an atom: first try to interpret it as a number, and failing that, it must be a symbol. " ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "c2677c70-f08f-49ff-b167-0cb492ec124f", "metadata": {}, "outputs": [], "source": [ - "def read_from_tokens(tokens: list[str]) -> Exp:\n", + "def parse_tokens(tokens: list[str]) -> Exp:\n", " \"\"\"Read an expression from a list of tokens, mutating the list.\"\"\"\n", - " token = tokens.pop(0) if tokens else None\n", - " match token:\n", - " case None:\n", - " raise SyntaxError('unexpected end of expression')\n", + " if not tokens:\n", + " raise SyntaxError('unexpected end of expression')\n", + " match (token := tokens.pop(0)):\n", " case ')':\n", " raise SyntaxError('unexpected \")\"')\n", " case '(':\n", " result = []\n", " while tokens[0] != ')':\n", - " result.append(read_from_tokens(tokens))\n", - " tokens.pop(0) # pop off ')'\n", + " result.append(parse_tokens(tokens))\n", + " tokens.pop(0) # pop off the closing ')'\n", " return result\n", " case _:\n", " try:\n", @@ -184,37 +258,163 @@ }, { "cell_type": "markdown", - "id": "99ae3c30-3d69-4f26-a835-f4ad44e4265b", + "id": "a8191faa-a8ad-41dc-a1fa-a3e805b24a28", "metadata": {}, "source": [ - "Now we're ready to parse a sample program:" + "## Homoiconicity\n", + "\n", + "One of the defining features of Lisp is [**homoiconicity**](https://en.wikipedia.org/wiki/Homoiconicity), a fancy word derived from the Greek for \"same representation\" that refers to a language in which the internal representation of a program is the same as the external representation. In other words, a Lisp program is just a list, so all the functions for reading, manipulating and printing lists apply equally to programs. We've already defined `parse` to convert a string into an internal representation; now we'll define `unparse` to reverse the process:" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "69509c3a-2c1e-435e-8563-9a9a82cfc75f", + "execution_count": 7, + "id": "62c5a9f4-5969-4646-ac64-fbc34027cadc", + "metadata": {}, + "outputs": [], + "source": [ + "def unparse(exp: Exp) -> str:\n", + " \"Convert a Python object back into a Scheme-readable string.\"\n", + " match exp:\n", + " case List(): return '(' + ' '.join(map(unparse, exp)) + ')'\n", + " case _: return str(exp)" + ] + }, + { + "cell_type": "markdown", + "id": "69764e26-0c13-4b05-86aa-cec9605865b6", + "metadata": {}, + "source": [ + "We can see that parse and unparse are inverses:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9c5d310b-832e-494e-a141-b8eeaa221206", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['begin', ['define', 'r', 10], ['*', 'pi', ['*', 'r', 'r']]]" + "'(lambda (A i) (fn (+ (aref A i) (* 3 i))))'" ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "def parse(program: str) -> Exp:\n", - " \"\"\"Read a Scheme expression from a string.\n", - " (First split the program string into tokens, then read from the token list.\"\"\"\n", - " return read_from_tokens(tokenize(program))\n", + "unparse(parse(\"(lambda (A i) (fn (+ (aref A i) (* 3 i))))\"))" + ] + }, + { + "cell_type": "markdown", + "id": "cf6b5b61-f523-486a-b600-7a9aadc4c824", + "metadata": {}, + "source": [ + "Python has a module, `ast` (for \"abstract syntax tree\") that makes it possible to manipulate programs, but Python is not homoiconic. The internal representation of a program is quite different from the external representation:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0617fa61-7f37-4623-b431-fa44a3edb5e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module(\n", + " body=[\n", + " Expr(\n", + " value=Lambda(\n", + " args=arguments(\n", + " args=[\n", + " arg(arg='A'),\n", + " arg(arg='i')]),\n", + " body=Call(\n", + " func=Name(id='fn', ctx=Load()),\n", + " args=[\n", + " BinOp(\n", + " left=Subscript(\n", + " value=Name(id='A', ctx=Load()),\n", + " slice=Name(id='i', ctx=Load()),\n", + " ctx=Load()),\n", + " op=Add(),\n", + " right=BinOp(\n", + " left=Constant(value=3),\n", + " op=Mult(),\n", + " right=Name(id='i', ctx=Load())))])))])\n" + ] + } + ], + "source": [ + "import ast\n", + "print(ast.dump(ast.parse(\"lambda A, i: fn(A[i] + 3 * i)\"), indent=4))" + ] + }, + { + "cell_type": "markdown", + "id": "c568f646-4f7e-4c13-806d-5bfc7fc98933", + "metadata": {}, + "source": [ + "## Batch Processing\n", "\n", - "program = \"(begin (define r 10) (* pi (* r r)))\"\n", - "parse(program)" + "In **batch processing** an entire program is read, parsed, and evaluated in one step, with no human in the loop." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3a96b511-30da-407b-9137-4b79bc40c367", + "metadata": {}, + "outputs": [], + "source": [ + "def batch(program: str) -> None:\n", + " \"\"\"Parse the program, evaluate it, and print the result.\"\"\"\n", + " print(unparse(eval(parse(program), ENV)))" + ] + }, + { + "cell_type": "markdown", + "id": "8aa89ec1-7f62-4797-8e70-da97e74a7b88", + "metadata": {}, + "source": [ + "Here is a sample program and the result of running it using `batch`:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "69509c3a-2c1e-435e-8563-9a9a82cfc75f", + "metadata": {}, + "outputs": [], + "source": [ + "program1 = \"\"\"\n", + "(begin \n", + " (define r 10)\n", + " (* pi (* r r))) \"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6447f9b9-a3f8-4465-a735-1be81217b94d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "314.1592653589793\n" + ] + } + ], + "source": [ + "batch(program1)" ] }, { @@ -222,12 +422,12 @@ "id": "3ec8b0e9-e384-48fa-8539-2794114f2275", "metadata": {}, "source": [ - "We can also see the tokenization of the program:" + "We can also see the intermediate steps of tokenizing and parsing the program:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "id": "75485bb1-9625-470e-bfa2-3e3c39cb43c0", "metadata": {}, "outputs": [ @@ -253,87 +453,34 @@ " ')']" ] }, - "execution_count": 6, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "tokenize(program)" - ] - }, - { - "cell_type": "markdown", - "id": "e9ae14da-9668-405a-8c5c-2a7186e98cb4", - "metadata": {}, - "source": [ - "## Environments\n", - "\n", - "We mentioned in passing that an **environment** is a mapping from variable names to their values. We will define a default global environment with the names for a bunch of standard functions (like `sqrt` and `max`, and also operators like `+` and `>`). This environment can be augmented with user-defined variables, using the expression `(define symbol value)`." + "tokenize(program1)" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "ce21a511-1089-4d70-9c9a-8825c3d63b17", - "metadata": {}, - "outputs": [], - "source": [ - "global_env = Env({\n", - " '+':op.add, '-':op.sub, '*':op.mul, '/':op.truediv, \n", - " '>':op.gt, '<':op.lt, '>=':op.ge, '<=':op.le, '=':op.eq, \n", - " 'abs': abs,\n", - " 'append': op.add, \n", - " 'apply': lambda proc, args: proc(*args),\n", - " 'begin': lambda *x: x[-1],\n", - " 'car': lambda x: x[0],\n", - " 'cdr': lambda x: x[1:], \n", - " 'cons': lambda x,y: [x] + y,\n", - " 'eq?': op.is_, \n", - " 'equal?': op.eq,\n", - " 'expt': pow,\n", - " 'length': len, \n", - " 'list': lambda *x: List(x), \n", - " 'list?': lambda x: isinstance(x, list), \n", - " 'map': map,\n", - " 'max': max, 'min': min,\n", - " 'not': op.not_,\n", - " 'null?': lambda x: x == [], \n", - " 'number?': lambda x: isinstance(x, Number), \n", - "\t'print': print,\n", - " 'procedure?': callable,\n", - " 'round': round,\n", - " 'symbol?': lambda x: isinstance(x, Symbol),\n", - " **vars(math)})" - ] - }, - { - "cell_type": "markdown", - "id": "565a02c7-15b1-4965-a60e-240464a10ed4", - "metadata": {}, - "source": [ - "We're done! You can see it all in action:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "d09b539c-39d9-481d-9e5e-64ca3b16fbda", + "execution_count": 14, + "id": "1fba56d9-e97b-4919-9a51-31e94c535361", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "314.1592653589793" + "['begin', ['define', 'r', 10], ['*', 'pi', ['*', 'r', 'r']]]" ] }, - "execution_count": 8, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "eval(parse(program), global_env)" + "parse(program1)" ] }, { @@ -341,49 +488,58 @@ "id": "ffe3866c-76ee-4a6e-b0d2-efb18b544c1e", "metadata": {}, "source": [ - "## Interaction: A REPL\n", + "## Interactive Processing\n", "\n", - "It is tedious to have to enter `eval(parse(\"...\", global_env))` all the time. One of Lisp's great legacies is the notion of an interactive read-eval-print loop: a way for a programmer to enter an expression, and see it immediately read, evaluated, and printed, without having to go through a lengthy build/compile/run cycle. So let's define the function `repl` (which stands for read-eval-print-loop), and the function `scheme_to_str` which returns a string representing a Scheme object." + "One of Lisp's great legacies is the notion of an interactive loop: a way for a programmer to enter an expression, see the results, and then think of something new to try. This facilitates exploratory programming: instead of having to design every aspect of a complete program ahead of time, the programmer can experiment, learning as they go, step by step. So let's define the function `repl` (which stands for read-eval-print-loop):" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "id": "037afa47-c35e-416f-affb-aa219cfff935", "metadata": {}, "outputs": [], "source": [ - "def repl(prompt='\\nlis.py> '):\n", - " \"\"\"A prompt-read-eval-print loop.\"\"\"\n", - " print('Scheme read-eval-print loop. Type exit to exit')\n", - " while (expr := parse(input(prompt))) != 'exit':\n", - " val = eval(expr, global_env)\n", - " if val is not None: \n", - " print(scheme_to_str(val))\n", - "\n", - "def scheme_to_str(exp):\n", - " \"Convert a Python object back into a Scheme-readable string.\"\n", - " if isinstance(exp, List):\n", - " return '(' + ' '.join(map(scheme_to_str, exp)) + ')' \n", - " else:\n", - " return str(exp)" + "def repl(prompt='\\nlispy> ') -> None:\n", + " \"\"\"A read-eval-print loop.\"\"\"\n", + " print('lispy> read-eval-print loop – Type exit to exit')\n", + " while (expr := input(prompt)) != 'exit':\n", + " batch(expr)" ] }, { "cell_type": "markdown", - "id": "113b7499-db18-4320-ad82-af66364228f3", + "id": "28cccf9e-0cf3-426b-9f12-61ac165f1e31", "metadata": {}, "source": [ - "Here is `repl` in action. You can run it yourself in a cell.\n", - "\n", - " >>> repl()\n", - " lis.py> (define r 10)\n", - " lis.py> (* pi (* r r))\n", + "Here is an example run of `repl()`:\n", + " \n", + " lispy> read-eval-print loop – Type exit to exit\n", + " lispy> (define r 10)\n", + " r\n", + " \n", + " lispy> (* pi (* r r))\n", " 314.159265359\n", - " lis.py> (if (> (* 11 11) 120) (* 7 6) oops)\n", + " \n", + " lispy> (if (> (* 11 11) 120) (* 7 6) oops)\n", " 42\n", - " lis.py> (list (+ 1 1) (+ 2 2) (* 2 3) (expt 2 3))\n", - " lis.py> (2 4 6 8)" + " \n", + " lispy> (list (+ 1 1) (+ 2 2) (* 2 3) (expt 2 3) (expt 2 (expt 2 2)))\n", + " (2 4 6 8 16\n", + "\n", + " lispy> exit\n", + "\n", + "You can experiment with `repl()` yourself by deleting the `#` and running the following cell. I left it commented out so that when you do the \"Run All Cells\" command on this notebook, it runs all the way through, without pausing to ask you to type in some Scheme expressions." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5286fcff-0152-4da7-8b70-d5ba1883ac4d", + "metadata": {}, + "outputs": [], + "source": [ + "#repl()" ] }, { @@ -393,29 +549,38 @@ "source": [ "# Language 2: Full Lispy\n", "\n", - "We will now extend our language with three new special forms, giving us a much more nearly-complete Scheme subset:\n", + "We will now extend our language with four new special forms, and one variant of the old `define` special form. This gived us a much more nearly-complete Scheme subset:\n", "\n", "|Expression\t|Syntax| Example|\tSemantics|\n", "|-----------|------|--------|------------|\n", + "|conditional\t|(`if` *test then_part else_part*`)`|`(if (< x 0) (- x) x)`|\tEvaluate *test*; if true, evaluate and return *then part*; otherwise *else part*.|\n", "|quotation\t|`(quote` *exp*`)`| `(quote (+ 1 2))` ⇒ `(+ 1 2)`|\tReturn the exp literally; do not evaluate it.|\n", "|assignment\t|`(set!` *symbol exp*`)`| `(set! r2 (* r r))`|\tEvaluate *exp* and assign that value to *symbol*.|\n", - "|procedure\t|`(lambda (`*symbol...*`)` *exp*`)`|`(lambda (r) (* pi (* r r)))`|\tCreate a procedure with parameter(s) named *symbol...* and *exp* as the body.|\n", + "|procedure\t|`(lambda (`*symbol...*`)` *exp*`)`|`(lambda (r) (* pi (* r r)))`|\tCreate an anonymous procedure.|\n", + "|definition | `(define (`*symbol*...`)` *body*`)`|`(defun (add1 x) (+ x 1)`| Define a named procedure.|\n", "\n", - "The lambda special form (an obscure nomenclature choice that refers to Alonzo Church's [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus)) creates a procedure. We want procedures to work like this:\n", + "- The `if` special form is similar to the `(x if test else y)` syntax in Python, although only `False` counts as false in Scheme.\n", + "- The `quote` special form allows you to build a literal data structure.\n", + "- The `set!` special form allows you to update the value of a previously-defined variable. This is different from `define`, which introduces a new variable in the curent environment (and sets its initial value).\n", + "- The `lambda` special form (an obscure name from Alonzo Church's [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus)) creates a procedure (without giving it a name).\n", + "- The new option for `define` is just a shortcut for a regular `define` of a `lambda` expression.\n", "\n", - " lis.py> (define circle-area (lambda (r) (* pi (* r r)))\n", - " lis.py> (circle-area (+ 5 5))\n", - " 314.159265359\n", + "There are two equivalent ways of defining a procedure and giving it a name. Consider:\n", "\n", + " (define (circle-area r) (* pi (* r r)))\n", "\n", - "There are two steps here. In the first step, the lambda expression is evaluated to create a procedure, one which refers to the global variables pi and `*`, and takes a single parameter, which it calls `r`. This procedure is defined as the value of the new variable `circle-area`. In the second step, the procedure we just defined is the value of circle-area, so it is called, with the value 10 as the argument. We want `r` to take on the value 10, but it wouldn't do to just set `r` to 10 in the global environment. What if we were using `r` for some other purpose? We wouldn't want a call to `circle-area` to alter that value. Instead, we want to arrange for there to be a **local variable** named `r `that we can set to 10 without worrying about interfering with any global variable that happens to have the same name. The process for calling a procedure introduces these new local variable(s), binding each symbol in the parameter list of the function to the corresponding value in the argument list of the function call.\n", + " (define circle-area (lambda (r) (* pi (* r r)))\n", "\n", - "The difference between `set!` and `define` is that `set!` always refers to a previously-defined variable, whcih might be in the innermost environment, or might be in an outer environment. `define` always introduces a new variable in the innermost environment.\n", + "Either way, `circle-area` is defined to take as its value a procedure that refers to the global variables `pi` and `*`, and takes a single parameter, `r`. Now we can call the procedure like this:\n", "\n", + " (circle-area (+ 5 5))\n", "\n", - "## Redefining Env as a Class\n", + "We want this call to return the value of `(* pi (* r r))` with `r` set to 10. But it wouldn't do to set `r` to 10 in the global environment. What if we were using `r` for some other purpose? Instead, we want to arrange for there to be a **local variable** named `r` that is only used during this call to `circle-area`. The process for calling a procedure introduces these new local variable(s), binding each symbol in the parameter list of the function to the corresponding value in the argument list of the function call. In this case, the result of the call is 314.159265359.\n", + " \n", "\n", - "To handle local variables, we will redefine `Env` to be a subclass of `dict.` When we evaluate (`circle-area (+ 5 5))`, we will fetch the procedure body, `(* pi (* r r))`, and evaluate it in an environment that has `r` as the sole local variable (with value 10), but also has the global environment as the \"outer\" environment; it is there that we will find the values of `*` and `pi`. In the diagram, the inner environment is blue and the outer red:\n", + "## Local Variables and Procedures\n", + "\n", + "To handle local variables, we will **nest** envronments. Local variables are defined in an environment that is \"inside\" another environment. We will use the convention: `env['_outer']` to refer to the outer environment of the nested environment `env`. When we evaluate (`circle-area (+ 5 5))`, we will fetch the procedure body, `(* pi (* r r))`, and evaluate it in an environment that has `r` as the sole local variable (with value 10), but also has the global environment as the `_outer` environment; it is there that we will find the values of `*` and `pi`. In the diagram, the inner environment is blue and the outer red:\n", "\n", "

\n", "pi: 3.141592653589793\n", @@ -427,38 +592,53 @@ "
\n", "\n", "\n", - "When we look up a variable in such a nested environment, we look first at the innermost level, but if we don't find the variable name there, we move to the next outer level. Procedures and environments are intertwined, so let's define them together:" + "When we look up a variable in such a nested environment, we look first at the innermost level, but if we don't find the variable name there, we move to the next outer level. \n", + "\n", + "Here is the definition of the Procedure class:" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "ed27933e-dc95-4e75-a021-853d8a60d231", + "execution_count": 17, + "id": "1d9cc9fb-32df-41dc-9c6c-863c7a5ba5a6", "metadata": {}, "outputs": [], "source": [ "from dataclasses import dataclass\n", "\n", - "class Env(dict):\n", - " \"\"\"An environment: a dict of {'var': val} pairs, with an outer Env.\"\"\"\n", - " def __init__(self, inner, outer=None):\n", - " self.update(inner)\n", - " self.outer = outer\n", - " def find(self, var):\n", - " \"\"\"Find the innermost Env where var appears.\"\"\"\n", - " return self if (var in self or not self.outer) else self.outer.find(var)\n", - "\n", "@dataclass\n", "class Procedure(object):\n", " \"\"\"A user-defined Scheme procedure.\"\"\"\n", " parms: list[Symbol]\n", " body: Exp\n", " env: Env\n", - " def __call__(self, *args): \n", - " return eval(self.body, Env(zip(self.parms, args), outer=self.env))\n", + " def __call__(self, *args) -> object: \n", + " env = Env(zip(self.parms, args), _outer=self.env)\n", + " return eval(self.body, env)\n", + " def __repr__(self) -> str: \n", + " return f''" + ] + }, + { + "cell_type": "markdown", + "id": "7734c900-7d9c-4770-987a-30830989175d", + "metadata": {}, + "source": [ + "We see that a procedure has three components: a list of parameter names, a body expression, and an environment that tells us what other variables are accessible from the body. For a procedure defined at the top level this will be the global environment, but it is also possible for a procedure to refer to the local variables of the environment in which it was defined (**not** the environment in which it is called).\n", "\n", - "# Now transfer the old global_env into a new Env\n", - "global_env = Env(global_env)" + "The function `find` is used to find the right environment for a variable: starting with the inner one and going out, find the first environment that mentions the variable name." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "22fd9960-b288-4a01-94fe-faab8e8da8bf", + "metadata": {}, + "outputs": [], + "source": [ + "def find(var: Symbol, env: Env) -> Env:\n", + " \"\"\"Find the environment that contains the variable `var`.\"\"\"\n", + " return env if (var in env) else find(var, env['_outer'])" ] }, { @@ -466,38 +646,38 @@ "id": "3d0599c6-3a35-4fd8-b179-c970e8a36c4d", "metadata": {}, "source": [ - "We see that every procedure has three components: a list of parameter names, a body expression, and an environment that tells us what other variables are accessible from the body. For a procedure defined at the top level this will be the global environment, but it is also possible for a procedure to refer to the local variables of the environment in which it was defined (**not** the environment in which it is called).\n", - "\n", - "An environment is a subclass of `dict`, so it has all the methods that `dict` has. In addition there are two methods: the constructor `__init__` builds a new environment by taking a list of parameter names and a corresponding list of argument values, and creating a new environment that has those {variable: value} pairs as the inner part, and also refers to the given outer environment. The method `find` is used to find the right environment for a variable: starting with the inner one and going out, find the first environment that mentions the variable name.\n", - "\n", - "To see how these all go together, here is the new definition of `eval`. Note that the clause for variable reference has changed: we now have to call `env.find(exp)` to find at what level the variable exists; then we can fetch the value of the variable from that level. (The clause for `define` has not changed, because a define always adds a new variable to the innermost environment.) There are three new clauses: `quote` returns the constant without evaluating it, `set!`, finds the environment level where the variable exists and sets it to a new value there, and for `lambda` we create a new procedure object with the given parameter list, body, and environment." + "To see how these all go together, here is the new definition of `eval`:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 19, "id": "afa69b35-bac3-459c-a0cc-b94656ab474c", "metadata": {}, "outputs": [], "source": [ - "def eval(exp: Exp, env=global_env) -> object:\n", + "def eval(exp: Exp, env) -> object:\n", " \"\"\"Evaluate an expression in an environment.\"\"\"\n", " match exp:\n", " case Symbol(): # variable reference\n", - " return env.find(exp)[exp]\n", + " return find(exp, env)[exp]\n", " case Number(): # constant \n", " return exp\n", - " case ('if', test, then, els): # conditional evaluates one branch or the other\n", - " branch = (then if eval(test, env) \n", - " else els)\n", + " case ('if', test, then_, else_): # conditional evaluates one branch or the other\n", + " branch = (else_ if eval(test, env) is False else then_)\n", " return eval(branch, env)\n", - " case ('define', name, exp): # definition\n", - " env[name] = eval(exp, env)\n", - " case ('quote', constant):\n", + " case ('define', (name, *parms), body): # procedure definition\n", + " env[name] = eval(['lambda', parms, body], env)\n", + " return name\n", + " case ('define', Symbol(name), val): # regular definition\n", + " env[name] = eval(val, env)\n", + " return name\n", + " case ('quote', constant): # constant expression\n", " return constant\n", - " case ('set!', symbol, exp):\n", - " env.find(symbol)[symbol] = eval(exp, env)\n", - " case ('lambda', parms, body):\n", + " case ('set!', symbol, val): # variable assignment\n", + " find(symbol, env)[symbol] = eval(val, env)\n", + " return None\n", + " case ('lambda', parms, body): # create an anonymous procedure\n", " return Procedure(parms, body, env)\n", " case (proc, *args): # procedure call\n", " func = eval(proc, env)\n", @@ -507,20 +687,31 @@ }, { "cell_type": "markdown", - "id": "499ec617-e3f5-4f5e-9e8e-e7da7656c624", + "id": "73750dec-a8e0-41fb-83ae-3c7740103659", "metadata": {}, "source": [ - "You can run try new version by removing the `#` and running the cell below:" + "For example:" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "8a76bb61-7195-4b1d-8b01-fb6a5825b94c", + "execution_count": 20, + "id": "fb398ac0-cd7f-45e2-9a8c-1ea15bc7b4e6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "314.1592653589793\n" + ] + } + ], "source": [ - "# repl()" + "batch(\"\"\"\n", + "(begin \n", + " (define (circle-area r) (* pi (* r r)))\n", + " (circle-area (+ 5 5)))\"\"\")" ] }, { @@ -528,135 +719,138 @@ "id": "1a2ccfcd-326b-44f0-b041-da657dc042a0", "metadata": {}, "source": [ - "Here is an example of what you can do:\n", - "\n", - " >>> repl()\n", - " \n", - " lis.py> (define circle-area (lambda (r) (* pi (* r r))))\n", - " \n", - " lis.py> (circle-area 3)\n", - " 28.274333877\n", - " \n", - " lis.py> (define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))\n", - " \n", - " lis.py> (fact 10)\n", - " 3628800\n", - " \n", - " lis.py> (fact 100)\n", - " 9332621544394415268169923885626670049071596826438162146859296389521759999322991\n", - " 5608941463976156518286253697920827223758251185210916864000000000000000000000000\n", - " \n", - " lis.py> (circle-area (fact 10))\n", - " 4.1369087198e+13\n", - " \n", - " lis.py> (define first car)\n", - " \n", - " lis.py> (define rest cdr)\n", - " \n", - " lis.py> (define count (lambda (item L) (if L (+ (equal? item (first L)) (count item (rest L))) 0)))\n", - " \n", - " lis.py> (count 0 (list 0 1 2 3 0 0))\n", - " 3\n", - " \n", - " lis.py> (count (quote the) (quote (the more the merrier the bigger the better)))\n", - " 4\n", - " \n", - " lis.py> (define twice (lambda (x) (* 2 x)))\n", - " \n", - " lis.py> (twice 5)\n", - " 10\n", - " \n", - " lis.py> (define repeat (lambda (f) (lambda (x) (f (f x)))))\n", - " \n", - " lis.py> ((repeat twice) 10)\n", - " 40\n", - " \n", - " lis.py> ((repeat (repeat twice)) 10)\n", - " 160\n", - " \n", - " lis.py> ((repeat (repeat (repeat twice))) 10)\n", - " 2560\n", - " \n", - " lis.py> ((repeat (repeat (repeat (repeat twice)))) 10)\n", - " 655360\n", - " \n", - " lis.py> (pow 2 16)\n", - " 65536.0\n", - " \n", - " lis.py> (define fib (lambda (n) (if (< n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))))\n", - " \n", - " lis.py> (define range (lambda (a b) (if (= a b) (quote ()) (cons a (range (+ a 1) b)))))\n", - " \n", - " lis.py> (range 0 10)\n", - " (0 1 2 3 4 5 6 7 8 9)\n", - " \n", - " lis.py> (map fib (range 0 10))\n", - " (1 1 2 3 5 8 13 21 34 55)\n", - " \n", - " lis.py> (map fib (range 0 20))\n", - " (1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765)\n", - " \n", - " \n", - "We now have a language with procedures, variables, conditionals (`if`), and sequential execution (`begin`). If you are familiar with other languages, you might think that a while or for loop would be needed, but Scheme manages to do without these just fine. The Scheme report says \"Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language.\" In Scheme you iterate by defining recursive functions.\n", + "We now have a language with variables, conditionals, sequential execution, and procedures with recursive calls. That makes our language Turing-complete. If you are familiar with other languages, you might think that a `while` or `for` loop would be needed, but Scheme manages to do without these just fine. In Scheme you iterate by defining recursive functions. The Scheme report says \"Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language.\" \n", "\n", "## How Small/Complete/Good/Fast is Lispy?\n", " \n", "In which we judge Lispy on several criteria:\n", - "- **Small**: Lispy is *very* small: about 120 lines or 4K of source code. (An earlier version was just 90 lines, but was perhaps a bit too terse.) The smallest version of my Scheme in Java, [Jscheme](http://norvig.com/jscheme.html) was 1664 lines and 57K of source. Jscheme was\n", - " originally called SILK (Scheme in Fifty Kilobytes), but I only kept\n", - " under that limit by counting bytecode rather than source code. Lispy does much\n", - " better; I think it meets Alan Kay's 1972 [claim](http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html)\n", - " that *you could define the \"most powerful language in the world\" in \"a page of code.\"* (if you use a small font). However,\n", - " I think Alan would disagree, because he would count the Python compiler as part of the code, putting me well over a page.\n", - "- **Complete**: Lispy is not very complete compared to the Scheme standard. Some major shortcomings:\n", + "- **Small**: Lispy is *very* small: about 120 lines or 4K of source code. (An earlier version was just 90 lines, but was perhaps a bit too terse.) The smallest version of my Scheme in Java, [Jscheme](http://norvig.com/jscheme.html) was 1664 lines and 57K of source. Jscheme was originally called SILK (Scheme in Fifty Kilobytes), but I only kept under that limit by counting bytecode rather than source code. Lispy does much better; I think it meets Alan Kay's 1972 [claim](http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html) that *you could define the \"most powerful language in the world\" in \"a page of code.\"* (if you use a small font). However, I think Alan would disagree, because he would count the Python compiler as part of the code, putting me well over a page.\n", + "- **Complete**: Lispy is not very complete compared to the [Scheme standard](https://standards.scheme.org/). Some major shortcomings:\n", " - **Syntax**: Missing comments, quote and quasiquote notation, # literals, the derived\n", - " expression types (such as `cond`, derived from `if`,\n", - " or `let`, derived from `lambda`), and dotted list notation.\n", + " expression types (such as `cond` and `let`), and dotted list notation.\n", " - **Semantics**: Missing `call/cc` and tail recursion. \n", " - **Data Types**: Missing strings, characters, booleans, ports,\n", " vectors, exact/inexact numbers. A Scheme list should actually be a custom data class, not a Python list.\n", " - **Procedures**: Missing over 100 primitive procedures.\n", " - **Error recovery**: Lispy does not attempt to detect,\n", " reasonably report, or recover from errors. Lispy expects the\n", - " programmer to be perfect. (That is an environment issue, not a language issue.)\n", - "- **Good**: That's up to the readers to decide. I think that Lispy is good for my purpose of explaining Lisp interpreters.\n", - "- **Fast**: Lispy computes (fact 100) in about a millisecond. That's fast enough for me (although slower than some\n", - "other ways of computing it).

" + " programmer to be perfect. \n", + "- **Good**: That's up to the readers to decide. I think that Lispy is good for my purpose of explaining Lisp interpreters. It is not a viable choice for serious software development.\n", + "- **Fast**: Lispy computes (factorial 100) in less than a millisecond. That's fast enough for me.

" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "ececc132-11f2-4f76-80d4-771b89f93f14", + "execution_count": 21, + "id": "5bcc6a7f-261b-4156-92d3-c771ecfcd109", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 371 μs, sys: 108 μs, total: 479 μs\n", - "Wall time: 484 μs\n" + "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000\n", + "CPU times: user 395 μs, sys: 200 μs, total: 595 μs\n", + "Wall time: 521 μs\n" ] - }, - { - "data": { - "text/plain": [ - "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "fact = \"\"\"(begin (define fact (lambda (n) \n", - " (if (<= n 1) \n", - " 1 \n", - " (* n (fact (- n 1)))))) \n", - " (fact 100))\"\"\"\n", - "\n", - "%time eval(parse(fact))" + "%%time\n", + "batch(\"\"\"\n", + "(begin \n", + " (define (factorial n) \n", + " (if (<= n 1) \n", + " 1 \n", + " (* n (factorial (- n 1)))))\n", + " (factorial 100))\"\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "802789ab-2f1c-4fb0-a79b-c7621a851e81", + "metadata": {}, + "source": [ + "## More Example Lisp Programs" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "f8728be6-2423-487f-a44a-49a50411d363", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(count 3 4)\n" + ] + } + ], + "source": [ + "batch(\"\"\"\n", + "(list \n", + " (define (count item L) \n", + " (if (null? L)\n", + " 0\n", + " (+ (equal? item (first L)) (count item (rest L)))))\n", + " (count 0 (list 0 1 2 3 0 0))\n", + " (count (quote the) (quote (the more the merrier the bigger the better))))\"\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "af58a444-c684-481c-a74b-1ad6bb49459b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(square compose repeat 10 81 65536 2.0)\n" + ] + } + ], + "source": [ + "batch(\"\"\"\n", + "(list\n", + " (define (square x) (* x x))\n", + " (define (compose f g) (lambda (x) (f (g x))))\n", + " (define (repeat f) (compose f f))\n", + " ((compose round sqrt) 101)\n", + " ((repeat square) 3)\n", + " ((repeat (repeat square)) 2)\n", + " ((repeat (repeat sqrt)) (pow 2 16)))\"\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5dba7073-33d3-4f39-a192-5e0ccdc42f8a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765)\n" + ] + } + ], + "source": [ + "batch(\"\"\"\n", + "(begin\n", + " (define (fib n) \n", + " (if (< n 2) \n", + " 1 \n", + " (+ (fib (- n 1)) (fib (- n 2)))))\n", + " (define (range start stop)\n", + " (if (= start stop) \n", + " (quote ()) \n", + " (cons start (range (+ start 1) stop))))\n", + " (map fib (range 0 20)))\"\"\")" ] }, { @@ -666,7 +860,7 @@ "source": [ "## True Story\n", "\n", - "To back up the idea that it can be very helpful to know how\n", + "To back up the idea that it can be helpful to know how\n", "interpreters work, here's a story. Way back in 1984 I was writing a\n", "Ph.D. thesis. This was before LaTeX, before Microsoft Word for Windows–we used\n", "[troff](https://en.wikipedia.org/wiki/Troff). Unfortunately, troff had no facility for forward references\n", @@ -681,7 +875,7 @@ "From there Tony and I split paths. He reasoned that the hard part was\n", "the interpreter for expressions; he needed Lisp for that, but he knew\n", "how to write a tiny C routine\n", - "for reading the characters one at a time, and how to link the C routine into the Lisp\n", + "for reading the characters one at a time, and how to link it into the Lisp\n", "program. I didn't know how to do that linking, but I reasoned that writing an\n", "interpreter for this trivial language (all it had was set variable,\n", "fetch variable, and string concatenate) was easy, so I wrote an\n", @@ -692,9 +886,9 @@ "\n", "

Further Reading

\n", "\n", + "Years ago, I showed how to write a semi-practical near-complete Scheme interpreter (one in [Java](https://norvig.com/jscheme.html) and one in [Common Lisp](https://github.com/norvig/paip-lisp/blob/main/docs/chapter22.md)). I also have another page describing a more advanced version of Lispy.\n", " \n", - " \n", - "

To learn more about Scheme consult some of the fine books (by\n", + "To learn more about Scheme consult some of the fine books (by\n", " Friedman\n", " and Fellesein,\n", @@ -716,8 +910,7 @@ " reference\n", " manual.\n", - "\n", - "

I also have another page describing a more advanced version of Lispy." + "\n" ] } ],