AlgImperSem008.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3a76f68e-f22a-4278-b747-19b46d5f94ae",
   "metadata": {},
   "source": [
    "# Algebraic Imperative Semantics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98e783df-67af-407e-8bbe-632d135ccd9d",
   "metadata": {},
   "source": [
    "or, Lambda, The Pynultimate Imperative"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9308f930-36ac-4e22-807e-657bcc265844",
   "metadata": {},
   "source": [
    "**Version 8**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad9d7360-e79b-41a6-a1c6-8f115aa77c7f",
   "metadata": {},
   "source": [
    "**Brian Beckman**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9dd7e97-f193-4c02-b6a6-2add0e1f4004",
   "metadata": {},
   "source": [
    "**30 Dec 2022**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "063aa6e3-a5e6-421c-89f8-23109f834be4",
   "metadata": {},
   "source": [
    "**[Creative Commons Attribution 4.0 International Public License](https://creativecommons.org/licenses/by/4.0/legalcode)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a7aaedb-0423-4c26-9144-b1e230dd799a",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3441580e-c02a-4fa2-8f74-25d127464332",
   "metadata": {},
   "source": [
    "In a classic paper, [_Lambda, the Ultimate Imperative_](https://www.researchgate.net/publication/37596655_Lambda_The_Ultimate_Imperative), Steele and Sussman show how to model most imperative constructs with just _lambda:_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "732d965e-2640-468a-8dfa-4dc9690b5025",
   "metadata": {},
   "source": [
    "> We demonstrate how to model the following common [imperative] programming constructs in ... an applicative-order language similar to LISP: Simple Recursion, Iteration, Compound Statements and Expressions, GO TO and Assignment, Continuation-Passing, Escape Expressions, Fluid Variables, Call by Name, Call by Need, and Call by Reference. The models require only (possibly self-referent) lambda application, conditionals, and (rarely) assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5671e4da-8bae-4d07-b787-d0fe038de6b6",
   "metadata": {},
   "source": [
    "It's useful to recap this paper in Python, which has most of the listed imperative constructs. Imagine compiling Python into an intermediate language in which the semantics, even those with side-effects, are laid bare as trees of $\\lambda$ expressions. In such a representation, optimizations are \n",
    "1. easy to write as tree-to-tree transforms, in a closed algebra of expressions\n",
    "1. easy to extend via just function composition (even Kleisli-monadic)\n",
    "2. independent of surface syntax, thus easy to share with or decompile into other imperative languages like Fortran, C, Java\n",
    "3. independent of back ends, thus easy to run interactively; or to translate into LLVM, x86, ARM64, C, for execution; or to transpile into other surface languages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d073480b-92a4-44fc-9a03-e52129093751",
   "metadata": {},
   "source": [
    "The use-cases above are similar to those for a SQL algebraizer. Many SQL implementations \n",
    "1. translate the surface language into bare-bones expressions in a closed relational algebra, free of original syntax\n",
    "2. run the algebraic expressions through symbolic optimizers, which often rearrange the expressions completely\n",
    "2. incrementally extend the system by composing new optimizations\n",
    "3. translate optimized expressions into commands for local and distributed servers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fd51461-7fc1-4df7-953c-3f25a6aa1f01",
   "metadata": {},
   "source": [
    "TODO: An older algebraic formalization, [Denotational Semantics, was defined for R5RS](https://schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-10.html). It focused on the non-imperative aspects of scheme. The reconstruction in this paper has not yet been compared to that one."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34ffc9c4-3912-4d50-add7-9e2cc1dfd59b",
   "metadata": {},
   "source": [
    "TODO: ? Formalize objects of Object-Oriente Programming ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e440b17b-ed1e-4a26-a8aa-f00ed59c4bfe",
   "metadata": {},
   "source": [
    "We follow Steele's and Sussman's paper more-or-less directly, with reference to [SICP](https://sarabander.github.io/sicp/), [\"TSPL\"](https://www.scheme.com/tspl4/), and [the Gambit Manual](https://gambitscheme.org/latest/manual/#Top)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fab97f19-27e0-4004-b9de-f951fcc50e7e",
   "metadata": {},
   "source": [
    "## _Schemulation:_ Python Semantics in Python<a id=\"semantics\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1ff76f-d551-46ab-a060-4814ab47ec29",
   "metadata": {},
   "source": [
    "Ideally, we'd compile Python into Scheme or Clojure or Common Lisp, then write semantical transformations, translations, interpreters, debuggers, etc. in Scheme or Clojure or Common Lisp. We'd even prove out our work with Coq, as in [Software Foundations](https://softwarefoundations.cis.upenn.edu/). All of these systems have great support for formalizing semantics. However, to maintain a convenient notebook structure and to avoid creeping dependencies, we'll just model Python imperatives in a Scheme-like applicative-order $\\lambda$-calculus embedded in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71f09186-b939-488b-8238-c236d36688a1",
   "metadata": {},
   "source": [
    "Some people may find this weird. Why not just implement Python in Scheme (or Clojure or Common Lisp) instead of emulating Scheme in Python? It's an engineering judgment call. Most authors of compilers and interpreters spend undue time on syntax before even getting to semantics. Compiler textbooks tell you to do this! Semantics becomes a hidden \"implementation detail,\" but then developers forgive themselves for making an ungodly mess of it. We prefer the other way around. Get the semantics clean, composable, extendable, maintainable, and correct, _first_, then spend time on syntax, if you even care any more. Or just let someone else do it. From the compiler-development point of view, syntax is a distraction. It's been solved for decades, but it makes young developers and professors feel powerful. The decision to spend time on syntax before semantics is not engineering, it's self-indulgence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d144a6-5c9e-4569-9528-74690ed57be5",
   "metadata": {},
   "source": [
    "TODO: Revisit in the light of [Calysto Scheme](https://github.com/Calysto/calysto_scheme), a Scheme implemented in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57c016be-1bff-4281-b09d-fb67d3deee4e",
   "metadata": {},
   "source": [
    "## How to Use this Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c462dac7-2b05-4854-bc16-9be095f72fd1",
   "metadata": {},
   "source": [
    "The goal of this notebook is to transmit ideas from my mind to others. Most examples return easy numerical results like `42 * 43 == 1806`. Do the arithmetic and look at results. That's why I don't use Python `assert` much, in this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4aa1b5f-fe02-4eb7-b45c-7c7edb8bfa84",
   "metadata": {},
   "source": [
    "There is a companion Python project that `asserts` the results in pytest, proving the results in the computer. Unlike this notebook, that project is written in non-narrative style. The tests can be run in any order, largely independent of one another."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb27a0d2-0396-4468-8f02-db4d00594ac0",
   "metadata": {},
   "source": [
    "Run the cells sequentially, in order. Some cells modify the unique global environment. Later cells may depend on earlier cells. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8caba04-fe3a-4832-a31b-6b6803813639",
   "metadata": {},
   "source": [
    "# PART I: BASICS<a id=\"basics\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "784b2bdb-40b3-4bb7-a7d0-b467fbebbdd9",
   "metadata": {},
   "source": [
    "[Chez Scheme](https://github.com/cisco/ChezScheme/blob/main/BUILDING) does not build on my Mac M1 Max. I run Scheme examples in [Gambit Scheme](https://gambitscheme.org/latest/manual/#Top). My Jupyter installation does not support multiple languages in the kernel. All code cells run in Python 3.9.6. Scheme cells must be copied and pasted into an interpreter. There is a companion file called \"AlgImperSem008.scm,\" which can be loaded and run in Scheme like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7176f7e-4ecf-473a-bf6d-62d2b81432fb",
   "metadata": {},
   "source": [
    "(load \"AlgImperSem008.scm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebea908d-e479-4d22-933b-194bea01bdfa",
   "metadata": {},
   "source": [
    "# `ECHO` for Debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deed90ca-09ac-4a11-8a7e-154da30046d0",
   "metadata": {},
   "source": [
    "`ECHO` prints and then returns its argument. Semantically, it's the identity function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f51a4c-4304-4680-a746-28cb15cf0cfe",
   "metadata": {},
   "source": [
    "Though the print statement in `ECHO` is technically a side-effect, it's not semantically pertinent. It's a side-effect at the interpreter level,  for user convenience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "38acef91-dd46-4f1f-9cec-9ae7aed6b813",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint, pformat\n",
    "from typing import Any\n",
    "def ECHO(key: str, x: Any) -> Any:\n",
    "    \"\"\"In any Lisp, this would be a macro!\"\"\"\n",
    "    print()\n",
    "    pprint({key: x})\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fde42f05-4b0c-421b-8eb3-ba5691401f12",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "40e1a2e4-ae26-4d20-8356-f92b0c9a9858",
   "metadata": {},
   "source": [
    "(define (echo str expr)\n",
    "  (pp str)\n",
    "  (newline)\n",
    "  expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3096ba84-72a8-4928-814b-ab05acfe721d",
   "metadata": {},
   "source": [
    "# Environment and Frame<a id=\"environment\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b098edb-c3c9-489b-9630-0216c3b1953e",
   "metadata": {},
   "source": [
    "The material in this section will remind you of \"Operations on Environments\" in [SICP 4.1.3](https://sarabander.github.io/sicp/html/4_002e1.xhtml#g_t4_002e1_002e3)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81df4344-49c9-4d00-a6f0-9a8904394029",
   "metadata": {},
   "source": [
    "We model Scheme's environments and frames explicitly. We tried multiple Pythonic short-cut alternatives and found that none compose well."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae24100b-5793-4fce-985e-e788d02e5a21",
   "metadata": {},
   "source": [
    "[SICP 3.2](https://sarabander.github.io/sicp/html/3_002e2.xhtml#g_t3_002e2) has apparent contradictions in the definition of environment and frame. It says that \"an environment is a sequence of frames,\" but the rest of the text and figures clearly imply that an environment has just one frame."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a497199a-798e-4903-af13-0d2559e1d48e",
   "metadata": {},
   "source": [
    "The best resolution appears to be:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d51e004-559c-4868-af7a-e5f97c2345df",
   "metadata": {},
   "source": [
    "> __DEFINITIONS__: An ___environment___ is a frame $\\phi$ and a pointer $\\pi$ to an enclosing environment. A ___frame___ is a mathematical function from variable names to values; no variable name may appear more than once in a frame."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83e26f24-712b-439b-b80f-b5820602996f",
   "metadata": {},
   "source": [
    "We note in passing that this works only for a single thread. [Clojure, for instance, solves that problem with _Vars_](https://clojure.org/reference/vars)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a755018-dc17-4b55-a206-0bfbb7518601",
   "metadata": {},
   "source": [
    "## Greek and ALL CAPS<a id=\"greek\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0cef101-9abd-46c5-bad3-7d617629d95c",
   "metadata": {},
   "source": [
    "$\\pi$ for an enclosing environment is a nice pun: it evokes $\\pi\\eta\\rho\\iota$, a Greek prefix meaning \"surrounding,\" as in \"perimeter\" (_sic_, not \"parameter\")."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "210e0a3a-376b-4663-a86a-820f87ab2cb8",
   "metadata": {},
   "source": [
    "This notebook uses Greek letters in the names system attributes and variables. These letters won't collide with user symbols if users follow the rule below. With this rule, don't need `gensym`, a thorn in every programmer's side:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c97d3883-644a-44cd-abd1-af590c883d20",
   "metadata": {},
   "source": [
    "> __RULE__: Avoid Greek in user-level Python code to avoid clobbering system-supplied names."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c23bcb6-2022-4257-8c12-9955e38b8e7e",
   "metadata": {},
   "source": [
    "Greek is problematic in my installation of Gambit, so I avoid Greek in Scheme code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c9fb02d-6dc2-433c-af33-867b222d3c16",
   "metadata": {},
   "source": [
    "Names in ALL CAPS denote Schemulator procedures visible at user level."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e792017-45b7-4ec9-b7cb-89682ffaa1a3",
   "metadata": {},
   "source": [
    "## Bindings<a id=\"bindings\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27e4595e-51ea-4dcb-a8ae-d5251e2cd0ac",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___binding___ is an association from a variable name to a value. A binding is an entry in a frame."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1f0c66d-994b-425d-bbe5-18a86a3459a6",
   "metadata": {},
   "source": [
    "We might model a binding as a pair, a row in a table, an element of a relation (subset of a Cartesian product), an _item_ in a Python dictionary, or as an attribute of a Python object. We prefer attributes of objects because they afford _dot_ notation, that is, `obj.foo`. Dot notation is shorter than dictionary syntax `dict['foo']`. Thanks to [divs1210](https://gist.github.com/divs1210?page=3) for this idea."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de5caced-7ae8-474c-8890-e04046faba5c",
   "metadata": {},
   "source": [
    "If the definitions above are acceptable, the apparent contradiction in SICP is resolved. SICP says that an environment _is_ a sequence of frames. Rather, I'd say that any environment _implies_ a sequence of frames via the chain of pointers to enclosing environments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89cc50c3-7d05-4bfc-8186-3f458601e2a7",
   "metadata": {},
   "source": [
    "> __INVARIANT__: The system maintains a unique ___global environment___, whose _pointer-to-enclosing-environment_ is `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "934ce7e8-5096-4fdc-8da7-71949f6165bd",
   "metadata": {},
   "source": [
    "> __OBSERVATION__: A frame $\\phi$ belongs to a sequence of environments implied by the unidirectional chain of enclosing environments ending at the unique global environment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74f39e9a-6f52-40b2-aba9-e18ac8cdd061",
   "metadata": {},
   "source": [
    "> __DEFINITIONS__: The ___value of a variable in an environment___ is the value in the first binding in any frame of the sequence ending at _global_. Bindings lower in the chain may ___shadow___ bindings higher in the chain. If no frame in a chain has a binding for a variable, then the variable is ___unbound___ in the environment. A variable may be ___bound___ in one environment and unbound in another. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb7227d-5a28-4768-a39c-23ababa6188e",
   "metadata": {},
   "source": [
    "> __LEMMA__: A chain of environments implements a mathematical partial function from variable names to values. Shadowing ensures that any name appearing more than once in a chain has only one value when looked up."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8900603b-46f7-487d-ab12-1c5d3286edee",
   "metadata": {},
   "source": [
    "Informally, an accessible variable in a chain is a _found_ variable. For all intents and purposes, a _found_ variable is a _bound_ variable and vice versa, though [beware of the confusing usage of the term \"bound variable.\"](#confusing)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b1ba719-c8c0-42b1-b8f8-f3ba53d7fea6",
   "metadata": {},
   "source": [
    "In the Environment class below, `__getattr__` is overridden to avoid a separate method for recursive lookup. We can't also override `__setattr__` to call `setattr(self.ϕ ...)` because `self.ϕ` diverges on `getattr(self.ϕ ...) = getattr(getattr(getattr...))`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45a964d-a4bb-4535-910f-ccd5cb1c9a67",
   "metadata": {},
   "source": [
    "The `Environment` class is lengthy only due to code for _splicing_, necessary to bind [___free variables___](#free-variables) in procedure bodies. Jupyter notebooks do not furnish a convenient way to break up the code for classes, so we put essential information in comments; read them as if they were text in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0029529f-496a-4661-b426-bfc665408c40",
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass, field\n",
    "from types import FunctionType\n",
    "from typing import Any\n",
    "@dataclass\n",
    "@dataclass\n",
    "class Environment:\n",
    "    \"\"\"An Environment has a frame ϕ and a pointer π to an enclosing\n",
    "    Environment. Bindings in the frame are _attributes_ on the\n",
    "    object ϕ. Choose an empty function as the carrier object for\n",
    "    such bindings / attributes. Bindings / attributes have a name and\n",
    "    a value. Retrieve the value of binding ξ in frame ϕ of\n",
    "    Environment E via dot notation as in 'E.ϕ.ξ'. Set the value v\n",
    "    of binding ξ via 'setattr(E.ϕ, ξ, v)'. When getting values of\n",
    "    bindings, it's OK to omit the ϕ, writing 'E.ξ', because of the\n",
    "    overloaded __getattr__ of this class, Environment. Bracket\n",
    "    notation is also OK, as in 'E[\"ξ\"]', because of Environment's\n",
    "    overloaded __getitem__.\"\"\"\n",
    "    ϕ: \"() -> None\"  # \"frame,\" a nice place to hang attributes\n",
    "    π: \"Environment | None\"  # via Greek πηρι, short name for 'enclosing'\n",
    "\n",
    "    def _is_global(self):\n",
    "        return self.π is None\n",
    "\n",
    "    def _is_empty(self):\n",
    "        return not vars(self.ϕ)\n",
    "\n",
    "    def _copy(self) -> \"Environment\":\n",
    "        \"\"\"same parent π\"\"\"\n",
    "        e = Environment(lambda: None, self.π)\n",
    "        for k, v in vars(self.ϕ).items():\n",
    "            setattr(e.ϕ, k, v)\n",
    "        return e\n",
    "\n",
    "    def _copy_trunk(self) -> \"Environment\":\n",
    "        \"\"\"Don't copy the global at the end, but do leave it\n",
    "        attached. WARNING: this does not return a _trunk_ \n",
    "        because the global environment remains at the end. \n",
    "        This avoids two traversals of the chain, once to \n",
    "        remove the global and again to splice something in\n",
    "        its place.\"\"\"\n",
    "        if self._is_global():\n",
    "            return self\n",
    "        r = self._copy()\n",
    "        r.π = r.π._copy_trunk()  # recurse\n",
    "        return r\n",
    "\n",
    "    def _splice_onto_lower(self, lower: \"Environment\"):\n",
    "        \"\"\"Splice self onto the end of lower._trunk(), which\n",
    "        does not have the global at its end. Self should either \n",
    "        be the global or have the global at its end.\n",
    "\n",
    "        Purpose:\n",
    "        For monkey-patching proc envs, where free vars and\n",
    "        parameters are looked up. 'Lower' comes from the\n",
    "        prevailing env chain when a procedure is evaluated, i.e.,\n",
    "        defined in some env like that established by LET_STAR.\n",
    "        'Lower' may contain bindings for free variables in the \n",
    "        body of the procedure.\n",
    "\n",
    "        _splice_onto_lower is called iff 'self' comes from the\n",
    "        explicit π parameter of a procedure constructor. 'Self'\n",
    "        is global if the procedure has no parameters (i.e., no\n",
    "        non-free variables). This rule is not checked because \n",
    "        it's ignored during testing.\n",
    "\n",
    "        Aside:\n",
    "        When a procedure with parameters is APPLY'd, a fresh\n",
    "        singleton env is consed on to 'self.' The fresh env \n",
    "        contains parameter bindings. When a procedure with no\n",
    "        parameters is APPLY'd, no such env is consed on.\n",
    "\n",
    "        Definitions:\n",
    "        - A chain ends in global with no refs to global inside.\n",
    "        - The tip of a chain is the one env furthest from global.\n",
    "        - The trunk of a chain is all but the final global.\n",
    "        - The root of a chain is the final global.\n",
    "\n",
    "        lemmas:\n",
    "        - A chain cannot be None.\n",
    "        - A chain could be simply a ref to global. That's a\n",
    "          chain with no tip or trunk, only a root.\n",
    "        - The tip of a chain is None if the chain is just the\n",
    "          final global.\n",
    "        - The trunk of a chain is None if the chain is just the\n",
    "          final global.\n",
    "\n",
    "        @precondition: self and lower are non-None chains. There\n",
    "        are two references to the global in the two chains.\n",
    "\n",
    "        @postcondition: a chain whose tip is a mutable copy of\n",
    "        the tip of lower if lower is not empty. The final global\n",
    "        of lower is replaced by self. The resulting chain has\n",
    "        one ref to global at the end (the root).\n",
    "\n",
    "        scenarios:\n",
    "        _splice_onto_lower is called iff self is an explicit\n",
    "        procedure env.\n",
    "\n",
    "        self is global      lower is global     return lower\n",
    "        self is global      lower is not empty  return lower\n",
    "        self is not empty   lower is global     return self\n",
    "        self is not empty   lower is not empty  splice\n",
    "        \"\"\"\n",
    "        assert lower is not None\n",
    "        if lower._is_global() or lower._is_empty():\n",
    "            return self\n",
    "        if lower is self:\n",
    "            return self\n",
    "        if self._is_global():\n",
    "            return lower\n",
    "\n",
    "        temp = lower._trunk()\n",
    "        branch = temp\n",
    "        while branch.π:\n",
    "            branch = branch.π\n",
    "        branch.π = self  # MONKEY PATCH!\n",
    "        return temp\n",
    "\n",
    "    def _trunk(self) -> \"Environment | None\":\n",
    "        \"\"\"all but the last, global environment in a chain;\n",
    "        Remove the pointer to global env in a copy of the\n",
    "        penultimate. Called ONLY by _splice_onto_lower!\n",
    "        \"\"\"\n",
    "        if self._is_global():\n",
    "            return None\n",
    "        else:  # Monkey-patch the last env\n",
    "            result = self._copy_trunk()\n",
    "            branch = result\n",
    "            while not branch.π._is_global():\n",
    "                branch = branch.π\n",
    "            branch.π = None  # danger! Looks global!\n",
    "            # Fix this immediately in _splice_onto_lower\n",
    "        return result\n",
    "\n",
    "    def _get_binding_val(self, var: str) -> Any:\n",
    "        \"\"\"Walk the sequence of Environments upward.\"\"\"\n",
    "        try:\n",
    "            ρ = getattr(self.ϕ, var)\n",
    "        except AttributeError as _:\n",
    "            if self.π is None:\n",
    "                raise NameError(\n",
    "                    f'Environment: Name {var} is unbound.')\n",
    "            else:  # Recurse: walk upwards.\n",
    "                ρ = self.π.__getattr__(var)\n",
    "        return ρ\n",
    "\n",
    "    def __getattr__(self, key: str) -> Any:\n",
    "        \"\"\"recursive lookup by dot notation\"\"\"\n",
    "        return self._get_binding_val(key)\n",
    "\n",
    "    def __getitem__(self, key: str) -> Any:\n",
    "        \"\"\"recursive lookup by bracket notation\"\"\"\n",
    "        return self._get_binding_val(key)\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\"for the debugger\"\"\"\n",
    "        is_global = (self.π is None)\n",
    "        result = (\"(\" + hex(id(self.ϕ))[-4:] +\n",
    "                  (\",ΓΠ\" if is_global else \"\") +\n",
    "                  \") \") + \\\n",
    "                 pformat(str(list(vars(self.ϕ).keys()))) + \\\n",
    "                 (\">\" + self.π.__repr__()\n",
    "                  if not is_global\n",
    "                  else \"\")\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79898275-2730-4fda-8075-3eede21ec0fa",
   "metadata": {},
   "source": [
    "# Unique Global Environment $\\Gamma\\Pi$<a id=\"global-environment\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4b8f5a6-c13e-4037-9942-5d66a076e71b",
   "metadata": {},
   "source": [
    "The unique global environment is $\\Gamma\\Pi$, defined once for each session. The frame $\\phi$, an object that ___carries___ attributes, is an empty function, namely `lambda: None`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "48491ed9-5a3c-427e-9208-30d95a6c24a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "ΓΠ = Environment(lambda: None, None)  # Γ for \"global,\" Π for \"environment\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91842b8e-e02e-4e9f-ad0a-d92dc48d74d0",
   "metadata": {},
   "source": [
    "## Example:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "070df742-dc68-445f-bd5b-063083dd8159",
   "metadata": {},
   "source": [
    "The example shows setting and getting the binding for a made-up variable, `γόὂ` as an attribute on $\\phi$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "52b68fda-042c-4f56-8183-6867047ade90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setattr(ΓΠ.ϕ, 'γόὂ', 43)\n",
    "ΓΠ.γόὂ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79b8ea49-1d8f-44e5-96f9-837c3b265298",
   "metadata": {},
   "source": [
    "# Procedure(code{body, params}, $\\pi$)<a id=\"procedure\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79e5021e-ec2f-47ee-a47b-148a29e2e5d7",
   "metadata": {},
   "source": [
    "From SICP again:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c4d6ba-814e-40bd-be3f-77bcca70637c",
   "metadata": {},
   "source": [
    "> __DEFINITIONS__: A ___procedure___ is a pair of _code_ and environment. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2732aa-f6de-43d5-a379-96e0b34cd24f",
   "metadata": {},
   "source": [
    "The environment specifies the ___closure chain___ for the procedure. The closure chain is the chain of environments that contain [_free-variable bindings_](#free-variables), that is, bindings for non-parameters. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77b2c8aa-244e-4d46-b002-43f31874800d",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___closure___ is a procedure along with its closure chain of environments. All variables, free and bound, may be ___resolved___, that is, looked up, in the environment chain."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc8b98ea-8e6e-4a20-92a6-4f0f222e732c",
   "metadata": {},
   "source": [
    "In a typical scenario, a procedure will call other procedures. The other procedures may be passed in as arguments. More typically, however, the names of these other procedures are free variables. For example, in the following procedure (in ordinary Python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "14a3eee4-1ffb-4c25-b21b-4b7bf356015b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7071067811865476+0.7071067811865475j)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def complex_from_polar(r, θ):\n",
    "    from math import sin, cos\n",
    "    result = complex(cos(θ), sin(θ))\n",
    "    return result\n",
    "from math import pi\n",
    "complex_from_polar(1.0, pi/4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82aa2aa8-fde0-4882-a334-d7a3d87852b5",
   "metadata": {},
   "source": [
    "`sin` and `cos` are [free variables](#free-variables), and `r` and `theta` are not free. In the following, more tedious example, `math.sin` and `math.cos` are passed in as arguments bound to the parameters named `sin` and `cos`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3afbde3c-76ef-4d24-93e4-c8009e8d710c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7071067811865476+0.7071067811865475j)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def complex_from_polar(r, θ, sin, cos):\n",
    "    result = complex(cos(θ), sin(θ))\n",
    "    return result\n",
    "import math\n",
    "complex_from_polar(1.0, math.pi/4, math.sin, math.cos)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec83e2c4-c35e-413a-bcb1-3c3792c81ea1",
   "metadata": {},
   "source": [
    "Procedures are values, like numbers. Notionally, they are either \n",
    "\n",
    "1. lookup tables from input values to output values, if they are pure functions, or\n",
    "\n",
    "2. blocks of code that compute outputs from imputs and optionally perform side effects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11c48cf9-0230-455e-94a5-2b4e2b823d32",
   "metadata": {},
   "source": [
    "> __DEFINITIONS__: ___Code___ is a dictionary of two items: a list of parameter names and a `body`. _Body_ is a $\\lambda$ expression taking a single parameter, $\\pi$. $\\pi$ is bound to the closure chain or ___define-time environment___. The define-time environment is the old [`Environment`](#environment) in which [`APPLY`] evaluates [actual arguments](#actual-arguments) at call time before binding them to [formal parameters](#formal-parameters) in a fresh [`Environment`](#environment)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84fc465a-cfce-4d01-82a0-4a13ebc0af89",
   "metadata": {},
   "source": [
    "> __DEFINITIONS__: ___Call___, ___invocation___, and ___application___ are synonyms for expressions in which a procedure's [formal parameters](#formal-parameters) are bound in a fresh environment to [actual arguments](#actual-arguments): values of `Any` type. Invocations may be evaluated _in-situ_ or may be captured in variables of type [`Application`](#application) for later evaluation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15ecbd80-34a2-4e5b-9f8c-bb554bb454f0",
   "metadata": {},
   "source": [
    "This definition sidesteps questions of _order of evaluation_. These questions include shallow ones, such as right-to-left versus left-to-right, and deeper ones, such as [_applicative order_ versus _normal order_](https://sarabander.github.io/sicp/html/4_002e2.xhtml#g_t4_002e2_002e1)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a8753f7-06f5-4f4c-baea-68721b8cc5dc",
   "metadata": {},
   "source": [
    "> __DEFINITION__: ___Arguments___ or ___[actual arguments](#actual-arguments)___ are values of `Any` type that appear in 1-to-1 correspondence to [formal parameters](#formal-parameters) in a call expression, a.k.a, invocation expression or application expression."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c846cc84-1a6e-4eb9-8e2a-c9f43833cc55",
   "metadata": {},
   "source": [
    "## Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "763dd9c5-b0b4-4e77-9522-2dd0b72b26f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "{\"body\": lambda π: π.x + (2 * π.y), \n",
    " \"parameters\": ['x', 'y', 'z']};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00c4e2a1-083c-4ea9-84ea-bf0290f9b955",
   "metadata": {},
   "source": [
    "## Confusing Terminology<a id=\"confusing\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "331b85b3-7020-49c9-af91-50030f9bb884",
   "metadata": {},
   "source": [
    "When speaking of the body of a procedure, variables in the parameter list, i.e., [formal parameters](#formal-parameters) are called [___bound variables___](#bound-variables); confer `x` and `y` above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "231327b4-d219-4343-8869-b13d9c88b95d",
   "metadata": {},
   "source": [
    "> __WARNING__: This terminology is confusing, but common."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f5c027-dc5c-4e56-a288-9e71edd6916e",
   "metadata": {},
   "source": [
    "> __EMPHASIS__: [Formal parameters](#formal-parameters) are not bound to values when the procedure is _defined_, only when the procedure is _called_ with [actual arguments](#actual-arguments). [Formal parameters](#formal-parameters) are presumably called _bound variables_ because it's shorter than calling them \"potentially bound variables\" or \"eventually bound variables.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "232d6c55-cec8-4895-be93-fc39ffa91083",
   "metadata": {},
   "source": [
    "## Parameters, Arguments<a id=\"formal-parameters\"></a><a id=\"actual-arguments\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "285f3448-88ac-40bd-b9ea-3ed44621e657",
   "metadata": {},
   "source": [
    "In ordinary Python, a call, invocation, or application of an anonymous function looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ec99b29f-a29f-4cf1-8178-b995838da969",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y, z:  # <~~~ formal parameters\n",
    " x + 2*y)(\n",
    "    40, 1, None)  # <~~~ actual arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "feb6ca28-5c9f-4b3f-9a8f-e49e6cb47868",
   "metadata": {},
   "source": [
    "The formal parameters are `x`, `y`, and `z`. The actual arguments are `40`, `1`, and `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e166fa0-a666-4fc1-8821-73ca70fc0d8f",
   "metadata": {},
   "source": [
    "> __DEFINITION__: ___Formal___ means \"machine-checkable.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd3abfe0-b91f-4bf2-a206-f6b1eb4657b3",
   "metadata": {},
   "source": [
    "Formal parameters are called \"formal\" because one can machine-check properties of the parameter list, such as absence of duplicated symbols."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4502f8b-501a-4920-8565-ac675087af38",
   "metadata": {},
   "source": [
    "Not all formal parameters need be mentioned in the body. Vice versa, the body may mention variables that are not in the parameter list. Such variables are [___free variables___](#free-variables)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c77b15c-b3ed-4bf7-bb9c-4d99bc6a6a3c",
   "metadata": {},
   "source": [
    "In Schemulator, we write the code part of the example above as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ec56a47e-70a7-45b8-bdf1-cd864c9d22dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda π: π.x + (2 * π.y);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09802b55-829b-47cd-83a1-291534dbe889",
   "metadata": {},
   "source": [
    "Notice that the unused parameter `z` is nowhere to be seen. How do we know it's there? We might wait until the procedure is called with the wrong number of actual arguments, producing a run-time error. That's not great!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7406e48-45cc-4843-ad17-244c4519d18e",
   "metadata": {},
   "source": [
    "To make all parameters explicit, the body code is paired with a list of formal parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eeecac47-fe12-472d-8e0b-0380cd013913",
   "metadata": {},
   "outputs": [],
   "source": [
    "{\"body\": lambda π: π.x + (2 * π.y), \n",
    " \"parameters\": ['x', 'y', 'z']};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "593d32b2-3b36-48fb-83d4-4ed19070c37e",
   "metadata": {},
   "source": [
    "When speaking of the (formal) parameters of a procedure or the (actual) arguments in an invocation of a procedure, we do not mean $\\pi$, the closure chain. Rather, we mean the variables bound in the fresh environment that [`APPLY`](#apply) chains to the front of $\\pi$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ec203bc-3eb0-46cc-967e-a331f5e84f4e",
   "metadata": {},
   "source": [
    "### Ambiguous Language"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c22581d4-10f0-4911-948e-d4afbeb7b1e9",
   "metadata": {},
   "source": [
    "Sloppily, one says \"a procedure of $n$ arguments\" and really means \"a procedure with $n$ (formal) parameters.\" More carefully, we may say \"a procedure _call_ with $n$ (actual) arguments,\" or \"a procedure _invocation_ with $n$ arguments,\" or \"a procedure _application_ with $n$ arguments.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c9856f3-1778-48b6-8818-754f4c59682c",
   "metadata": {},
   "source": [
    "Notice we gradually elide \"formal parameters\" and \"actual arguments\" to the shorter \"parameters\" and \"arguments,\" without loss of precision."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "050e6d45-b31c-4994-8fa7-9cc0dbd43b8d",
   "metadata": {},
   "source": [
    "### Positional Arguments Only"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a8fc27f-fa32-4723-931d-20553f7a12f1",
   "metadata": {},
   "source": [
    "For now, unlike ordinary Python, Schemulator has only positional parameters, 1-to-1 with arguments. That's consistent with [Gambit Scheme](https://github.com/gambit/gambit), which reports \"Wrong number of arguments ...\" if the call has too many or too few arguments. Since Schemulator should be semantically compatible with Scheme, it's OK to have positional parameters and arguments only. Likewise, Schemulator does not yet have Python's (admittedly wonderful) keyword arguments. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df09706-72d8-4894-82a0-0d42de072f4f",
   "metadata": {},
   "source": [
    "## Anonymous versus Named"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03c872ba-b683-4ab7-a4f2-6f7e7547cb04",
   "metadata": {},
   "source": [
    "Procedures need not have a name. In ordinary Python, contrast the named procedure `foo`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f70c6cd4-8312-4ec2-9f66-68505b2fd74c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo(x):\n",
    "    return x * x\n",
    "foo(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b59acd2-b172-497f-bc8e-01dbba2fd3e0",
   "metadata": {},
   "source": [
    "against the anonymous procedure an identical body (except for the lack of `return`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6d29be30-66cc-401d-a6ce-03dc57de566c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x: x * x)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "366aee97-0679-4639-9b0b-5a5b3c2b5e2c",
   "metadata": {},
   "source": [
    "By default, if the user gives a name to a Schemulator procedure, that name is bound in the unique global environment, $\\Gamma\\Pi$. Schemulator allows nested definitions in non-global environments, as with `def` inside `def` in ordinary Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38cd466e-620b-430e-ae9e-f307e5a436da",
   "metadata": {},
   "source": [
    "## Call Notation via `__call__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9745cd89-6728-4ad9-9283-1f746dfc4f11",
   "metadata": {},
   "source": [
    "The `Procedure` class below includes a `__call__` override. To test it, we need [`APPLY`](#apply). We prototype [`APPLY`](#apply) here, just printing actual arguments. [Later, in section `APPLY`](#apply), we implement the real work of binding parameters (in a fresh environment) to arguments (evaluated in an existing environment). That implementation requires [a codependent procedure, `EVAL`](#eval), which, in-turn, needs `APPLY` (see [SICP Figure 4.1](https://sarabander.github.io/sicp/html/4_002e1.xhtml#g_t4_002e1_002e1))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4b6005e-c21c-402e-abdc-21d3bc02b129",
   "metadata": {},
   "source": [
    "The definition of `Procedure` again illustrates codependent types. `Procedure`'s `__call__` syntax depends on `APPLY` and `APPLY` depends on `Procedure`. Python requires writing to-be-defined types in string quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "624c88bf-2197-4eed-807c-e7338157eb96",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict, List, Tuple, Any\n",
    "Parameters = List[str]  # type synonym; positional, ordered arguments only\n",
    "def APPLY(proc: \"Procedure\",  # <~~~ in quotes because it's not defined yet.\n",
    "          args: List[\"Expression\"] | None, \n",
    "          π: Environment = ΓΠ) -> Any:  # defaults to global\n",
    "    \"\"\"forward reference; will be corrected. Needed to\n",
    "    spec Procedure.\"\"\"\n",
    "    ECHO(\"APPLY.args\", args)  # Just print, for now.\n",
    "@dataclass\n",
    "class Procedure:\n",
    "    \"\"\"Include __call__ override for convenient syntax.\"\"\"\n",
    "    code: Dict\n",
    "    π: Environment = ΓΠ  # bound in global environment by default\n",
    "\n",
    "    def __init__(self, code, π: Environment = ΓΠ):\n",
    "        if len(set(code[\"parameters\"])) != len(code[\"parameters\"]):\n",
    "            raise ValueError(\n",
    "                f'Procedure: parameters {code[\"parameters\"]}'\n",
    "                ' must not contain duplicate symbols.')\n",
    "        self.code = code\n",
    "        self.π = π\n",
    "\n",
    "    def __call__(self, *args):\n",
    "        result = APPLY(self, args, self.π)\n",
    "        return result\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\"for the debugger\"\"\"\n",
    "        result = pformat({\n",
    "            'Λ': hex(id(self.code['body']))[-4:],\n",
    "            'parms': str(self.code['parameters']),\n",
    "            'env': self.π if self.π.π else 'ΓΠ'\n",
    "        })\n",
    "        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7692399d-0b11-48a0-b7cc-a69eaa677c6b",
   "metadata": {},
   "source": [
    "## Examples:<a id=\"procedure-examples\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bda3079d-0652-4fdc-942d-230ff10fcd0e",
   "metadata": {},
   "source": [
    "Following SICP 3.2.1, define `square` in the global environment and test `APPLY`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d2dd6315-4732-47f2-88a5-963936ef74cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "setattr(  # Bind a variable ...\n",
    "    ΓΠ.ϕ,  # ... in the frame of the global environment ...\n",
    "    \"square\",  # ... a variable named \"square\" ...\n",
    "    Procedure(  # ... to this Schemulator procedure.\n",
    "        {\"body\": lambda π: π.x * π.x,\n",
    "         \"parameters\": ['x']}))  # Don't forget the parameter list!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed3fbdda-f6c4-444c-8e88-0f6ecbae21e9",
   "metadata": {},
   "source": [
    "Test it! Remember, `APPLY`, for now, just prints the arguments of the applied procedure!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ae2ed44a-8675-436c-b129-c4a9552371ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'APPLY.args': (5,)}\n",
      "\n",
      "{'APPLY.args': (5, 6)}\n"
     ]
    }
   ],
   "source": [
    "ΓΠ.square(5)\n",
    "ΓΠ.square(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a93dfee-7840-4ea8-99c2-d41a6370899d",
   "metadata": {},
   "source": [
    "Test detection of duplicate parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e675728-2cf6-4782-aa5e-ca7ebe065caf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"Procedure: parameters ['x', 'x'] must not contain duplicate symbols.\",)\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    setattr(\n",
    "        ΓΠ.ϕ,\n",
    "        \"square\",\n",
    "        Procedure(\n",
    "            {\"body\": lambda π: π.x * π.y,\n",
    "             \"parameters\": ['x', 'x']}))\n",
    "except ValueError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7cded5e-c882-4149-9968-0685dbdb428d",
   "metadata": {},
   "source": [
    "## Function, Routine, Method<a id=\"function\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "feb188a9-5c90-417f-b13d-5523137b62b9",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___function___ is a mathematical object that associates input arguments to unique output values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a12baa73-1141-44ac-8348-7b0dbdad6505",
   "metadata": {},
   "source": [
    "The best way to think of a function is as a simple lookup table, where a key may appear no more than once. This works even if the notional lookup table is uncountably infinite, as with a function from real numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41d6a82d-1e30-4de6-99d3-d5d092bd0a34",
   "metadata": {},
   "source": [
    "In Schemulator, a function is a special case of a procedure: a procedure without side effects. Every invocation of a function with the same arguments produces the same result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d001e5fd-094d-4fab-a0bc-23fb39852484",
   "metadata": {},
   "source": [
    "> __DEFINITION__: ___Routine___ is a synonym for _Procedure_."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1865d4d9-a4fa-40cc-82bb-4d30d4df96dc",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___method___ is a procedure whose first argument is an object, as with `self` in ordinary Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13726a49-bbea-4adc-b69b-f8e3c036a79a",
   "metadata": {},
   "source": [
    "This definition of _method_ hides the entire topic of object-oriented programming, only tangentially relevant here. One only needs to know that much of Schemulator is implemented in terms of Python's classes, objects, and methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decb0745-15d4-4155-9072-db053fa2af66",
   "metadata": {},
   "source": [
    "## Shortcut: $\\Lambda$($\\lambda$, params, $\\pi$)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0800a8a3-55df-41ed-a537-b3963b441894",
   "metadata": {},
   "source": [
    "Note: The `code` attributes of procedures are an unordered dictionary of parameters and body. The $\\Lambda$ shortcut puts them in an order. $\\Lambda$ expressions would be more clear if the list of parameters preceded the body, but defaulting the list to `None` would not be easy and one would have to write empty brackets `[]` in every instance of $\\Lambda$. Better this way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "655b3ca2-1d19-4317-b9e7-3b7cbffdaa09",
   "metadata": {},
   "source": [
    "The example procedure above has a name, \"square\", bound in the global environment. \"Square\" is not anonymous, but the [`Procedure`](#procedure) value bound to the name \"square\" is anonymous."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320b9276-0b09-4d32-a407-19719f6ba9dd",
   "metadata": {},
   "source": [
    "$\\Lambda$ is syntactical help to shorten definitions of anonymous procedures. Its default parameter list is empty and its default environment is the unique global environment $\\Gamma{}\\Pi$. The shortest $\\Lambda$ expression is `Λ(lambda π: None)`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d37e5b8-0d73-483d-b5fb-0f342e826b72",
   "metadata": {},
   "source": [
    "Python requires function types for parameters in strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bc04a5d8-ee84-4f29-9f39-f66c7dff4b66",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Λ(\n",
    "        body: \"(π: Environment) -> Any\",\n",
    "        parameters=None,  # default empty\n",
    "        π = ΓΠ            # default global\n",
    ") -> Procedure:\n",
    "    ρ = Procedure(\n",
    "        code={\"body\": body, \n",
    "              \"parameters\": parameters or []},\n",
    "        π=π)\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe75bd7-f270-469e-82c9-c32cc1b5106a",
   "metadata": {},
   "source": [
    "### Example:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "908a9724-453e-4994-bcb7-1cc46d611c2b",
   "metadata": {},
   "source": [
    "Procedures need closure chains for looking up free variables and for evaluating actual arguments. The next few examples have no free variables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f5ab868-971f-47d2-b47b-668bfbf0a109",
   "metadata": {},
   "source": [
    "Test the $\\Lambda$ syntax with the current `APPLY`, which just prints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "da3388dc-9d9b-47c5-a293-f958340a466e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'APPLY.args': (5,)}\n",
      "\n",
      "{'APPLY.args': (5, 6)}\n"
     ]
    }
   ],
   "source": [
    "setattr(  # Give a name ...\n",
    "    ΓΠ.ϕ,  # ... in the frame of the global environment ...\n",
    "    \"square\",\n",
    "    Λ(lambda π: π.x * π.x, ['x']))  # ... to this anonymous procedure\n",
    "ΓΠ.square(5)\n",
    "ΓΠ.square(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aaeb3f7-5214-4343-beae-35f5e5625d76",
   "metadata": {},
   "source": [
    "# Application(head, args, $\\pi$)<a id=\"application\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9372d8ab-c3eb-4b7e-bec7-6926a0064245",
   "metadata": {},
   "source": [
    "> __DEFINITION__: An `Application` is an unevaluated data object with a [`Procedure`](#procedure) or symbol of type `str` and a list of actual arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a77c9a3-e3d6-4495-9c04-081e81d994bf",
   "metadata": {},
   "source": [
    "Do not confuse this [_Application_](#application), capital \"A\", with _application_, little \"a\", meaning a call or invocation of a procedure. An _Application_ with capital \"A\" is data representing a procedure call, invocation, or application. We test it later, after [`EVAL`](#eval) and [`APPLY`](#apply) are fully defined."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91863b01-2a45-41c3-b8e6-7484f193ac73",
   "metadata": {},
   "source": [
    "`Application` is needed in [LET_STAR](#let-star) and related constructs to delay evaluation until the environment with parameter bindings is established, where [EVAL](#eval) can look them up by name. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2277bb1e-17b7-4bd0-8e3e-33c5628fa886",
   "metadata": {},
   "source": [
    "`Application` is a placeholder for a more general [QUOTE](#quote) or macro mechanism, which prevents evaluation in all cases (TODO). In real Scheme, `LET` and friends are syntactical forms that delay evaluation via Scheme macros, i.e., code rewriters. We prefer explicit delaying via `Application` objects at the semantical level, so as not to obscure the algebraic structures we pursue. TODO: there may be observble differences in this model between Scheme and Schemulator if Scheme delays the evaluation of arguments, not just the application of the procedure. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a6f55ed-4d1f-400f-a782-d627c320cd56",
   "metadata": {},
   "source": [
    "An alternative is an embedded macro DSL (Domain-Specific Language) in Python, overkill here. If we go down that road, we might as well just implement Scheme altogether."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d861288e-aa1b-44c0-8cbb-eb12efa275e6",
   "metadata": {},
   "source": [
    "`Application` includes a `__call__` override for Pythonic calling syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f7004787-8d04-4f4e-b3d9-c5dc449a6355",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Union, Any\n",
    "def EVAL_APPLICATION(\n",
    "        expr: \"Application\", \n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    \"\"\"forward reference; corrected below\"\"\"\n",
    "    pass\n",
    "from dataclasses import (dataclass, field)\n",
    "@dataclass\n",
    "class Application:\n",
    "    head: Union[str, Procedure]\n",
    "    args: List[\"Expression\"] = field(default_factory=list)  # args, not params!\n",
    "    π: Environment = ΓΠ\n",
    "    def __call__(self, π=None):\n",
    "        return EVAL_APPLICATION(self, π or self.π)\n",
    "    def __repr__(self):\n",
    "        \"\"\"for the debugger\"\"\"\n",
    "        result = str({\n",
    "            'Ξ': hex(id(self))[-4:],\n",
    "            'head': self.head,\n",
    "            'args': self.args,\n",
    "            'π': self.π if self.π.π else \"ΓΠ\"\n",
    "            })\n",
    "        return result        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "145c23d4-fcf4-4515-aa12-31aeeae3b4d3",
   "metadata": {},
   "source": [
    "## Shortcut: $\\Xi$(head, args, $\\pi$)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ed50bfb-df83-4af5-bb84-47e113826c3f",
   "metadata": {},
   "source": [
    "Just as [Procedure](#procedure) has a [system-reserved Greek](#greek) shortcut, $\\Lambda$, we make a Greek shortcut, $\\Xi$, for `Application`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f8a9bb0a-62ee-482c-84e2-c2897a1e80c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "Ξ = Application"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b906b688-6898-42bc-9132-93c24e3ce579",
   "metadata": {},
   "source": [
    "Test later."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7164510c-865a-4b1b-b794-37660ba48453",
   "metadata": {},
   "source": [
    "# Var(sym)<a id=\"var\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "156b1e08-2c96-4ee6-a635-76d2379fed04",
   "metadata": {},
   "source": [
    "In [applications](#application), we sometimes interpret strings as symbolic references to variables in an environment. The type that manages that need is `Var`. We test `Var` [after defining `EVAL`](#eval)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e446b347-57de-4da4-a0e0-8ea3a4b21e32",
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Var:\n",
    "    sym: str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5ac5fb3-84fc-46dd-84e2-a658e7e6c63e",
   "metadata": {},
   "source": [
    "# EVAL(expr, $\\pi$)<a id=\"eval\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc28795c-1c88-4c36-8b28-ce885c3b7d2e",
   "metadata": {},
   "source": [
    "`EVAL` calls `APPLY`, but `APPLY` calls `EVAL`. We can't test `EVAL` until [`APPLY` is corrected, below](#apply)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7b70ba-0ac2-4965-b0e7-1e8d6f1b84aa",
   "metadata": {},
   "source": [
    "First, we correct `EVAL_APPLICATION`, [originally stubbed above](#application). The first slot of an `Application` may contain:\n",
    "\n",
    "1. a string, [treated as a `Var` in the define-time environment](#var), that must evaluate to a procedure\n",
    "\n",
    "2. or an explicit procedure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32d94aa-131a-4805-8a55-69347400ddec",
   "metadata": {},
   "source": [
    "To evaluate an [`Application`](#application), evaluate the procedure or string (implicitly a `Var`) in the first slot, then evaluate the arguments, then [`APPLY`](#apply) the procedure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c6194306-2954-471b-a0b5-b44acf365017",
   "metadata": {},
   "outputs": [],
   "source": [
    "def EVAL(\n",
    "        expr: Any, \n",
    "        π: Environment = ΓΠ, \n",
    "        tag=None\n",
    ") -> Any:\n",
    "    \"\"\"forward reference, corrected below.\"\"\"\n",
    "    pass\n",
    "def EVAL_APPLICATION(\n",
    "        expr: Application,\n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    \"\"\"corrected definition; Treats 'head' a free variable in \n",
    "    an expression to recursively evaluate.\"\"\"\n",
    "    if isinstance(expr.head, str):  # 'head' is implicitly a Var.\n",
    "        # 1/4. Evaluate first slot to find proc from string ...\n",
    "        proc = π[expr.head]\n",
    "        # ... yielding a procedure:\n",
    "        assert isinstance(proc, Procedure), \\\n",
    "            f'The head of {expr} must be a string or a Procedure, ' \\\n",
    "            f'not a type({expr.head}) = {type(expr.head)}.'\n",
    "    elif isinstance(expr.head, Procedure):\n",
    "        # 1/4. Evaluate first slot in the closure environment  ...\n",
    "        proc = expr.head\n",
    "    else:\n",
    "        raise ValueError(\n",
    "            f'The head of {expr} must be a string or a Procedure, '\n",
    "            f'not a {expr.head}')\n",
    "    # 2/4. Evaluate the proc to splice the free vars ...\n",
    "    proc = EVAL(proc, π)\n",
    "    # 3/4. Evaluate all args ...\n",
    "    eargs = [EVAL(arg, π) for arg in expr.args]\n",
    "    # 4/4. Apply the procedure.\n",
    "    ρ = APPLY(proc, eargs, π)  # 3.3. Apply the procedure.\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "203a9adf-9d53-4c4a-9f24-412d81855b63",
   "metadata": {},
   "source": [
    "`EVAL_PROCEDURE` splices environments for [free variables](#free-variables)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "22521f18-d6fa-400d-9d29-c96680052051",
   "metadata": {},
   "outputs": [],
   "source": [
    "def EVAL_PROCEDURE(\n",
    "        λ: Procedure,\n",
    "        π: Environment = ΓΠ\n",
    ") -> Procedure:\n",
    "    λ.π = λ.π._splice_onto_lower(π)\n",
    "    return λ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ae9582d-5007-42ba-90b8-f636bcb5e519",
   "metadata": {},
   "source": [
    "Many types other than [`Application`](#application), [`Procedure`](#application),  or [`Var`](#var) evaluate to themselves. `EVAL` only needs more cases for collections. [We test that below](#test-collections) after defining [`LET_STAR`](#let-star) and [`LET`](#let)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "49a0fcbc-8932-4443-a420-d12ce8ea97c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any, Dict, Tuple, List\n",
    "import numpy\n",
    "\n",
    "Atom = Union[str, int, float, bool]\n",
    "Expression = Union[\n",
    "    Dict, Tuple, List, numpy.ndarray,\n",
    "    Var, Application, Procedure, Atom]\n",
    "\n",
    "def EVAL(\n",
    "        expr: Expression,\n",
    "        π: Environment = ΓΠ,\n",
    "        tag=None  # Call EVAL with tag=\"debug\" to get a printout.\n",
    ") -> Any:\n",
    "    \"\"\"Python does a lot of this for us.\n",
    "    'Tag' is included to aid debugging, especially\n",
    "    outside this notebook.\"\"\"\n",
    "    if tag == 'debug':\n",
    "        pprint({\"EVAL\": \"\",\n",
    "                \"expr\": expr,\n",
    "                \"type\": type(expr),\n",
    "                \"tag\": tag,\n",
    "                \"env\": π})\n",
    "    if isinstance(expr, Dict):\n",
    "        ρ = {k: EVAL(v, π) for k, v in expr.items()}\n",
    "    elif isinstance(expr, Tuple):\n",
    "        ρ = tuple((EVAL(v, π) for v in expr))\n",
    "    elif isinstance(expr, List):\n",
    "        ρ = [EVAL(v, π) for v in expr]\n",
    "    elif isinstance(expr, numpy.ndarray):\n",
    "        ρ = numpy.vectorize(lambda v: EVAL(v, π))(expr)\n",
    "    elif isinstance(expr, Var):\n",
    "        ρ = π[expr.sym]  # recursive lookup in Environment\n",
    "    elif isinstance(expr, Application):\n",
    "        ρ = EVAL_APPLICATION(expr, π)\n",
    "    elif isinstance(expr, Procedure):\n",
    "        ρ = EVAL_PROCEDURE(expr, π)\n",
    "    else:\n",
    "        ρ = expr\n",
    "    return ρ  # hang a breakpoint here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ca03c76-d169-426a-a1a5-31cf7469f76f",
   "metadata": {},
   "source": [
    "## Test Var Lookup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2b93af6-db65-4303-930f-597a34b0dffe",
   "metadata": {},
   "source": [
    "Earlier, we bound the little [Greek](#greek) system-test variable `γόὂ` in [section \"Global Environment\"](#global-environment)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c0b8683f-fe7e-41d7-b56d-a4ee16a04f77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EVAL(Var('γόὂ'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4607233e-f639-447b-beba-829b20c8f624",
   "metadata": {},
   "source": [
    "Without `VAR`, strings are literal data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1561a9c1-2cdc-4a7c-9aec-7351ac72f60d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(EVAL('γόὂ'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a73a82a-6d1d-4a3c-a946-f7ee9ca354f0",
   "metadata": {},
   "source": [
    "# APPLY(proc, args, $\\pi$)<a id=\"apply\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038ca98a-dbfa-4ba1-8afa-451557914aa5",
   "metadata": {},
   "source": [
    "It's easier to mentally track environment chaining if one remembers that every procedure call creates a new environment for binding [formal parameters](#formal-parameters) to [actual arguments](#actual-arguments), and that [free variables](#free-variables) are bound in the closure chain, i.e., the _define-time environment_ of the procedure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58fc0d23-c900-47db-a450-0192a498dead",
   "metadata": {},
   "source": [
    "> __MEMORIZE__: `APPLY` (1) makes a new environment parented in the closure-chain environment (default, $\\Gamma\\Pi$), then (2) evaluates actual arguments in the old, parent environment, then (3) binds parameters in the new environment to the values of the actual arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29c11f98-ac7a-4a38-b695-0a3b06e46670",
   "metadata": {},
   "source": [
    "Optimization: if a procedure has no parameters, `APPLY` doesn't make a fresh environment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0d4cb86-c751-4b64-90a2-ef308d895d51",
   "metadata": {},
   "source": [
    "TODO: explore use cases where the environment for actual arguments given to `APPLY` is different from the define-time environment of the procedure given to `APPLY`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7804331a-2dcb-4f68-80d0-145c599ee39e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class IllegalArgumentsError(ValueError):\n",
    "    pass\n",
    "\n",
    "def APPLY(\n",
    "        proc: Procedure,\n",
    "        args: List[Expression] | None = None,  # Python doesn't like mutable [] here, ...\n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    if args is None:\n",
    "        args = []  # ... but here it's OK.\n",
    "    if len(proc.code['parameters']) != len(args):\n",
    "        raise IllegalArgumentsError(\n",
    "            f\"Wrong number of arguments, \"\n",
    "            f\"{len(args)} = len({args}), \"\n",
    "            f\"passed to procedure {proc}, \"\n",
    "            f\"which expects {len(proc.code['parameters'])} = \"\n",
    "            f\"len({proc.code['parameters']}).\"\n",
    "        )\n",
    "    # 1/3. Make a new environment, E1, if needed.\n",
    "    if proc.code['parameters']:\n",
    "        E1 = Environment(lambda: None, π)\n",
    "    else:\n",
    "        E1 = π\n",
    "    # 2/3. Bind parameters in new env E1 to actual args, evaled\n",
    "    #      in the old environment ...\n",
    "    for k, v in zip(proc.code['parameters'], args):\n",
    "        setattr(E1.ϕ, k, EVAL(v, π))\n",
    "    # 3/3. Invoke the code body, ...\n",
    "    ρ = proc.code['body'](E1)\n",
    "    # ... always a lambda of an environment π.\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7f65a32-ab6f-47b6-9ca0-9c26ed093ea6",
   "metadata": {},
   "source": [
    "## Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "aa5eb25d-b202-4bcf-ab5c-944417bc491e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "APPLY(ΓΠ.square, [42])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c726a8fe-b489-4be4-b3a7-96de9be589f0",
   "metadata": {},
   "source": [
    "Call `APPLY` via \"Pythonic\" round brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7cb12c20-323e-4060-853e-f84eaba1b1a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ΓΠ.square(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71b9cb28-b54c-4a74-889a-250517a93767",
   "metadata": {},
   "source": [
    "Works on anonymous procedures, too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f6d34218-7230-4589-b1e3-cc106bbc1882",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda π: π.x * π.x, ['x'])(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fd486c3-661a-43c3-b603-fc74be29bfce",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2cab656c-489d-4c7a-aa96-b9b3c4e95e7e",
   "metadata": {},
   "source": [
    "> ((lambda (x) (* x x)) 42)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e981eb73-129d-4636-a516-0dfd4e08efe2",
   "metadata": {},
   "source": [
    "Test multiple parameters and arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5ebc5e7f-7ff6-4334-84f2-1b2854fd339e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (f400) \"['x', 'y']\">(cc10,ΓΠ) \"['γόὂ', 'square']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "56"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda π: π.x * ECHO('π', π).y, ['x', 'y'])(8, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ff5d74d-3351-432d-abec-924703c08b57",
   "metadata": {},
   "source": [
    "Scheme equivalent (must define a name because Gambit `break` doesn't work on anonymous lambda expressions); Gambit debugger prints the entire environment chain excepting the global environment:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f8ae81d5-80ff-47e5-8c04-68b6f7c2f89f",
   "metadata": {},
   "source": [
    "> (goo 8 7)\n",
    "*** STOPPED IN goo, (stdin)@56.20\n",
    "x = 8\n",
    "y = 7\n",
    "1> ,c\n",
    "56"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce0576bf-18d8-4a25-8961-8493daefb595",
   "metadata": {},
   "source": [
    "The bound variables in the procedures, for example, `x`, don't leak: they are not bound in $\\Gamma\\Pi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b3abb85c-bab1-4bba-848a-38b46ff5b261",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name x is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    ΓΠ.x\n",
    "except Exception as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8f7a7a-7edc-4f16-a040-64e7958a501a",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0e627675-985f-4ec0-ac66-f2ae609cab36",
   "metadata": {},
   "source": [
    "> x\n",
    "*** ERROR IN (stdin)@63.1 -- Unbound variable: x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "910eceff-2c72-4cdf-bdc5-b07ec23c96d5",
   "metadata": {},
   "source": [
    "## Test `Application`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c87a4c8-7cc5-43ac-b1a1-24ac7d0f1df3",
   "metadata": {},
   "source": [
    "Recall that an [`Application`](#application) is a data object representing a procedure call on actual arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c5d64032-4b96-4cdf-ac64-afa11f14ec08",
   "metadata": {},
   "outputs": [],
   "source": [
    "ωfoo = Application(ΓΠ.square, [42])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c95803-7e84-4f78-b6a6-a08e01d5cee4",
   "metadata": {},
   "source": [
    "Notice that the parameters are _not bound to actual arguments when the `Application` is defined_, only when the `Application` is evaluated, that is, until call-time of the procedure in the `Application`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9f34bd43-5a4e-4530-843e-f942823e8bfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'ωfoo': {'Ξ': '6140', 'head': {'env': 'ΓΠ', 'parms': \"['x']\", 'Λ': 'c700'}, 'args': [42], 'π': 'ΓΠ'}}\n"
     ]
    }
   ],
   "source": [
    "ECHO('ωfoo', ωfoo);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384f8e59-9ee4-4bdc-bf8b-8ebbbfa39398",
   "metadata": {},
   "source": [
    "To perform the call, `EVAL` the `Application`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "afd3a73f-6e0d-4b1e-96b1-5446db0c1269",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EVAL(Application(ΓΠ.square, [42]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c3ce944-0bc8-4c51-ac37-40fd94ead4dc",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5a2cee16-c3fb-4ab1-9263-5f23fbf88f02",
   "metadata": {},
   "source": [
    "> square\n",
    "#<procedure #7 square>\n",
    "> (define omegafoo '(square 42))\n",
    "> (eval omegafoo)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ed8123-2378-4637-8e59-35d568e694c9",
   "metadata": {},
   "source": [
    " Internally, `EVAL` calls `EVAL_APPLICATION`. The results are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3b8d6e80-7b5c-4dc0-8842-3fe6d6241004",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EVAL_APPLICATION(Application(ΓΠ.square, [42]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ed99bce-4b9c-4f22-ad75-4ba024da63b4",
   "metadata": {},
   "source": [
    "Round-bracket _call_ notation also works, but don't pass arguments; as a procedure, and `Application` is a [_thunk_](#thunk):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "21f6e368-8cdc-4cf7-9bd8-65bd47f43ce9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Application(ΓΠ.square, [42])()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab5ee0d5-0b3e-450f-8874-0116729af857",
   "metadata": {},
   "source": [
    "Test the [Greek](#greek) shortcut $\\Xi$ for `Application`, now treating the string in the procedure slot implicitly as a `Var` looked up in $\\Gamma\\Pi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "42fa385e-2ec1-4ccd-8a46-783a35cbeda3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ξ('square', [42])()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e174677-293f-4df3-a945-ecd2edb49689",
   "metadata": {},
   "source": [
    "`Applications` require explicit `Vars` to help with actual arguments looked up in $\\Gamma\\Pi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "25a4e368-959e-425f-80cd-14d2bd8283e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1849"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ξ('square',  # find proc in global env\n",
    "   [Var('γόὂ')])()  # find binding in global env"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6189fe4a-3f7a-4c07-819c-a9873bd96ae1",
   "metadata": {},
   "source": [
    "Without the `Var`, `EVAL` treats `'γόὂ'` as a Python string, producing a `TypeError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9d43a87a-84bd-4e2f-9b8a-5328357ad747",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"can't multiply sequence by non-int of type 'str'\",)\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    EVAL(Ξ('square',  # find proc in global env\n",
    "           ['γόὂ']))  # get horribly confused\n",
    "except TypeError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7c74512-3fff-4f74-a372-4ea64e3c69bd",
   "metadata": {},
   "source": [
    "Scheme equivalent (Scheme doesn't need `Var`, [though Clojure has it](https://clojure.org/reference/vars)):"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0b5b77ca-a134-4d87-8298-1604393df84e",
   "metadata": {},
   "source": [
    "> (define gammaoo 43)\n",
    "> (square gammaoo)\n",
    "1849"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3155d5cc-8f76-4943-ac84-3e21897ea75b",
   "metadata": {},
   "source": [
    "[`Applications`](#application) may have explicit procedures, instead of strings, in their first slot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "84fabf35-40b5-45e9-bf3b-8cfbbfdd9317",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1849"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EVAL(\n",
    "    Ξ(Λ(lambda π: π.x * π.x, ['x']), \n",
    "      [Var('γόὂ')]  # find binding in global env\n",
    "     ))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d4a4737-342f-49fa-8a07-455e6d411396",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d9927779-dff6-4dc0-abe4-479530d81621",
   "metadata": {},
   "source": [
    "> (eval '((lambda (x) (* x x)) gammaoo))\n",
    "1849"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e87e10d-6720-4192-9d35-20b7f545b700",
   "metadata": {},
   "source": [
    "$\\Xi$ honors sub-environments even when looking up procedures and arguments by their symbolic names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7bf9b488-79a8-4625-b4f9-44604b285f41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (97e0) \"['ϕοοβαρ']\">(cc10,ΓΠ) \"['γόὂ', 'square']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda π:  # fresh env created by implied call of APPLY\n",
    "  EVAL(\n",
    "      Ξ('square',  # Look me up in ΓΠ.\n",
    "        [Var('ϕοοβαρ')]),  # Look me up in fresh env chained to π.\n",
    "      ECHO('π', π)),  # pass fresh env to EVAL\n",
    "  ['ϕοοβαρ'])(  # formal parameter of the Λ; open ( implicitly calls APPLY\n",
    "    42)  # actual argument of implied call of APPLY, which makes fresh env"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b446abc6-59c6-4aed-9251-ed2c7987274f",
   "metadata": {},
   "source": [
    "$\\phi\\omicron\\omicron\\beta\\alpha\\rho$ is not bound in the $\\pi$ of the $\\Lambda$, wchich is $\\Gamma\\Pi$, as we see by attempting the `EVAL` in $\\Gamma\\Pi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "c3625f9e-99d0-4174-a6ae-abcc9f9d487a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name ϕοοβαρ is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    Λ(lambda π:\n",
    "      EVAL(\n",
    "          Ξ('square', \n",
    "            [Var('ϕοοβαρ')]), \n",
    "          ΓΠ),  # <~~~ wrong env\n",
    "      ['ϕοοβαρ'])(\n",
    "        42)\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9604b2c-f3e6-4038-be5e-c955b5ff74c0",
   "metadata": {},
   "source": [
    "$\\Gamma\\Pi$ is the default of `EVAL`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "02709764-ca2a-45ad-98cf-f0dcc143be86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name ϕοοβαρ is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    Λ(lambda π:\n",
    "      EVAL(\n",
    "          Ξ('square', \n",
    "            [Var('ϕοοβαρ')])),  # <~~~ no env means ΓΠ\n",
    "      ['ϕοοβαρ'])(\n",
    "        42)\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21a63b65-02b9-418d-9ed4-55633cfff924",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e703078-526c-4b54-a8ba-68a6b47d1cf5",
   "metadata": {},
   "source": [
    "> __WARNING__: [Gambit Scheme's eval](https://gambitscheme.org/latest/manual/#index-_002ddebug_002denvironments), unlike [r5rs](https://schemers.org/Documents/Standards/R5RS/r5rs.pdf), always evaluates in the global environment."
   ]
  },
  {
   "cell_type": "raw",
   "id": "662e8384-9549-4d4d-9247-38751e304f28",
   "metadata": {},
   "source": [
    "> ((lambda (foobar) (eval '(square foobar))) 42)\n",
    "*** ERROR -- Unbound variable: foobar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc442a00-42c0-47d7-913d-79ac39d82d8e",
   "metadata": {},
   "source": [
    "Finally, round brackets -- call syntax on $\\Xi$ -- can take an optional environment argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "ef1cf3c8-9dee-4091-960a-31c5b7f6b50d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (a200) \"['ϕοοβαρ']\">(cc10,ΓΠ) \"['γόὂ', 'square']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda π:  # fresh env created by implied call of APPLY\n",
    "    Ξ('square',  # Look me up in ΓΠ.\n",
    "      [Var('ϕοοβαρ')])(  # round brackets on the Ξ evaluate it ...\n",
    "      ECHO('π', π)),  # ... in this env, the fresh env of the outer call\n",
    "  ['ϕοοβαρ'])(  # formal parameter of the Λ; open ( implicitly calls APPLY\n",
    "    42)  # actual argument of implied call of APPLY, which makes fresh env"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec826a79-b3b5-4468-b649-387a5c245955",
   "metadata": {},
   "source": [
    "There is no equivalent in Gambit Scheme."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cf13206-d8d2-4f05-91f4-67efcee6dc99",
   "metadata": {},
   "source": [
    "# DEFINE(sym, val, $\\pi$)<a id=\"define\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df57b592-2563-476e-987e-3ca7f780953d",
   "metadata": {},
   "source": [
    "Package up the \"defining\" boilerplate."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9c19035-8083-4490-a7fa-eae9d2db1e60",
   "metadata": {},
   "source": [
    "By default, `DEFINE` binds symbols in $\\Gamma\\Pi$. The \"return value\" is consistent with Gambit Scheme, which doesn't return anything from a `define`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ff4420fa-eb4f-4ea0-8018-f2bf9e3d6f9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def DEFINE(\n",
    "        sym: str, \n",
    "        val: Any, \n",
    "        π: Environment=ΓΠ  # default\n",
    ") -> None:\n",
    "    \"\"\"official Scheme\"\"\"\n",
    "    setattr(π.ϕ, sym, val)\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbced021-36dc-473b-b791-0982f98794ea",
   "metadata": {},
   "source": [
    "## Examples:<a id=\"fancy\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2af00abd-1563-4c0c-87fb-387a6c4fd97d",
   "metadata": {},
   "source": [
    "Do some fancy stuff:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "ad1627a1-77b9-4c30-9f66-a1fc82e6664d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9, 16],\n",
       "       [ 1,  4]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "ΓΠ.square(numpy.array([[3, 4],[1, 2]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5829e308-0b9b-48df-9ccf-8e8b73ca13ab",
   "metadata": {},
   "source": [
    "> __IMPORTANT TODO__: Notice we are not delving into numerical semantics, just piggy-backing on the Python ecosystem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a02551d8-f48c-4907-82bc-90d46622a0e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE(\n",
    "    'saxpy', \n",
    "    Λ(lambda π: \n",
    "      # Fancy!\n",
    "      numpy.dot(π.a, π.x) \\\n",
    "      if isinstance(π.a, numpy.ndarray) \n",
    "      and isinstance (π.x, numpy.ndarray) \\\n",
    "      # Regular\n",
    "      else π.a * π.x + π.y, \n",
    "      ['a', 'x', 'y']));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d411832a-9c12-4a9f-ba31-d602aa455b75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 68],\n",
       "       [161]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "ΓΠ.saxpy(numpy.array([[1, 2, 3], [4, 5, 6]]),\n",
    "         numpy.array([[7], [11],[13]]),\n",
    "         numpy.array([[42], [43]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dad22bf-322f-4b31-8041-399c42293a2f",
   "metadata": {},
   "source": [
    "or just some ordinary stuff:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "8e16ae5d-8f34-4543-8f4f-87867469f1d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ΓΠ.saxpy(4, 10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1f2597c-cefd-42f4-af81-9e39c8895099",
   "metadata": {},
   "source": [
    "## SICP 3.2.2<a id=\"sicp-322\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "8cfcb5e3-3d96-4377-9957-f625e1081331",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "136"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('square', \n",
    "       Λ(lambda π: π.x * π.x, ['x']))\n",
    "\n",
    "DEFINE('sum_of_squares',\n",
    "       Λ(lambda π: π.square(π.x) + π.square(π.y), ['x', 'y']))\n",
    "\n",
    "DEFINE('f',\n",
    "       Λ(lambda π: π.sum_of_squares(1 + π.a, 2 * π.a), ['a']))\n",
    "\n",
    "ΓΠ.f(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "047f29c0-b09d-4e6e-8624-17890edbcf9e",
   "metadata": {},
   "source": [
    "Having `f` defined will bother us below. Get rid of it now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1133f7bb-ee49-4489-b481-d941cb2e9434",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    del ΓΠ.ϕ.f\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a08ca583-5050-4d4c-b427-36e8a5ffea7e",
   "metadata": {},
   "source": [
    "## SICP Exercise 3.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9684ccd8-bdc3-4b1d-8b86-8800972a8d7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('factorial',\n",
    "       Λ(lambda π: 1 if π.n < 2 else \\\n",
    "         π.n * π.factorial(π.n - 1), ['n']))\n",
    "\n",
    "ΓΠ.factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09a7cbfc-0681-4990-be95-8a6a8253926a",
   "metadata": {},
   "source": [
    "This next example doesn't tail-recurse because Python does not tail-recurse. We mitigate that in section [Tail Recursion](#tail-recursion)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "337e216e-6675-4929-9c77-4cb4fcf5cdbe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('fact_iter',\n",
    "       Λ(lambda π: π.product if π.counter > π.max_count else \\\n",
    "         π.fact_iter(\n",
    "           π.counter * π.product,\n",
    "           π.counter + 1,\n",
    "           π.max_count\n",
    "           ), ['product', 'counter', 'max_count']));\n",
    "\n",
    "ΓΠ.fact_iter(1, 1, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49333d00-057e-4136-82f5-602068a7e388",
   "metadata": {},
   "source": [
    "# Procedures that Apply Procedures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dceee784-b183-40be-9d47-94b1f2c285f1",
   "metadata": {},
   "source": [
    "Here is a procedure of two parameters, `f` and `x`, that applies `f` to `x`. In the example, bind `f` to `square`, `x` to 42, then invoke `f`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25dd113c-7776-4e92-a8f4-3fb238a5b1a4",
   "metadata": {},
   "source": [
    "(This example exposes a gargoyle in Python syntax regarding the positioning of call-parens.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "cd07f625-5eb2-46c4-8a65-159d1c8c299a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (4790) \"['f', 'x']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:     # Calling this λ chains a binding environment E1 to ΓΠ.\n",
    "  E1.f(ECHO('E1', E1).x),  # Apply E1.f to E1.x.\n",
    "  ['f', 'x'])(   # formal parameters (open paren must be on this line)\n",
    "ΓΠ.square, 42)   # <~~~ Bind f to square, x to 42."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96dca384-e7eb-4650-9885-d64772541adb",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "47a1e8bb-acab-4c2b-8c28-9703d790dcb5",
   "metadata": {},
   "source": [
    "> ((lambda (f x) (f x)) square 42)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63db30a9-559b-4069-8242-2fcbeaa47419",
   "metadata": {},
   "source": [
    "Here is a procedure that applies an internal anonymous procedure of `n` in `E2`. The outer procedure of `m` in `E1` is rooted in $\\Gamma\\Pi$. Read bottom-up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "54ec55c0-0ce7-423a-a117-f0bf0f51bb3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (4940) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (4af0) \"['n']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:      # Calling this Λ chains environment E1 to ΓΠ.\n",
    "  Λ(lambda E2:    # Calling this Λ chains environment E2 to ΓΠ.\n",
    "    E2.n * ECHO('E2', E2).n,  # <~~~ n is bound in E2;\n",
    "    ['n']         #      E2 is sibling to E1; parent of E2 is ΓΠ.\n",
    "   )(             # Parent of E1 is implicitly ΓΠ (open paren must be here).\n",
    "     ECHO('E1', E1).m),  # <~~~ invocation; Look up m in E1, bind to n in E2.\n",
    "  ['m'])(42)      # <~~~ Bind m to 42 in E1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b82df7-23d9-473a-8871-9f7523d51568",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "17f891df-c5fd-4ca3-9ea1-cf92f97a9544",
   "metadata": {},
   "source": [
    "> ((lambda (m)\n",
    "   ((lambda (n) (* n n))\n",
    "    m))\n",
    " 42)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ca0d25b-4113-4d53-bbfd-361c4878914b",
   "metadata": {},
   "source": [
    "`E1` and `E2` are siblings and can't see one another. In the next example `m` is a [free variable](#free-variable) in the inner $\\lambda$, not found in `E2`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "c72dfbf2-6db0-4a37-b880-94284d701d8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (4b80) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (4e50) \"['n']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "('Environment: Name m is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    Λ(lambda E1:      # Calling this λ chains environment E1 to ΓΠ.\n",
    "      Λ(lambda E2:    # Calling this λ chains environment E2 to ΓΠ.\n",
    "        E2.n * ECHO('E2', E2).m,  # <~~~ DIFFERENT: m is not found or bound in E2.\n",
    "        ['n']         #      E2 is sibling to E1.\n",
    "       )(             # Parent environment implicitly ΓΠ.\n",
    "          ECHO('E1', E1).m),  # <~~~ invocation. Look up m in E1, bind to n in E2.\n",
    "      ['m'])(42)      # <~~~ Bind m to 42 in E1.\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c1ebe2-d150-4247-b542-020b2b2c9905",
   "metadata": {},
   "source": [
    "Scheme _automatically_ chains environments into static closures, in which free variables are bound."
   ]
  },
  {
   "cell_type": "raw",
   "id": "d4b0feaf-d511-4bd1-9ea8-b4d20fa135a3",
   "metadata": {},
   "source": [
    "> ((lambda (m)\n",
    "   ((lambda (n) (* n m))  ; DIFFERENT\n",
    "    m))\n",
    " 42)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "809b92b0-5a00-4244-82b8-2528f8f30eb2",
   "metadata": {},
   "source": [
    "How do we emulate this? Schemulator requires an explicit chaining parameter because Schemulator does not know there are free variables in the body of the $\\Lambda$. Schemulator does not know because Schemulator does not parse, on purpose, [as explained in the introduction](#semantics). If Schemulator were Scheme, and thus parsing, it could determine that free variables occur in the body and then it could automatically chain environments. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48c35bf8-8653-4994-ac55-224ec0a54258",
   "metadata": {},
   "source": [
    "Schemulator forces the user to write environments, on purpose. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b04ad39c-cf69-4388-890d-e590e4a4d692",
   "metadata": {},
   "source": [
    "Here's the example above in Schemulator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "693a105e-ccae-4366-994c-95947c4557c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (5120) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (52d0) \"['n']\">(5120) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:      # Calling it creates environment E1 in ΓΠ.\n",
    "  Λ(lambda E2:    # !!!! LOOK BELOW Define this Λ in E1, not in ΓΠ, the default !!!!\n",
    "    E2.n * ECHO('E2', E2).m,  # <~~~ n in E1, x in E2.\n",
    "    ['n'],        #      (E2 is child of E1, written E1<--E2)\n",
    "    E1)(          # !!!! DIFFERENT Parent environment *explicitly* E1 !!!!\n",
    "         ECHO('E1', E1).m),  # <~~~ Look up n in E1, bind x in E2->E1\n",
    "  ['m'])(42)      # <~~~ Bind n to 42 in E1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cbb03f8-8dd4-4804-951d-812753992767",
   "metadata": {},
   "source": [
    "There is no Scheme equivalent."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d825a0e-d7cf-441a-a4a8-d617db4b0b75",
   "metadata": {},
   "source": [
    "## Return a Closure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e478e1-0f48-4f5b-a59a-c0602da0f471",
   "metadata": {},
   "source": [
    "Here's a Scheme example that, when called, returns a closure, that is, in-turn, called externally. This also happens to be an example of [_currying_](#thunk)."
   ]
  },
  {
   "cell_type": "raw",
   "id": "358aaee9-ff37-4cdf-854b-beace1412598",
   "metadata": {},
   "source": [
    "> (((lambda (m)\n",
    "       (lambda (n) (* n m))) 42) 42)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04edaa8a-a3be-448f-ab1f-f06c8b296d78",
   "metadata": {},
   "source": [
    "Here's the same example in Schemulator. The outer procedure doesn't _call_ the inner closure, but returns it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "6d77dfb5-b7b1-4f91-8dd8-4c72573a67e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (53f0) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (5360) \"['n']\">(53f0) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:\n",
    "  Λ(lambda E2:\n",
    "    E2.n * ECHO('E2', E2).m,\n",
    "    ['n'],\n",
    "    ECHO('E1', E1)),\n",
    "  ['m'])(42)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547aa5c2-06c5-42a0-8d1e-4109cb9df0f4",
   "metadata": {},
   "source": [
    "## Static Closure<a id=\"static-closure\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d534ecd0-a47c-4119-88c3-1b9f541c96f6",
   "metadata": {},
   "source": [
    "Static [closures](#closures) are created at define-time. In the next example, we assign a static closure to a Python variable, `foo`, then invoke it externally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "17a70032-7964-47bb-860c-6191ba88ad4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (e950) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (57e0) \"['n']\">(e950) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = Λ(lambda E1:\n",
    "        Λ(lambda E2:  # This Λ ...\n",
    "          E2.n * ECHO('E2', E2).m,\n",
    "          ['n'],\n",
    "          ECHO('E1', E1))  # <~~~ This Λ is defined in E1.\n",
    "        (E1.m),\n",
    "        ['m'])  # <~~~ This Λ is defined in ΓΠ, the default.\n",
    "foo(42)  # <~~~ 42 is bound to E1.m, in-turn bound to E2.n."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3655d21a-4377-4544-9001-2b3633e3f425",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "60a49ed3-8817-41da-b375-868848f3c5a4",
   "metadata": {},
   "source": [
    "> (define foo\n",
    "    (lambda (m)\n",
    "      (lambda (n) (* n m))))\n",
    "\n",
    "> (pp foo)\n",
    "(lambda (m) (lambda (n) (* n m)))\n",
    "\n",
    "> (pp (foo 42))\n",
    "(lambda (n) (* n m))\n",
    "\n",
    "> (pp ((foo 42) 42))\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af12683f-580c-485f-9d03-5dfa8ca58936",
   "metadata": {},
   "source": [
    "## Dynamic Closure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eaa3229-26b2-434c-abf6-6ad06fd9e410",
   "metadata": {},
   "source": [
    "If we explicitly `EVAL` the inner procedure of `E2` in the environment `E1` of the outer procedure, the evaluator dynamically splices the environments. The downside of this approach is that evaluation of the closure below, `bar`, splices the environments on every invocation. The upside is that it lets us create closures at run time from unclosed or partially closed procedures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1b31b75e-564d-47fe-963c-0bde9e32a64a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (5990) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (5b40) \"['n']\">(5990) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bar = Λ(lambda E1:\n",
    "        EVAL(\n",
    "            Λ(lambda E2:  # <~~~ This Λ is ...\n",
    "              E2.n * ECHO('E2', E2).m,\n",
    "              ['n']\n",
    "             ),  # <~~~ ... defined in global, but ...\n",
    "            ECHO('E1', E1))  # <~~~ ... evaluated in E1; envrmt spliced.\n",
    "        (E1.m),\n",
    "        ['m'])\n",
    "bar(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84107b3e-78af-4892-a15c-3d521ecdbe57",
   "metadata": {},
   "source": [
    "Gambit Scheme does not support dynamic closures, i.e., evaluating procedures in environments specified at run time. In the following, there is no way for `m`, as a free variable, to acquire a binding:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c045dbd3-9524-401d-adc6-63edf44acf7d",
   "metadata": {},
   "source": [
    "> (define foo\n",
    "    (lambda (n) (* n m)))\n",
    "\n",
    "> (with-exception-handler\n",
    "      pp\n",
    "    (lambda () (pp (foo 43))))\n",
    "#<unbound-global-exception #22>\n",
    "#<type-exception #23>\n",
    "#!void\n",
    "\n",
    "> (with-exception-handler\n",
    "      pp\n",
    "    (lambda () (pp ((foo 43) 42))))\n",
    "   #<unbound-global-exception #24>\n",
    "#<type-exception #25>\n",
    "#<nonprocedure-operator-exception #26>\n",
    "#!void"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d07570c-50e8-4656-936a-fe77148b4c59",
   "metadata": {},
   "source": [
    "If we do both, defining _and_ evaluating the inner $\\lambda$ in E1, we get only one copy of E1 containing `m`. Dynamic splicing in [`Environment`](#environment) checks this case and optimizes it away:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "228de8e2-3a94-4c1f-b51b-5ef114c9806d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E2': (5f30) \"['n']\">(5e10) \"['m']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:        \n",
    "  EVAL(        # EVAL the inner procedure itself ....\n",
    "      Λ(lambda E2:  \n",
    "        E2.n * ECHO('E2', E2).m,  # <~~~ n and m are Found in E2 by chaining ...\n",
    "        ['n'],                    #      ... but n is not Bound in E2.\n",
    "        E1     # DIFFERENT: !!!! explicitly defined in outer E1\n",
    "       ), E1)  # .... EVAL in the outer environment E1.\n",
    "  (E1.m),      # <~~~ Look up m in E1, bind to n in E2.\n",
    "  ['m'])(42)   # <~~~ Bind m to 42 in E1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62f4c5d3-a5a5-4b61-a852-79e82fa35ed2",
   "metadata": {},
   "source": [
    "There is no Scheme equivalent."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d426d108-60b8-4d3d-aa34-9ae1c55c06cc",
   "metadata": {},
   "source": [
    "## Shadowing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65909014-44a9-4938-b646-61b8e0d4df36",
   "metadata": {},
   "source": [
    "Because the two variables `m` and `n` are in different environments, they can have the same name. `E2.n` (value 42) ___shadows___ `E1.n` (value 43), meaning that `E1.n` is inaccessible from `E2`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "5aca4f8c-6401-4d1b-b687-3bb56a0e7146",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E2': (6050) \"['n']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2.n': 42}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:\n",
    "  Λ(lambda E2:\n",
    "    E2.n * ECHO('E2.n', ECHO('E2', E2).n),\n",
    "    ['n']),\n",
    "  ['n'])(43)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d50daf1-1edb-4408-afc4-954f0e3c21aa",
   "metadata": {},
   "source": [
    "Scheme equivalent; the inner `n`, bound to 43, is inaccessible:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c618a4e9-5b9b-4398-b732-e70c8d8bbc42",
   "metadata": {},
   "source": [
    "> (define foo\n",
    "    (lambda (n)\n",
    "      (lambda (n) (* n n))))\n",
    "\n",
    "> (pp foo)\n",
    "(lambda (n) (lambda (n) (* n n)))\n",
    "\n",
    "> (pp (foo 43))\n",
    "(lambda (n) (* n n))\n",
    "\n",
    "> (pp ((foo 43) 42))\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb392770-fe90-47ce-a42c-99c7db26d0df",
   "metadata": {},
   "source": [
    "The same happens, even when we explicitly chain environments. See by inspecting the addresses in hex, that `E2` precedes `E1` in the chain, so a lookup of `n` starting at `E2` will find `n` in `E2` and never progress to `E1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "7dc51748-7e0d-4348-8280-6e92955a934b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'E1': (6440) \"['n']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2': (63b0) \"['n']\">(6440) \"['n']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n",
      "\n",
      "{'E2.n': 42}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:\n",
    "  Λ(lambda E2:\n",
    "    E2.n * ECHO('E2.n', ECHO('E2', E2).n),\n",
    "    ['n'], \n",
    "   ECHO('E1', E1)),\n",
    "  ['n'])(43)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f095eff-2748-4c77-a225-d0bee4c52a8e",
   "metadata": {},
   "source": [
    "As usual, there is no Scheme equivalent for explicitly chained environments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4af2acd-c522-40db-bea0-85611e6091b1",
   "metadata": {},
   "source": [
    "# Procedures that Return Procedures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9242bdab-3121-4b5b-b456-00c580d276ec",
   "metadata": {},
   "source": [
    "The outer $\\Lambda$ below is the identity function: it returns its argument. It's applied to `ΓΠ.square`, which is closed _only_ over the global environment, returning it. The result is applied to 42:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "151a96a5-226d-400f-bc35-f612dd17fd4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda E1:  # Calling it creates environment E1 in ΓΠ.\n",
    "  E1.f,       # Just return the value of parameter f.\n",
    "  ['f'])(     # Parent environment is implicitly ΓΠ.\n",
    " ΓΠ.square)(  # <~~~ 'square' is bound in ΓΠ.\n",
    " 42)          # Apply the returned procedure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e9e93e8-ae81-49ed-9d71-a2fbb6916b49",
   "metadata": {},
   "source": [
    "Return a fresh anonymous procedure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "563871af-7158-4864-b361-1f4916660c0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda π: π.f, ['f'])(             # identity function as above ...\n",
    "    Λ(lambda π: π.x * π.x, ['x']))(  # ... applied to anonymous procedure;\n",
    "42)                                  # Apply the returned procedure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "023eec22-6e1f-484a-a1e5-cda41054dd0e",
   "metadata": {},
   "source": [
    "Scheme equivalents:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c2e44b8c-f483-4593-90c1-b5438aa9a3d0",
   "metadata": {},
   "source": [
    "> (((lambda (f) f) square) 42)\n",
    "1764\n",
    "> (((lambda (f) f) (lambda (x) (* x x))) 42)\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6303abd1-bb0a-4067-94ff-6e1a430fd7ab",
   "metadata": {},
   "source": [
    "# Thunks and Currying<a id=\"thunk\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1512af-c2c4-4a76-95a3-ed1f97cd0dbf",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___thunk___ is a procedure of no arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e49f49-999f-4c50-a87d-ed9bbfa607c8",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___1-thunk___ is a procedure of one argument. 1-thunks are the only kind of procedure, and they're all pure functions, with no side-effects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "400b202a-ef66-4759-910f-a94757e470c1",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___curried___ function is a procedure of many arguments transformed into a composition of 1-thunks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "073d6cae-8b47-422d-b94f-e3df5c426ad8",
   "metadata": {},
   "source": [
    "For example, in ordinary Python, the following $\\lambda$ of `x` and `y`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "93e18561-7c08-4d1b-bd9f-2af807294e06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1807"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y: x + y**2)(43, 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b5604e5-92f1-4964-b017-550f2ac99a90",
   "metadata": {},
   "source": [
    "is curried into the following: a $\\lambda$ of `x` returning a $\\lambda$ of `y`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "066e0d54-7624-4cc2-91a4-595f9d775c33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1807"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x: (lambda y: x + y**2))(43)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0445af31-c0bb-4878-bde2-0cf49cc3aa15",
   "metadata": {},
   "source": [
    "Here are these examples in Schemulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "c601ec12-c8ba-4e95-8cf8-d46e9ecf301b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1807"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda π: π.x + π.y**2, ['x', 'y'])(43, 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "95617ab3-6183-4c13-806c-a8fb42b834ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1807"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo: \n",
    "  Λ(lambda πi: πi.x + πi.y**2, \n",
    "    ['y'], \n",
    "    πo),  # <~~~ explicit chaining\n",
    "  ['x'])(43)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12c9e926-8f5b-4a06-920b-cbf73cbbe467",
   "metadata": {},
   "source": [
    "Notice that `x` occurs [free](#free-variables) in the inner $\\lambda$ but [bound](#bound-variables) in the outer $\\lambda$. As always, be wary of [the confusing terminology \"bound variable\"](#confusing). Also notice that the curried form requires two invocations, one for each formal parameter of the two 1-thunks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c30a8ce-37f0-41bd-9f69-b1317bf2ab4d",
   "metadata": {},
   "source": [
    "The name \"curried\" comes from Haskell Curry, who developed the theory of analyzing all functions as 1-thunks. Haskell Curry also gave his name to the World's most prominent pure functional programming language, Haskell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95af66dd-1cbb-41ad-b00b-4c2f15d47eaf",
   "metadata": {},
   "source": [
    "In many examples below, we will work with curried functions, but eventually leave them behind because they're often less than intuitive and they are mathematically equivalent to non-curried forms. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a2d573f-fc3b-4057-92c5-dfb0dc3fc907",
   "metadata": {},
   "source": [
    "# $\\Upsilon$: Squaring Square Roots of Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27505a0a-27f2-4208-ba75-2ba8dbe50956",
   "metadata": {},
   "source": [
    "Anonymous recursive procedures are fundamental; the Ultimate Imperative requires them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa941f14-a865-46ff-8d63-6fe3c91610fa",
   "metadata": {},
   "source": [
    "[See this other noteobook](https://github.com/rebcabin/rebcabin.github.io/blob/main/PythonYCombinators.md) for detailed explanations of the following development."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4599b260-3c75-44ab-82ff-4e8138b06b84",
   "metadata": {},
   "source": [
    "The running examples are factorial and Fibonacci."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e55ba32-d65f-479e-8be9-c13e4fb7382c",
   "metadata": {},
   "source": [
    "Don't forget non-default `πsf` on the inner definition, lest `sf` be unbound in the inner $\\lambda$. `sf` is the \"square root\" of the recursive function we want, square-root in an abstract algebraic sense where function application is multiplication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "e451dac2-5973-4a25-beef-5b682c8f8aba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πsf:  # <~~~ Apply this Λ ...\n",
    "  Λ(lambda πn: \n",
    "    # Observe the \"multiplication\" sf(sf):\n",
    "    1 if πn.n < 1 else πn.n * πn.sf(πn.sf)(πn.n - 1), \n",
    "    ['n'], πsf),  # <~~~ Don't forget!\n",
    "  ['sf'])(  # <~~~ ... to a copy of itself.\n",
    "    Λ(lambda πsf:  # <~~~ bind this Λ to upper 'sf'\n",
    "      Λ(lambda πn: \n",
    "        1 if πn.n < 1 else πn.n * πn.sf(πn.sf)(πn.n - 1), \n",
    "        ['n'], πsf),   # <~~~ Don't forget!\n",
    "      ['sf']))(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c630841a-2cb6-4bfd-b201-ff2a1ea07c95",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "078c1dcf-ae5d-4ddb-9b89-fea6b9060aaa",
   "metadata": {},
   "source": [
    "(((lambda (sf)\n",
    "    (lambda (n)\n",
    "      (if (< n 1)\n",
    "          1\n",
    "          (* n ((sf sf) (- n 1))))))\n",
    "  (lambda (sf)\n",
    "    (lambda (n)\n",
    "      (if (< n 1)\n",
    "          1\n",
    "          (* n ((sf sf) (- n 1)))))))\n",
    " 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7576a93-7e2c-44fa-84ce-27a162577bbf",
   "metadata": {},
   "source": [
    "Abstract `sf(sf)(m)` into a `f`, a delayed $\\lambda$ of `m`. That means \"replace `sf(sf)(m)` with `f(m)` in the business code, and bind `f` to a new $\\lambda(m)$ that is `sf(sf)(m)`. The environments are chained through every level, as exhibited by the `ECHO`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "5a767251-c8a9-4c40-a2b6-236c33b659c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'πm': (5750) \"['m']\">(56c0) \"['sf']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πsf:\n",
    "  Λ(lambda πf:  # Domain code d is a function of business code f.\n",
    "    Λ(lambda πn:  # Business code f is a function of business parameter n.\n",
    "      1 if πn.n < 1 else πn.n * πn.f(πn.n - 1), \n",
    "      ['n'], πf), \n",
    "    ['f'], πsf)(\n",
    "      Λ(lambda πm:  # Delayed application of business code f = sf(sf).\n",
    "        πm.sf(πm.sf)(ECHO('πm', πm).m), \n",
    "        ['m'], πsf)), \n",
    "  ['sf'])(  # <~~~ Apply to copy of self:\n",
    "Λ(lambda πsf:\n",
    "  Λ(lambda πf:  # Domain code d is a function of business code f.\n",
    "    Λ(lambda πn:  # Business code f is a function of business parameter n.\n",
    "      1 if πn.n < 1 else πn.n * πn.f(πn.n - 1), \n",
    "      ['n'], πf), \n",
    "    ['f'], πsf)(\n",
    "      Λ(lambda πm:  # Delayed application of business code f = sf(sf).\n",
    "        πm.sf(πm.sf)(πm.m), \n",
    "        ['m'], πsf)), \n",
    "  ['sf']))(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99d45b8b-dd3f-4d84-8d1f-54c94c9bb5c6",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d004f037-d0f5-457b-9da6-42bbe24a544b",
   "metadata": {},
   "source": [
    "(((lambda (sf)\n",
    "    ((lambda (f)\n",
    "       (lambda (n)\n",
    "         (if (< n 1)\n",
    "             1\n",
    "             (* n (f (- n 1))))))\n",
    "     (lambda (m) ((sf sf) m))))\n",
    "  (lambda (sf)\n",
    "    ((lambda (f)\n",
    "       (lambda (n)\n",
    "         (if (< n 1)\n",
    "             1\n",
    "             (* n (f (- n 1))))))\n",
    "     (lambda (m) ((sf sf) m)))))\n",
    " 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a08473b0-21fe-4449-b404-2087a29ede5d",
   "metadata": {},
   "source": [
    "Abstract the ___domain code___ into `d`, a function of the ___business code___ `f`, which, in-turn, is a function of the ___business parameter___ `n`, then involute $\\lambda(d)$ and $\\lambda(\\sqrt{f})$ to bring $\\lambda(d)$ outward. Notice that the domain code is isolated and no longer duplicated. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a388432c-073c-4cc9-b822-f132461d46cc",
   "metadata": {},
   "source": [
    "The two steps are broken out in the Scheme equivalents. The Schemulator code below is the result of the second, involuation step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "57a340f0-4da0-492f-93fd-0f6561b1d307",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'πm': (5750) \"['m']\">(5b40) \"['sf']\">(5510) \"['d']\">(cc10,ΓΠ) \"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πd:\n",
    "  Λ(lambda πsf:  # sf; copy this Λ below ...\n",
    "    πd.d(Λ(lambda πm: πm.sf(πm.sf)(ECHO('πm', πm).m),\n",
    "          ['m'], πsf)),\n",
    "    ['sf'], πd)(  # <~~~ \"squaring,\" i.e., self-application\n",
    "      Λ(lambda πsf:  # sf; .... right here\n",
    "        πd.d(Λ(lambda πm: πm.sf(πm.sf)(πm.m), \n",
    "              ['m'], πsf)),\n",
    "        ['sf'], πd)), \n",
    "  ['d'])(  # d is the formal parameter for domain code\n",
    "    Λ(lambda πf:  # Domain code d is a function of business code f.\n",
    "      Λ(lambda πn:  # Business code f is a function of business parameter n.\n",
    "        1 if πn.n < 1 else πn.n * πn.f(πn.n - 1), \n",
    "        ['n'], πf),  # n: business parameter\n",
    "      ['f'])  # square of sf, recursive function\n",
    "    )(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a54f94b-2071-47ef-894d-189ed18e772c",
   "metadata": {},
   "source": [
    "Scheme equivalent, step 1; abstract domain code:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "dc4e68b3-3cbd-43d5-a412-65299071ab68",
   "metadata": {},
   "source": [
    "(((lambda (sf)\n",
    "    ((lambda (d)\n",
    "       (d (lambda (m) ((sf sf) m))))\n",
    "     (lambda (f)\n",
    "       (lambda (n)\n",
    "         (if (< n 1)\n",
    "             1\n",
    "             (* n (f (- n 1))))))))\n",
    "  (lambda (sf)\n",
    "    ((lambda (d)\n",
    "       (d (lambda (m) ((sf sf) m))))\n",
    "     (lambda (f)\n",
    "       (lambda (n)\n",
    "         (if (< n 1)\n",
    "             1\n",
    "             (* n (f (- n 1)))))))))\n",
    " 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad5cde5-f7ee-4685-88d3-8eb365352fac",
   "metadata": {},
   "source": [
    "Scheme equivalent, step 2; involute $\\lambda(d)$ and $\\lambda(\\sqrt{f})$. Notice that domain code is now isolated outside and appears only once:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9899ede5-1c24-4a88-b102-ddd356efa4b6",
   "metadata": {},
   "source": [
    "(((lambda (d)\n",
    "    ((lambda (sf)\n",
    "       (d (lambda (m) ((sf sf) m))))\n",
    "     (lambda (sf)\n",
    "       (d (lambda (m) ((sf sf) m))))))\n",
    "  (lambda (f)\n",
    "    (lambda (n)\n",
    "      (if (< n 1)\n",
    "          1\n",
    "          (* n (f (- n 1)))))))\n",
    " 6)\n",
    " 720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b15c6ba-b8ca-4b44-9889-a3072254912a",
   "metadata": {},
   "source": [
    "Remove the duplication of the squaring code; abstract it (the self-application) into `g`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "310477d3-5718-4d51-9596-12286c93d866",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πd:  # function of domain code, d\n",
    "  Λ(lambda πg:  # generic squaring gizmo \n",
    "    πg.g(πg.g), ['g'], πd)(\n",
    "      Λ(lambda πsf: \n",
    "        πd.d(Λ(lambda πm: πm.sf(πm.sf)(πm.m), \n",
    "               ['m'], πsf)),\n",
    "        ['sf'], πd)), \n",
    "  ['d'])(  # formal parameter d for domain code\n",
    "    Λ(lambda πf:  # Domain code d is a function of business code f.\n",
    "      Λ(lambda πn:  # Business code f is a function of business parameter n.\n",
    "        1 if πn.n < 1 else πn.n * πn.f(πn.n - 1), # business code\n",
    "        ['n'], πf),  # n: business parameter\n",
    "      ['f'])  # square of sf, recursive function\n",
    ")(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f85f894b-9cff-455b-b5ed-3f67817624a6",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "899d4f4b-c681-4555-9cb6-56c5e1caa065",
   "metadata": {},
   "source": [
    "(((lambda (d)\n",
    "    ((lambda (g) (g g))\n",
    "     (lambda (sf)\n",
    "       (d (lambda (m) ((sf sf) m))))))\n",
    "  (lambda (f)\n",
    "    (lambda (n)\n",
    "      (if (< n 1)\n",
    "          1\n",
    "          (* n (f (- n 1)))))))\n",
    " 6)\n",
    " 720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e795c1ea-5886-46c7-8a6e-e17898af7d3d",
   "metadata": {},
   "source": [
    "## Recursivion via $\\Upsilon{}1$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e46ea340-c9f3-44ba-8a17-944ebe73245a",
   "metadata": {},
   "source": [
    "Now we can see that the function of domain code `d` is generic. Let's call it $\\Upsilon$1 and define it in the global environment. The \"1\" in the name means that $\\Upsilon{}1$ takes domain codes that return [1-thunk](#thunk) business codes, i.e., business codes of one parameter. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c2a3bae-3fe2-470b-b7b2-f5b679a0de0e",
   "metadata": {},
   "source": [
    "The glyph that looks like \"Y\" is actually capital Upsilon ($\\Upsilon$ in $\\LaTeX$). Names in user code should not collide with it if users remember to [avoid Greek](#greek)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "c7c62c77-027f-4cc9-9bac-9e4d6124fa3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('Υ1', \n",
    "       Λ(lambda πd: # Υ1 is function of domain code, d.\n",
    "         # d is a function of business code f, that \n",
    "         # returns new business code that can refer to f. \n",
    "         Λ(lambda πg: πg.g(πg.g), ['g'], πd)(  # λ(g) applied to ...\n",
    "             Λ(lambda πsf:  # generic square root.\n",
    "               πd.d(Λ(lambda πm: πm.sf(πm.sf)(πm.m), \n",
    "                      ['m'], πsf)),\n",
    "               ['sf'], πd)), \n",
    "         ['d']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc7f006f-a562-497e-be22-36be2c63b634",
   "metadata": {},
   "source": [
    "### Fact-Recursive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6ceb51b-b172-405a-881f-266bcd671133",
   "metadata": {},
   "source": [
    "Write a domain code that returns a business code of recursive, but externally anonymous, `f`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "03ffcf72-8f4f-427c-87b6-42e1c651ac88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('fact_recursive',\n",
    "      Λ(lambda π: # Domain code is a function of business code, f ...\n",
    "        Λ(lambda π: # ... that returns business code that can call f.\n",
    "          1 if π.n < 1 else π.n * π.f(π.n - 1), # business code\n",
    "          ['n'], π), # 1 business parameter, n\n",
    "        ['f'])) # recursive function\n",
    "\n",
    "ΓΠ.Υ1(ΓΠ.fact_recursive)(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7299a48f-dac6-43ca-959f-7de92f0f6bd9",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b0aa6094-407d-4ecb-a8e1-af39841e4368",
   "metadata": {},
   "source": [
    "(define (fact-recursive f)\n",
    "  \"domain code; Return a curried business code.\"\n",
    "  (lambda (n) (if (< n 1)\n",
    "                  1\n",
    "                  (* n (f (- n 1))))))\n",
    "\n",
    "(define (Y1 d)\n",
    "  \"d is domain code, a function that receives business code.\"\n",
    "  ((lambda (g) (g g))\n",
    "   (lambda (sf) (d (lambda (m) ((sf sf) m))))))\n",
    "\n",
    "((Y1 fact-recursive) 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee3789f3-095d-428d-b299-d70b914a2b26",
   "metadata": {},
   "source": [
    "## Examples via $\\Upsilon{}3$<a id=\"iterative-factorial\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82691675-93ae-4d19-8e7e-b5f2e7d92387",
   "metadata": {},
   "source": [
    "$\\Upsilon$ can be tailored for a given number of business parameters. This one is for three."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "6ee91c25-be26-401d-b4de-e218b3cd1ba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# λ d: (λ g: g[g])(λ sf: d[λ m, c, x: sf[sf][m, c, x]]) \n",
    "DEFINE('Υ3', \n",
    "       Λ(lambda πd:  # of d, the domain code ...\n",
    "         Λ(lambda πg: πg.g(πg.g), ['g'], πd)(\n",
    "             # ... of business code of three parameters\n",
    "             Λ(lambda πsf: πd.d(  # domain code\n",
    "                 Λ(lambda π: \n",
    "                   π.sf(π.sf)(π.μ, π.γ, π.ξ),  # business code\n",
    "                   ['μ', 'γ', 'ξ'], πsf)),  # business parameters\n",
    "               ['sf'], πd)), \n",
    "         ['d']));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c77053b8-da28-4922-b419-93b794ed6625",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9f016869-cc7e-49e2-a8af-f97d71fe118a",
   "metadata": {},
   "source": [
    "(define (Y3 d)\n",
    "  \"d is domain code, a function that receives business code, a\n",
    "function of three business parameters.\"\n",
    "  ((lambda (g) (g g))\n",
    "   (lambda (sf) (d (lambda (m c x)\n",
    "                     ((sf sf) m c x))))))\n",
    "\n",
    "((Y3 fact-iter) 1 1 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d8c7031-324e-4002-abf1-d30225209a24",
   "metadata": {},
   "source": [
    "Later, we generalize $\\Upsilon$ to any number $N$ of business parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa4237b5-1c9b-4640-85c8-9bc72aa69aa6",
   "metadata": {},
   "source": [
    "### Fact-Iter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fffeb3d9-5ece-40fb-a569-cfa080f5980a",
   "metadata": {},
   "source": [
    "Here is user-level domain code, redefining `fact_iter` in domain-code form. Any domain code is a function of `f`, recursive business code. In this case, `f` is a function of 3 business parameters. This will get us to a tail-recursive solution in the [section on tail recursion](#tail-recursion)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "85b368a2-2dbc-42ab-9045-f1fbe5b750df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# λ f: λ m, c, x: m if c > x else f(m*c, c+1, x)\n",
    "DEFINE('fact_iter', # domain code is a function of f ...\n",
    "       Λ(lambda π: # ... which is business code.\n",
    "         Λ(lambda π: \n",
    "           π.m \n",
    "           if π.c > π.x \n",
    "           else π.f(π.m * π.c, π.c + 1, π.x), # business code\n",
    "           ['m', 'c', 'x'], π), # business parameters\n",
    "         ['f']));\n",
    "\n",
    "ΓΠ.Υ3(ΓΠ.fact_iter)(1, 1, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "385b9a86-5130-4085-97fd-b839928cd69f",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ddfc1be9-7762-41b6-bfe4-60fbee554269",
   "metadata": {},
   "source": [
    "(define (fact-iter f)\n",
    "  \"domain code; Return a business code of three parameters.\"\n",
    "  (lambda (m c x)\n",
    "    (if (> c x)\n",
    "        m\n",
    "        (f (* m c) (+ c 1) x))))\n",
    "\n",
    "((Y3 fact-iter) 1 1 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baa87f5a-d74b-43af-b51a-82a2dc288e96",
   "metadata": {},
   "source": [
    "# Tail Recursion<a id=\"tail-recursion\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfb59f0b-799e-4cbf-8733-d6c31f790859",
   "metadata": {},
   "source": [
    "> __OBSERVATION__: The Ultimate Imperative requires anonymous _tail-recursive_ procedures."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53926c86-eb59-4a15-8edc-a539aacacd76",
   "metadata": {},
   "source": [
    "Thanks to [Thomas Baruchel for the idea of Exceptions to implement tail recursion](https://stackoverflow.com/questions/13591970/does-python-optimize-tail-recursion)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f04fbcb-e60a-42e3-89c0-8fa9662a6926",
   "metadata": {},
   "source": [
    "If users are aware that their domain code is tail-recursive, then they may call it via `LOOP` instead of via $\\Upsilon$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a44d66c-03de-4db1-9642-e0a1c6882369",
   "metadata": {},
   "source": [
    "Scheme detects tail recursion automatically. It parses user code and marks un-nested tail calls. Schemulator doesn't parse, [on purpose](#semantics), and [Python infamously avoids tail recursion](https://stackoverflow.com/questions/13591970/does-python-optimize-tail-recursion). In Python and Schemulator, users must invoke tail recursion explicitly. This isn't terrible. Tail-calls are lexically obvious, so users should always know. In Clojure, there is precedent: users explicitly write `loop` and `recur`. In any event, tail-recursive domain code can always be called via non-tail-recursive $\\Upsilon$, it just won't be as fast nor as resistent to stack overflow."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddb4d2d8-e845-45ec-abb4-be35168e9f9c",
   "metadata": {},
   "source": [
    "## `LOOP3`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cf86244-cba1-41b7-8b82-c13e3f6db014",
   "metadata": {},
   "source": [
    "`LOOP3` has the same signature as $\\Upsilon3$; it takes domain code of business code of three arguments as its sole argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13bdfde-a541-4126-8910-0213df02c8cc",
   "metadata": {},
   "source": [
    "The glyph that looks like \"P\" below is Greek Capital Rho for \"recur.\" Names in user code will not collide with P if users remember to [avoid Greek](#greek). As with $\\Upsilon$, Rho and `LOOP` must know their argument counts. That's fixed below with `LOOPN`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "470b55c3-b93d-4809-a523-7ad60e084ea9",
   "metadata": {},
   "source": [
    "`LOOP3` receives domain code, which receives recursive business code `f` of three business parameters. In the base case of its recursion, `f` just returns a result from the business parameters, else `f` calls `f` recursively. `LOOP3` calls the domain code with `f = P3`, which recurses by raising an exception that overwrites arguments with new values. `LOOP3` loops until that exception is not raised."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "872094eb-d9fd-473c-8d10-746eed1bf7ce",
   "metadata": {},
   "source": [
    "> __WARNING__: ***Results are undefined if any `LOOP` function is called with non-tail-recursive domain code.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "94bf948f-c5fd-46dc-844e-9aaf1a3a2b80",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TailCall(Exception):  \n",
    "    \"\"\"αναδρομική κλήση\"\"\"\n",
    "    def __init__(self, *args):\n",
    "        \"\"\"Overwrite old args with new.\"\"\"\n",
    "        self.args = args\n",
    "\n",
    "def RECUR(*args):  \n",
    "    \"\"\"υψώνω: in sincere flattery of Clojure\"\"\"\n",
    "    raise TailCall(*args)\n",
    "\n",
    "def LOOP3(d: Procedure) -> Procedure:  # domain code\n",
    "    \"\"\"in sincere flattery of Clojure, and thanks to Thomas Baruchel.\"\"\"\n",
    "    # in the global environment, ΓΠ,\n",
    "    DEFINE('Ρ3', Λ(lambda π: RECUR(π.m, π.c, π.x), ['m', 'c', 'x']));\n",
    "    def looper(*args):\n",
    "        \"\"\"Expression form of a while-loop statement.\"\"\"\n",
    "        while True:\n",
    "            try: \n",
    "                return d(ΓΠ.Ρ3)(*args)\n",
    "            except TailCall as e:\n",
    "                args = e.args\n",
    "    ρ = Λ(lambda π: looper(π.m, π.c, π.x), ['m', 'c', 'x'], π=d.π)\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2409d781-55e6-4e82-bd31-6c93d6b775bd",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "99fd8104-9a3b-4d9a-adb6-0f08a290a723",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LOOP3(ΓΠ.fact_iter)(1, 1, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af704044-9b85-4171-a038-e5f3297f9081",
   "metadata": {},
   "source": [
    "Scheme automatically tail-recurses, so explicit alternatives are not necessary. However, they are instructive."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee7e30b-abb8-4df2-a659-7e5545624b41",
   "metadata": {},
   "source": [
    "Gambit Scheme has an extension for exceptions, permitting a direct transcription of the implementation above:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "112ef24a-e57a-4685-bcbf-f3fe09cb10c3",
   "metadata": {},
   "source": [
    "(define (LOOP3 d)\n",
    "  ;; P3 calls looper with new args:\n",
    "  (define (P3 m+ c+ x+)\n",
    "    (raise (list m+ c+ x+)))  ; <~~~ Gambit extension\n",
    "  (define (looper m c x)\n",
    "    (with-exception-handler  ; <~~~ Gambit extension\n",
    "        ;; This is how P3 calls looper, indirectly:\n",
    "        (lambda (e)\n",
    "          (apply looper e))\n",
    "        ;; Pass P3 to domain code. If domain code calls P3,\n",
    "        ;; looper recurses, otherwise returns result below.\n",
    "        (lambda ()  ; With-exception-handler requires thunk.\n",
    "          ((d P3) m c x))))\n",
    "  looper)\n",
    "\n",
    "((LOOP3 fact-iter) 1 1 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf64eafa-c7b9-4018-bd37-83022f52aa61",
   "metadata": {},
   "source": [
    "That is not idiomatic Scheme. Instead, we must use `call-with-current-continuation`, or `call/cc`:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "3e66d6c6-1006-4183-93c3-cf3fdfcc29d7",
   "metadata": {},
   "source": [
    "(define (LOOP3 d)\n",
    "  (define (P3  m c x)\n",
    "    (call/cc (lambda (k)\n",
    "               (k ((d P3) m c x)))))\n",
    "  P3)\n",
    "\n",
    "((LOOP3 fact-iter) 1 1 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30d62b92-a6d4-443a-b45d-879d2893f0dd",
   "metadata": {},
   "source": [
    "This is frighteningly consise, like all `call/cc` code, at first glance, but not too bad if explained: `LOOP3` takes user's domain code `d` and closes over it in the _generic_ recursive business code `P3` of three business parameters named (capriciously) `m`, `c`, `x`. The recursive business code `P3` is passed to the domain code `d`. If `(d P3)` calls `P3`, as it should do in the recursive case, then `P3` recurses unconditionally by calling the continuation `k`. Otherwise, in the base case of its recursion, `(d P3)` doesn't call `P3` and `P3` just returns the result of `(d P3)` applied to actual-argument values for `m`, `c`, and `x`, 1, 1, and 6 in this case."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3261d8f-1396-4a15-b089-fceb4eb212b7",
   "metadata": {},
   "source": [
    "It is often much more difficult to devise scenarios with `call/cc` than it is to explain them. I suppose that is the reason that programmers prefer `try-except` to `call/cc` and mainstream programming languages like Python don't even offer `call/cc` or its generalization, [delimited continuations](https://en.wikipedia.org/wiki/Delimited_continuation)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a1535b8-6e3f-4071-987d-af88c22a6166",
   "metadata": {},
   "source": [
    "## Prove It on `fact_iter`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b969d0b0-2677-4681-b7f4-4fc92e03fd72",
   "metadata": {},
   "source": [
    "The recursive call via Schemulator $\\Upsilon$ blows Python's recursion limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "22aa12bb-ce0d-4485-8671-89cc03088334",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('maximum recursion depth exceeded in __instancecheck__',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.Υ3(ΓΠ.fact_iter)(1, 1, 400))\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8b113d-d655-4316-ae18-f0289ca764c4",
   "metadata": {},
   "source": [
    "Call via `LOOP3` does not. Notice the domain code `fact_iter` is EXACTLY the same as in the recursive call above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "ead045e6-152f-45b6-8ffd-6e786fbd92e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(LOOP3(ΓΠ.fact_iter)(1, 1, 400))\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ef9da0d-2fc9-4507-ba99-13979b7f1cf5",
   "metadata": {},
   "source": [
    "## Tail-Recursive Fibonacci<a id=\"tail-recursive-fibonacci\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60b0fecb-ebee-4d3f-8090-8f5db2455eb4",
   "metadata": {},
   "source": [
    "Write domain code for catastropically slow, non-tail-recursive, exponentially diverging Fibonacci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "24124806-e810-41be-8e4a-6f6f46285ed1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('fib_slow', \n",
    "       Λ(lambda π: \n",
    "         Λ(lambda π: 1 if π.n < 2 else \n",
    "           π.f(π.n - 1) + π.f(π.n - 2), ['n'], π),\n",
    "         ['f']))\n",
    "\n",
    "ΓΠ.Υ1(ΓΠ.fib_slow)(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7f288c-9039-40cc-9c01-003182f35e82",
   "metadata": {},
   "source": [
    "This is miserable even for $n=23$. Don't call it for bigger arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "2dd5dea4-5f9a-440b-a384-679bd0a7c2f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46368"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ΓΠ.Υ1(ΓΠ.fib_slow)(23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aea67273-35ab-432d-9798-ad0026a2cbbb",
   "metadata": {},
   "source": [
    "The following takes 10 seconds. Uncomment if you want to see the time per iteration: about 1,000 ms; YES, a full second!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "856660f2-c796-4c20-89e9-ccdbf1229705",
   "metadata": {},
   "outputs": [],
   "source": [
    "# timeit(ΓΠ.Υ1(ΓΠ.fib_slow)(23))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32b88ec-94c0-4f45-9512-403a30ae82d6",
   "metadata": {},
   "source": [
    "Without linearization, Fibonacci 500 would not complete in $10^{30}$ times the Age of the Universe. One way to linearize is tail recursion. Another way is [memoization](#memoization) (_sic:_ not _memorization_)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71b0e222-4c0a-4a58-bba2-1c977255ae6c",
   "metadata": {},
   "source": [
    "Tail-recursive memoization is possible but not necessary. A tail-recursive Fibonacci easy and blazingly fast:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "a3ce9fbc-3609-4751-87fc-91437bd65a5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('fib_iter',\n",
    "       Λ(lambda π:\n",
    "         Λ(lambda π: π.b if π.n < 1 else \n",
    "           π.f(π.b, π.a + π.b, π.n - 1),\n",
    "           ['a', 'b', 'n'], π),\n",
    "         ['f']));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea746bc4-101b-45ae-b3f3-a990f87ff58a",
   "metadata": {},
   "source": [
    "Check it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "fac98926-a4b3-4002-b421-5007ca391f49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46368"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LOOP3(ΓΠ.fib_iter)(0, 1, 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a1608a3-16eb-4d31-aaaa-5b89695df800",
   "metadata": {},
   "source": [
    "Time it. The following takes 10 seconds. Uncomment if you want see 250 _micro_ seconds, or so, 4000 times faster on this argument, 23. Exponentially faster on bigger arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "fe6d7ec8-cd48-4172-a9d9-fe64346dee16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# timeit(LOOP3(ΓΠ.fib_iter)(0, 1, 23))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d003b80-33b9-46e6-899c-e6d8a8b01337",
   "metadata": {},
   "source": [
    "Stress it, remembering that the non-tail-recursive version would not complete in astronomical time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "2ea94848-5fba-46f2-aa48-209b085369d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "225591516161936330872512695036072072046011324913758190588638866418474627738686883405015987052796968498626"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LOOP3(ΓΠ.fib_iter)(0, 1, 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c29ff3d0-9914-43f1-889e-2afea66b6666",
   "metadata": {},
   "source": [
    "# Memoized [sic] Fibonacci<a id=\"memoization\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7076d2e-e185-4d95-b2f3-702ff91876bf",
   "metadata": {},
   "source": [
    "We do not bother with Scheme equivalents for code in this chapter. Such would be lengthy and not instructive."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f721c31-60f9-497c-9326-687c660d4bce",
   "metadata": {},
   "source": [
    "Linearize execution of Fibonacci by recording intermediate results in a memo table instead of recomputing them. This is an easy instance of [_Dynamic Programming_](https://en.wikipedia.org/wiki/Dynamic_programming)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92f61b47-e64c-4517-9eb9-457fd965d1bb",
   "metadata": {},
   "source": [
    "## Curried Memo Table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66097304-2a5e-422e-ab4e-9bfe688402d8",
   "metadata": {},
   "source": [
    "One way to pass a memo table is through a Curried second argument. We'll need $\\Upsilon2C$, generic for 2-parameter, Curried business code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "4982e8bc-cc80-48d4-9615-7a752c1de4be",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('Υ2C', \n",
    "       Λ(lambda π: # function of domain code, d ...\n",
    "         Λ(lambda π: π.g(π.g), ['g'], π)(\n",
    "             # with business code of 2 parameters, curried\n",
    "             Λ(lambda π: \n",
    "               π.d(Λ(lambda π: \n",
    "                     Λ(lambda π: π.sf(π.sf)(π.m)(π.n), \n",
    "                       ['n'], π), ['m'], π)),\n",
    "               ['sf'], π)), \n",
    "         ['d']));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ca165b1-330d-40c1-8db0-f1a0aac8cf07",
   "metadata": {},
   "source": [
    "Notice that we eased our burden of writing this $\\Upsilon$ by not bothering to distinguish the environment parameters $\\pi$ by name. Ordinary scoping rules disambiguate them, affording us a more fluid and concise style."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f31346b-83e1-4ff1-91a1-10c1a1ceae32",
   "metadata": {},
   "source": [
    "The domain code for a memoized, Curried Fibonacci follows. The parameter `a` is the _accumulator_, _associator_, or memo table, whatever word you like best. This is easiest to read (and to write) from the bottom up. It looks horrendous, but it isn't really. We disambiguated the names of the environment parameters as a guide. We won't do so in the future. In the `ECHO` output, count the 13 levels of chained environments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "1db24f2a-3644-47e0-8062-f3994ccf354a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'πa2': (0ca0) \"['a2']\">(0a60) \"['r2']\">(09d0) \"['m2']\">(03a0) \"['fim2']\">(0040) \"['n_2']\">(00d0) \"['a1']\">(fe20) \"['r1']\">(fd90) \"['m1']\">(fa30) \"['fim1']\">(f910) \"['n_1']\">(f520) \"['n']\">(f640) \"['a']\">(f490) \"['f']\">(cc10,ΓΠ) (\"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter', 'Υ1', \"\n",
      " \"'fact_recursive', 'Υ3', 'Ρ3', 'fib_slow', 'fib_iter', 'Υ2C', 'fib_fast']\")}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "46368"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('fib_fast',\n",
    "       Λ(lambda πf: # of f; level 1\n",
    "         Λ(lambda πa: # of a; level 2\n",
    "           Λ(lambda πn: # of n; level 3\n",
    "             (πn.a, 1) if πn.n < 2 else\n",
    "             Λ(lambda πn1: # of n_1; level 4\n",
    "               (πn1.a, πn1.a[πn1.n_1]) # optimizer should remove these two lines\n",
    "               if πn1.n_1 in πn1.a else # ^^^\n",
    "               Λ(lambda πfim1: # of fim1; level 5\n",
    "                 Λ(lambda πm1: # of m1; level 6\n",
    "                   Λ(lambda πr1: # of r1; level 7\n",
    "                     Λ(lambda πa1: # of a1; level 8\n",
    "                       Λ(lambda πn2: # of n_2; level 9\n",
    "                         (πn2.a1, πn2.r1 + πn2.a1[πn2.n_2]) # <~~~ a quick exit\n",
    "                         if πn2.n_2 in πn2.a1 else \n",
    "                         Λ(lambda πfim2: # of fim2; level 10\n",
    "                           Λ(lambda πm2: # of m2; level 11\n",
    "                             Λ(lambda πr2: # of r2; level 12\n",
    "                               Λ(lambda πa2: # of a2; level 13\n",
    "                                 (ECHO('πa2', πa2).a2, πa2.r1 + πa2.r2), # <~~~ the money line\n",
    "                                 ['a2'], πr2)(πr2.m2[0] | {πr2.n_2: πr2.r2}),  # <~~~ update memo\n",
    "                               ['r2'], πm2)(πm2.m2[1]), # unpack\n",
    "                             ['m2'], πfim2)(πfim2.fim2(πfim2.n_2)), # unpack\n",
    "                           ['fim2'], πn2)(πn2.f(πn2.a1)), # <~~~ recurse\n",
    "                         ['n_2'], πa1)(πa1.n - 2), # DRY\n",
    "                       ['a1'], πr1)(πr1.m1[0] | {πr1.n_1: πr1.r1}), # <~~~ update memo\n",
    "                     ['r1'], πm1)(πm1.m1[1]), # unpack\n",
    "                   ['m1'], πfim1)(πfim1.fim1(πfim1.n_1)), # unpack\n",
    "                 ['fim1'], πn1)(πn1.f(πn1.a)), # <~~~ recurse\n",
    "               ['n_1'], πn)(πn.n - 1), # DRY\n",
    "             ['n'], πa), # business parameter\n",
    "           ['a'], πf), # curried memo\n",
    "         ['f'])) # domain code \n",
    "ΓΠ.Υ2C(ΓΠ.fib_fast)({})(23)[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47d41260-b255-4a3b-aa9e-ccf5caa820ea",
   "metadata": {},
   "source": [
    "It's about 1 millisecond per iteration, 1,000 times faster than the original. The following takes 10 seconds. Uncomment if you want proof."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "73e6fad5-4202-4b6b-9d26-4d9d5bf91422",
   "metadata": {},
   "outputs": [],
   "source": [
    "# timeit(ΓΠ.Υ2C(ΓΠ.fib_fast)({})(23)[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef1731e0-d277-4e02-bfa8-ed2c67bf2598",
   "metadata": {},
   "source": [
    "Still blows the recursion limit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "01ddb2e3-7b21-4946-a0a3-12f89725e619",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('maximum recursion depth exceeded while calling a Python object',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.Υ2C(ΓΠ.fib_fast)({})(200)[1])\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "124d07a8-d8ab-4804-943e-71bb44c1ea0f",
   "metadata": {},
   "source": [
    "We fix that immediately below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62017ed-455d-4813-9f94-769d26ff68b8",
   "metadata": {},
   "source": [
    "## Memo Table as Business Parameter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92aa3076-eb91-4402-a916-7f53e5f1ced2",
   "metadata": {},
   "source": [
    "Before doing tail-recursion with a memo table, show the memo as un-Curried. Currying is useful in general, but complicates $\\Upsilon$. Get rid of it. Notice, also, that we no longer bother to disambiguate the environment parameters, letting Nature take care of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "640a45c0-c543-452a-b5e8-637ddfd94ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('fib_fast_uncurried',\n",
    "      Λ(lambda π: # of f; level 1\n",
    "        Λ(lambda π: # of a, n; level 2\n",
    "          (π.a, 1) if π.n < 2 else\n",
    "          Λ(lambda π: # of n_1; level 3\n",
    "            Λ(lambda π: # of t1; level 4\n",
    "              Λ(lambda π: # of m1; level 5\n",
    "                Λ(lambda π: # of r1; level 6\n",
    "                  Λ(lambda π: # of a1; level 7\n",
    "                    Λ(lambda π: # of n_2; level 8\n",
    "                      (π.a1, π.r1 + π.a1[π.n_2]) # <~~~ quick exit\n",
    "                      if π.n_2 in π.a1 else \n",
    "                      Λ(lambda π: # of t_2; level 9\n",
    "                        Λ(lambda π: # of m_2; level 10\n",
    "                          Λ(lambda π: # of r_2; level 11\n",
    "                            Λ(lambda π: # of a_2; level 12\n",
    "                              (π.a2, π.r1 + π.r2), # <~~~ the money line\n",
    "                              ['a2'], π)(π.m2 | {π.n_2: π.r2}), # <~~~ update memo\n",
    "                            ['r2'], π)(π.t2[1]), # nupaci\n",
    "                          ['m2'], π)(π.t2[0]), # unpack\n",
    "                        ['t2'], π)(π.f(π.a1, π.n_2)), # <~~~ recurse\n",
    "                      ['n_2'], π)(π.n - 2), # dry\n",
    "                    ['a1'], π)(π.m1 | {π.n_1: π.r1}), # <~~~ update memo\n",
    "                  ['r1'], π)(π.t1[1]), # unpac\n",
    "                ['m1'], π)(π.t1[0]), # unpack\n",
    "              ['t1'], π)(π.f(π.a, π.n_1)), # <~~~ recurse\n",
    "            ['n_1'], π)(π.n - 1), # DRY\n",
    "          ['a', 'n'], π), # busines parameters\n",
    "        ['f'])); # domain-code signature"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daed92f6-647e-4852-a04d-cf6059089903",
   "metadata": {},
   "source": [
    "Now need only an ordinary $\\Upsilon2$ to call it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "8ee3fb3a-70d0-48b6-ba17-f9276fe977f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('Υ2', \n",
    "       Λ(lambda π: # of d, the domain code ...\n",
    "         Λ(lambda π: π.g(π.g), ['g'], π)(\n",
    "             # of business code of two parameters\n",
    "             Λ(lambda π: \n",
    "               π.d(Λ(lambda π: π.sf(π.sf)(π.m, π.c), \n",
    "                     ['m', 'c'], π)), \n",
    "               ['sf'], π)), \n",
    "         ['d']));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a75570c2-aefc-4994-a9c9-8f212abe3df0",
   "metadata": {},
   "source": [
    "The recursion limit is a little higher, but we don't want any of that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "37005807-3bee-4119-a98b-e75c2b328429",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "453973694165307953197296969697410619233826\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.Υ2(ΓΠ.fib_fast_uncurried)({}, 200)[1])\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "94a76533-3bf2-44a5-9ef7-2a556878997a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('maximum recursion depth exceeded in __instancecheck__',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.Υ2(ΓΠ.fib_fast_uncurried)({}, 250)[1])\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ababf2db-2ee2-4cd2-884a-87ea16bc1023",
   "metadata": {},
   "source": [
    "This code is not tail-recursive, because it sums the results of two tail-recursive calls. An attempt to call it through a specialization of `LOOP` produces incorrect results, as warned above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "b21816c8-54ad-4405-9108-c87c707e885c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LOOP2(d: Procedure) -> Procedure:  # domain code\n",
    "    \"\"\"in sincere flattery of Clojure, and thanks to Thomas Baruchel.\"\"\"\n",
    "    nyms = ['a', 'β']\n",
    "    # in the global environment, ΓΠ,\n",
    "    DEFINE('Ρ2',\n",
    "           Λ(lambda π:\n",
    "             RECUR(*[π[nym] for nym in nyms]),\n",
    "             nyms))\n",
    "\n",
    "    def looper(*args):\n",
    "        \"\"\"Expression form of a while-loop statement.\"\"\"\n",
    "        while True:\n",
    "            try:\n",
    "                return d(ΓΠ.Ρ2)(*args)\n",
    "            except TailCall as e:\n",
    "                args = e.args\n",
    "\n",
    "    ρ = Λ(lambda π:\n",
    "          looper(*[π[nym] for nym in nyms]),\n",
    "          nyms,\n",
    "          π=d.π)\n",
    "\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "3a6f37a8-830b-4da9-99a7-289fbbbf0f65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "({}, 1)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(LOOP2(ΓΠ.fib_fast_uncurried)({}, 250))\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4c688de-5aec-4525-bb93-fcb70d99d508",
   "metadata": {},
   "source": [
    "## Recursive With Memo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3bc8b75-88e3-4fac-b4be-351d8a3b80ce",
   "metadata": {},
   "source": [
    "Section [Tail-Recursive Fibonacci](#tail-recursive-fibonacci) exhibits a very short solution without a memo table. Could we write a tail-recursive version with a memo table? Is it worth the effort? Perhaps as a mental exercise. It grows into a function of 5 parameters:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f81a08a1-e77e-4d85-9567-de25543afcdf",
   "metadata": {},
   "source": [
    "Pseudocode:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "864b27fe-4b2c-4683-a417-ca6a31d1eb1e",
   "metadata": {},
   "source": [
    "```\n",
    "f(r1, r2, a, n, x):\n",
    "    (a, 1) if n < 1 else\n",
    "    f(r2, r1 + r2, a | {x - (n-1): r1, x - (n-2): r2}, x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83f000c1-3393-4b4f-ae30-890ff8761ab5",
   "metadata": {},
   "source": [
    "### Non-Tail-Recursive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "94bf2bed-d912-48bd-9120-9cf2918930bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('Υ5', \n",
    "       Λ(lambda π: # of d, the domain code ...\n",
    "         Λ(lambda π: π.g(π.g), ['g'], π)(\n",
    "             # of business code of five parameters\n",
    "             Λ(lambda π: π.d(\n",
    "                 Λ(lambda π: π.sf(π.sf)(π.m, π.c, π.x, π.a, π.b), \n",
    "                   ['m', 'c', 'x', 'a', 'b'], π)), \n",
    "               ['sf'], π)), \n",
    "         ['d']));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "a8c3af0c-5449-4e84-97ee-5c5601d2377f",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('fib_tc_memo',\n",
    "      Λ(lambda π: \n",
    "        Λ(lambda π:\n",
    "          (π.a | {π.x: π.r2}, π.r2) if π.n < 1 else \\\n",
    "          π.f(π.r2, π.r1 + π.r2, \n",
    "              π.a | {π.x-π.n: π.r2},\n",
    "              π.n - 1,\n",
    "              π.x),\n",
    "         ['r1', 'r2', 'a', 'n', 'x'], π), \n",
    "        ['f']));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "9788fe5f-b8a4-4113-b976-873d3ddb6ef8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({0: 1,\n",
       "  1: 1,\n",
       "  2: 2,\n",
       "  3: 3,\n",
       "  4: 5,\n",
       "  5: 8,\n",
       "  6: 13,\n",
       "  7: 21,\n",
       "  8: 34,\n",
       "  9: 55,\n",
       "  10: 89,\n",
       "  11: 144,\n",
       "  12: 233,\n",
       "  13: 377,\n",
       "  14: 610,\n",
       "  15: 987,\n",
       "  16: 1597,\n",
       "  17: 2584,\n",
       "  18: 4181,\n",
       "  19: 6765,\n",
       "  20: 10946,\n",
       "  21: 17711,\n",
       "  22: 28657,\n",
       "  23: 46368},\n",
       " 46368)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ΓΠ.Υ5(ΓΠ.fib_tc_memo)(0, 1, {}, 23, 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1758ef2-ff1f-4c4c-a6c0-02c5f551df3f",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Tail-Recusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "6b03a478-9fbf-4b6f-a9b5-8a2a1d3e2c43",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LOOP5(d: Procedure) -> Procedure:\n",
    "    \"\"\"in sincere flattery of Clojure, and thanks to Thomas Baruchel.\"\"\"\n",
    "    DEFINE('Ρ5', Λ(lambda π: \n",
    "                   RECUR(π.m, π.c, π.x, π.a, π.b), \n",
    "                   ['m', 'c', 'x', 'a', 'b']));\n",
    "    def looper(*args):\n",
    "        \"\"\"Expression form of a while-loop statement.\"\"\"\n",
    "        while True:\n",
    "            try: \n",
    "                return d(ΓΠ.Ρ5)(*args)\n",
    "            except TailCall as e:\n",
    "                args = e.args\n",
    "    ρ = Λ(lambda π: \n",
    "               looper(π.m, π.c, π.x, π.a, π.b), \n",
    "               ['m', 'c', 'x', 'a', 'b'], π=d.π)\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "32c44d8e-70e2-4590-8465-88fcc50eddda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({0: 1,\n",
       "  1: 1,\n",
       "  2: 2,\n",
       "  3: 3,\n",
       "  4: 5,\n",
       "  5: 8,\n",
       "  6: 13,\n",
       "  7: 21,\n",
       "  8: 34,\n",
       "  9: 55,\n",
       "  10: 89,\n",
       "  11: 144,\n",
       "  12: 233,\n",
       "  13: 377,\n",
       "  14: 610,\n",
       "  15: 987,\n",
       "  16: 1597,\n",
       "  17: 2584,\n",
       "  18: 4181,\n",
       "  19: 6765,\n",
       "  20: 10946,\n",
       "  21: 17711,\n",
       "  22: 28657,\n",
       "  23: 46368},\n",
       " 46368)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LOOP5(ΓΠ.fib_tc_memo)(0, 1, {}, 23, 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0b3be7e-25d4-4bdd-9df5-1da2689b1ce8",
   "metadata": {},
   "source": [
    "### Test the Limits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "cc6bf21b-7ffd-4254-b9d1-832cfe29a61d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('maximum recursion depth exceeded',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.Υ5(ΓΠ.fib_tc_memo)(0, 1, {}, 500, 500)[1])\n",
    "except RecursionError as e:\n",
    "    print(e.args)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "f45aac52-2387-4c89-9927-ca593cdc4fb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225591516161936330872512695036072072046011324913758190588638866418474627738686883405015987052796968498626\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(LOOP5(ΓΠ.fib_tc_memo)(0, 1, {}, 500, 500)[1])\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "607b8ad3-e2f3-4f23-8d4a-9350356700c7",
   "metadata": {},
   "source": [
    "# `LOOP` and $\\Upsilon$ of $N$ Business Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58748f5a-f187-4e13-a585-fb20e3ba3468",
   "metadata": {},
   "source": [
    "We finish off [PART 1: BASICS](#basics) with straightforward generalizations of `LOOP` and $\\Upsilon$ to any number of business parameters, without undue explanation. We test them extensively below in [the section on `DO`](#do)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "aa1ff18d-0aec-4fd7-9131-d89dcb883d20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def LOOPN(\n",
    "        d: Procedure, \n",
    "        vars_: List[str]  # <~~~ NOTA BENE, extra parameters to LOOPN\n",
    ") -> Procedure:\n",
    "    \"\"\"in sincere flattery of Clojure, and thanks to Thomas Baruchel.\"\"\"\n",
    "    DEFINE('ΡN',\n",
    "           Λ(lambda π:\n",
    "             RECUR(*[π[var] for var in vars_]),\n",
    "             vars_))\n",
    "\n",
    "    def looper(*args):\n",
    "        \"\"\"Expression form of a while-loop statement.\"\"\"\n",
    "        while True:\n",
    "            try:\n",
    "                return d(ΓΠ.ΡN)(*args)\n",
    "            except TailCall as e:\n",
    "                args = e.args\n",
    "\n",
    "    ρ = Λ(lambda π:\n",
    "          looper(*[π[var] for var in vars_]),\n",
    "          vars_,\n",
    "          π=d.π)\n",
    "\n",
    "    return ρ\n",
    "\n",
    "LOOPN(ΓΠ.fact_iter, ['m', 'c', 'x'])(1, 1, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32ddfa1b-bf9f-43f7-abaa-b24eb0ee6f8e",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9b422563-f744-46d0-af1e-f01cf89c0d50",
   "metadata": {},
   "source": [
    "(define (LOOPN d)\n",
    "  (define (PN . L)\n",
    "    (call/cc (lambda (k)\n",
    "               (k (apply (d PN) L)))))\n",
    "  PN)\n",
    "\n",
    "((LOOPN fact-iter) 1 1 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "a962090f-b5b7-4b4c-9d07-58592aa55c0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('ΥN',\n",
    "       Λ(lambda πd:  # of d, the domain code and vars ...\n",
    "         Λ(lambda πg: πg.g(πg.g), ['g'], πd)(\n",
    "             # of business code of N parameters\n",
    "             Λ(lambda πsf:\n",
    "               πd.d(Λ(lambda πvs:\n",
    "                      πvs.sf(πvs.sf)(\n",
    "                          *[πvs[var] for var in πvs.vars_]),\n",
    "                      πsf.vars_,  # <~~~ list of parameters\n",
    "                      πsf)),\n",
    "               ['sf'], πd)),\n",
    "         ['d', 'vars_']));  # <~~~ extra parameters\n",
    "\n",
    "ΓΠ.ΥN(ΓΠ.fact_iter, ['m', 'c', 'x'])(1, 1, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36246581-1824-4ac3-97f4-7b00980d47df",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9b15e22c-bc56-432d-8046-98dc45c3a3b7",
   "metadata": {},
   "source": [
    "(define (YN d)\n",
    "  ((lambda (g) (g g))\n",
    "   (lambda (sf) (d (lambda L\n",
    "                     (apply (sf sf) L))))))\n",
    "\n",
    "((YN fact-iter) 1 1 6)\n",
    "720"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17d8b2f1-148c-4f94-869c-23c496232949",
   "metadata": {},
   "source": [
    "# PART II: IMPERATIVES<a id=\"imperatives\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc670d2c-232f-410e-a131-838ff89f373a",
   "metadata": {},
   "source": [
    "Everything above is Schemulator set-up. We finally get to the Pynultimate Imperatives."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae349e3a-073b-4234-be24-b41695ad1836",
   "metadata": {},
   "source": [
    "# SET_BANG<a id=\"set-bang\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "401070fe-932b-403a-90f1-0efdcd7736bb",
   "metadata": {},
   "source": [
    "This is assignment without lambda. We do better later, but SICP and _Lambda the Ultimate Imperative_ use it. Implement it just to complete coverage of Chapter 3 of SICP."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "866241f6-4dd9-47b5-a2a5-9d43b53129c8",
   "metadata": {},
   "source": [
    "This has its own recursive lookup, exactly the same as that in [`Procedure`](#procedure), just for a different purpose."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "139882ff-e0f9-47dd-8da5-9cb461c4b872",
   "metadata": {},
   "source": [
    "Tested below in [BLOCK](#block). Like Gambit, we can only `set!` symbols that are already `define`d. Also, like Gambit, we return `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "1e4a8c72-e0de-4db1-962d-615e12b7e99e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def SET_BANG(\n",
    "        sym: str, \n",
    "        val: Any, \n",
    "        π: Environment = ΓΠ\n",
    ") -> None:\n",
    "    ee = EVAL(val, π)\n",
    "    \"\"\"recursive lookup\"\"\"\n",
    "    while π is not None:\n",
    "        # Find the right π; ...\n",
    "        try:\n",
    "            getattr(π.ϕ, sym)  # ... don't recurse via π[sym]\n",
    "            break\n",
    "        except AttributeError as _:\n",
    "            if π.π is None:\n",
    "                raise NameError(f'Set!: Name {sym} is unbound.')\n",
    "            else:  # recurse\n",
    "                π = π.π\n",
    "    setattr(π.ϕ, sym, ee)\n",
    "    return None  # following Gambit Scheme"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60ccc1b6-5edb-440c-9768-666a1c5db14e",
   "metadata": {},
   "source": [
    "# BLOCK / BEGIN<a id=\"block\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e53c5f8e-bc61-42c2-8a0e-90c47f0b7ab2",
   "metadata": {},
   "source": [
    "In the following implementation, every $\\lambda$ must be a [_thunk_](#thunk): a procedure of no arguments (our $\\lambda$s always have the conventional parameter $\\pi$; our thunks do not use any parameters bound in $\\pi$). All but the last thunk are for side-effect; all thunks are evaluated; all but the last value are discarded."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce5016cd-c21e-4c9b-80dd-31a925420292",
   "metadata": {},
   "source": [
    "Steele's paper calls this form `BLOCK`. Scheme calls it `BEGIN`. Common Lisp calls it `PROGN`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "bc162fa1-85db-4214-84a2-86be90d05724",
   "metadata": {},
   "outputs": [],
   "source": [
    "def BLOCK(\n",
    "        *thunks: \"Procedure | Procedure\",  # <~~~ PEP 438 type notation\n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    ρ = None\n",
    "    for thunk in thunks:\n",
    "        ρ = APPLY(thunk, [], π=π)  # <~~~ thunks take no args\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d80a960-d95d-4264-8211-a356d0cdd079",
   "metadata": {},
   "source": [
    "## Examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32665241-df19-482b-84a3-22eb71c8de38",
   "metadata": {},
   "source": [
    "### Set-and-Test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4df6c26c-747b-4812-92f8-4cc30259308f",
   "metadata": {},
   "source": [
    "This block first sets `x` in $\\Gamma\\Pi$ to 6 and then accesses that variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "84a420fe-0e03-4924-a69e-c7e95b0cea5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('x', 0)  # <~~~ Binding must preexist in ΓΠ for SET_BANG\n",
    "BLOCK(\n",
    "    Λ(lambda π: SET_BANG('x', 6, π)), \n",
    "    Λ(lambda π: π.x * 7))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c705c1-30c2-4d7d-bda0-8aec13658bac",
   "metadata": {},
   "source": [
    "Python equivalent (using [Greek](#greek) to avoid collisions with user names). Python $\\lambda$s can't have sequences of \"statements.\" We packages sequences of statements in `def`s with made-up names:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b15ce874-d2c2-4dd1-9901-7497447dee1b",
   "metadata": {},
   "source": [
    "As a general habit, the return value of any Python equivalent is called $\\rho$. We imclude it specifically so that t a compiler can notice the beginning and the end of a construction. It's also a convenient place to hang a debugger breakpoint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "4d6321f2-3394-4a7d-b310-3bdd590e58e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0\n",
    "def γ000():\n",
    "    global x\n",
    "    x = 6  # <~~~ Λ thunks in BLOCK are automatically called\n",
    "    ρ = x * 7\n",
    "    return ρ\n",
    "γ000()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3edd273-a9a6-4a70-8a6a-c7b8f1e93724",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "938c7d42-1fcc-4bd1-a01f-d8db7733166c",
   "metadata": {},
   "source": [
    "> (define x 0)\n",
    "> (begin (set! x 6)\n",
    "         (* x 7))\n",
    "42"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3d89c6b-fda7-4f81-ada2-151a03ab8370",
   "metadata": {},
   "source": [
    "### Set and Set Again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "07226e23-d9f7-4597-8660-b7e9a63dd6e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('y', 42)  # <~~~ in ΓΠ\n",
    "BLOCK(\n",
    "    Λ(lambda π: SET_BANG('x', 6, π)), \n",
    "    Λ(lambda π: SET_BANG('x', π.x * 7, π)),\n",
    "    Λ(lambda π: π.x * π.y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f20b1139-bdc1-474c-8209-5056dcca16fb",
   "metadata": {},
   "source": [
    "Python equivalent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "1d0ac8c5-3580-4fef-9592-e33434b33e43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 42\n",
    "def γ001():\n",
    "    global x, y\n",
    "    x = 6\n",
    "    x = x * 7\n",
    "    ρ = x * y\n",
    "    return ρ\n",
    "γ001()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6baa1d36-2e86-4b51-bd12-8c87746107d2",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d4804b26-ebec-475a-ac93-e7a070ea6047",
   "metadata": {},
   "source": [
    "> (define x 0)\n",
    "> (define y 42)\n",
    "> (begin (set! x 6)\n",
    "         (set! x (* x 7))\n",
    "         (* x y))\n",
    "1764"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00824a16-8bfb-4dc4-bd1c-127f855ed9a2",
   "metadata": {},
   "source": [
    "Check for unbound variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "80769b48-f66c-401b-b329-6d5d7bc4d1a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'expect 1764': 1764}\n",
      "{'from Schemulator': ('Environment: Name z is unbound.',)}\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    BLOCK(\n",
    "        Λ(lambda π: SET_BANG('x', 6, π)), \n",
    "        Λ(lambda π: SET_BANG('x', π.x * 7, π)),\n",
    "        Λ(lambda π: print({'expect 1764': π.x * π.y})),\n",
    "        Λ(lambda π: π.z))  # <~~~ no binding\n",
    "except NameError as e:\n",
    "    print({'from Schemulator': e.args})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42737ddd-575e-4928-9715-7a50c47a76c9",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "3f3c2680-f9bc-45d8-a881-054a9e20b71d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'expect 1764': 1764}\n",
      "{'from Python': (\"name 'z' is not defined\",)}\n"
     ]
    }
   ],
   "source": [
    "def γ002():\n",
    "    global x, y, z\n",
    "    x = 6\n",
    "    x = x * 7\n",
    "    print({'expect 1764': x * y})\n",
    "    ρ = z\n",
    "    return ρ\n",
    "try:\n",
    "    γ002()\n",
    "except Exception as e:\n",
    "    print({'from Python': e.args})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2da2ede4-5b62-49de-be73-265f43df370b",
   "metadata": {},
   "source": [
    "Test BLOCK in a non-global environment $\\pi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "45bb3a77-f3c5-4432-ac59-3d40f162b24c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π0': (fe20) \"['x1', 'y1']\">(cc10,ΓΠ) (\"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter', 'Υ1', \"\n",
      " \"'fact_recursive', 'Υ3', 'Ρ3', 'fib_slow', 'fib_iter', 'Υ2C', 'fib_fast', \"\n",
      " \"'fib_fast_uncurried', 'Υ2', 'Ρ2', 'Υ5', 'fib_tc_memo', 'Ρ5', 'ΡN', 'ΥN', \"\n",
      " \"'x', 'y']\")}\n",
      "\n",
      "{'π': (fe20) \"['x1', 'y1']\">(cc10,ΓΠ) (\"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter', 'Υ1', \"\n",
      " \"'fact_recursive', 'Υ3', 'Ρ3', 'fib_slow', 'fib_iter', 'Υ2C', 'fib_fast', \"\n",
      " \"'fib_fast_uncurried', 'Υ2', 'Ρ2', 'Υ5', 'fib_tc_memo', 'Ρ5', 'ΡN', 'ΥN', \"\n",
      " \"'x', 'y']\")}\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "Λ(lambda π0:  # <~~~ Make a non-global π.\n",
    "  print(\n",
    "  BLOCK(\n",
    "      Λ(lambda π: SET_BANG('x1', 7, ECHO('π', π)), π=π0),\n",
    "      Λ(lambda π: SET_BANG('y1', 6, π), π=π0),\n",
    "      Λ(lambda π: π.x1 * π.y1, π=π0),\n",
    "      π=ECHO('π0', π0)\n",
    "  )),\n",
    "  ['x1', 'y1'])(0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce43fd6f-5dcb-4ecc-aeae-b650f9d5c37f",
   "metadata": {},
   "source": [
    "Python equivalent; the only way to combine local variables with squencing is via `def`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "18f0266c-2ead-4588-9f7d-1a2fc32079a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ003():\n",
    "    x1 = 0\n",
    "    y1 = 0\n",
    "    def γ004():\n",
    "        nonlocal x1, y1\n",
    "        x1 = 7\n",
    "        y1 = 6\n",
    "        ρ = x1 * y1\n",
    "        return ρ\n",
    "    ρ = γ004()\n",
    "    return ρ\n",
    "γ003()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3747c2db-b496-4f0c-bd12-87fa875fd131",
   "metadata": {},
   "source": [
    "BLOCK automatically propagates the environments, so the $\\pi_0$ arguments to the individual $\\lambda$s are overkill:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "1bc94a35-0500-434d-93d4-81a0bdbc4594",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π0': (4280) \"['x1', 'y1']\">(cc10,ΓΠ) (\"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter', 'Υ1', \"\n",
      " \"'fact_recursive', 'Υ3', 'Ρ3', 'fib_slow', 'fib_iter', 'Υ2C', 'fib_fast', \"\n",
      " \"'fib_fast_uncurried', 'Υ2', 'Ρ2', 'Υ5', 'fib_tc_memo', 'Ρ5', 'ΡN', 'ΥN', \"\n",
      " \"'x', 'y']\")}\n",
      "\n",
      "{'π': (4280) \"['x1', 'y1']\">(cc10,ΓΠ) (\"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter', 'Υ1', \"\n",
      " \"'fact_recursive', 'Υ3', 'Ρ3', 'fib_slow', 'fib_iter', 'Υ2C', 'fib_fast', \"\n",
      " \"'fib_fast_uncurried', 'Υ2', 'Ρ2', 'Υ5', 'fib_tc_memo', 'Ρ5', 'ΡN', 'ΥN', \"\n",
      " \"'x', 'y']\")}\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "Λ(lambda π0:  # <~~~ Make a non-global π.\n",
    "  print(\n",
    "  BLOCK(\n",
    "      Λ(lambda π: SET_BANG('x1', 7, ECHO('π', π))),  # <~~~ overkill\n",
    "      Λ(lambda π: SET_BANG('y1', 6, π)),  # <~~~ overkill\n",
    "      Λ(lambda π: π.x1 * π.y1),           # <~~~ overkill\n",
    "      π=ECHO('π0', π0)  # <~~~ necessary\n",
    "  )),\n",
    "  ['x1', 'y1'])(0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aec1e98-d1f8-47db-903c-589759f4df74",
   "metadata": {},
   "source": [
    "Names `x1` and `y1` are not bound in the global environment, even though they were in the non-global environment. The following example proves no \"binding leakage.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "5e8aba92-fb9b-4961-8217-34899913d4ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name x1 is unbound.',)\n",
      "('Environment: Name y1 is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    ΓΠ.x1\n",
    "except NameError as e:\n",
    "    print(e.args)\n",
    "    \n",
    "try:\n",
    "    ΓΠ.y1\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d8a6564-bc83-435a-a1b3-cdeeb1327a11",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "de7377a8-5943-4ec6-8ebe-f885823d9922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(\"name 'x1' is not defined\",), 'from Python'}\n",
      "{'from Python': (\"name 'y1' is not defined\",)}\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    global x1\n",
    "    _ = x1\n",
    "except Exception as e:\n",
    "    print({'from Python', e.args})\n",
    "\n",
    "try:\n",
    "    global y1\n",
    "    _ = y1\n",
    "except Exception as e:\n",
    "    print({'from Python': e.args})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7f9ebd6-1bf4-408d-8a48-0d3a717a6e4b",
   "metadata": {},
   "source": [
    "Check that intermediate lambdas that don't return `None` are NOT a problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "063d0286-1c31-4131-b135-fed037dde217",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BLOCK(\n",
    "    Λ(lambda π: SET_BANG('x', 6, π)), \n",
    "    Λ(lambda π: SET_BANG('x', π.x * 7, π)),\n",
    "    Λ(lambda π: π.x * π.y),\n",
    "    Λ(lambda π: π.x * π.y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb6df8c2-d720-4422-a437-f9b210f9909c",
   "metadata": {},
   "source": [
    "Check nested `BLOCK`s. Don't forget to wrap the nested `BLOCK` in a [thunk](#thunk)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "05656424-7c8d-4a6a-b9b7-19c5dcc81591",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (cc10,ΓΠ) (\"['γόὂ', 'square', 'saxpy', 'sum_of_squares', 'factorial', 'fact_iter', 'Υ1', \"\n",
      " \"'fact_recursive', 'Υ3', 'Ρ3', 'fib_slow', 'fib_iter', 'Υ2C', 'fib_fast', \"\n",
      " \"'fib_fast_uncurried', 'Υ2', 'Ρ2', 'Υ5', 'fib_tc_memo', 'Ρ5', 'ΡN', 'ΥN', \"\n",
      " \"'x', 'y']\")}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BLOCK(\n",
    "    Λ(lambda π: SET_BANG('x', 6, ECHO('π', π))), \n",
    "    Λ(lambda π:  # <~~~ Don't forget to wrap it!\n",
    "      BLOCK(Λ(lambda π: SET_BANG('x', π.x * 7, π)),\n",
    "            Λ(lambda π: π.x * π.y))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1057eace-d7c7-4330-8c39-e6b417efffb6",
   "metadata": {},
   "source": [
    "# Clear the Global Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3023e86a-0e13-42d6-a3e4-5c518a9edfff",
   "metadata": {},
   "source": [
    "Get rid of `x` and `y` and other gaseous bindings lest they cause trouble below. We shouldn't just make a new global environment because some system procedures, like [`DEFINE`](#define), are closed over the old one and we'd just have to specify `ΓΠ` everywhere explicitly rather than using the convenient defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "f22c95fc-7699-418d-8ebe-86dbae10e050",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\""
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del ΓΠ.ϕ.γόὂ\n",
    "del ΓΠ.ϕ.saxpy\n",
    "del ΓΠ.ϕ.sum_of_squares\n",
    "del ΓΠ.ϕ.factorial\n",
    "del ΓΠ.ϕ.fact_iter\n",
    "del ΓΠ.ϕ.fact_recursive\n",
    "del ΓΠ.ϕ.fib_slow\n",
    "del ΓΠ.ϕ.fib_iter\n",
    "del ΓΠ.ϕ.fib_fast\n",
    "del ΓΠ.ϕ.fib_fast_uncurried\n",
    "del ΓΠ.ϕ.fib_tc_memo\n",
    "del ΓΠ.ϕ.x\n",
    "del ΓΠ.ϕ.y\n",
    "ΓΠ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edca7a0b-ddac-404d-a98e-ae142731bd58",
   "metadata": {},
   "source": [
    "`PN` does not appear because we have not yet called `LOOPN`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c454245-b5a9-4797-872a-8a8c10537989",
   "metadata": {},
   "source": [
    "Define the Scheme-like synonym `BEGIN` for `BLOCK`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "49281976-102f-49f7-bc50-44ddf550dda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "BEGIN = BLOCK"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c6e7c85-c08b-4195-82ee-de5fe74a94e2",
   "metadata": {},
   "source": [
    "# LET*, LET, LETREC<a id=\"the-lets\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b02fe5b-edda-4c8a-a362-aa42207d8710",
   "metadata": {},
   "source": [
    "`LET_STAR` is sequential binding of locals, syntactically like assignment, but purely with $\\lambda$ expressions. Later bindings may depend on earlier ones. `LET` is parallel binding, where bindings are independent and unordered, but can't depend on one another. `LETREC` is mutually recursive `LET`, where any bindings may depend on any and all other bindings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e829e372-36c8-47fe-979d-f80f32741340",
   "metadata": {},
   "source": [
    "We face a design choice: should the binding pairs be a list of tuples, as in Scheme, or a flat list of pairs, as in Clojure? The former introduces a level of collections, the latter simplifies implementation via slicinng, but introduces more checks for types and for element counts. We choose the Scheme-like option because the Schemulator is supposed to be like Scheme on the surface unless there is a profound reason not to be."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e21fafb-9888-45d0-af14-c63790a01dd5",
   "metadata": {},
   "source": [
    "Remember that $\\Xi$ is a [Greek](#greek) shortcut for [`Application`](#application). Body of any of the _Lets_ must be an `Application` so that the environment $\\pi$ can be propagated at the point where it is known."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7674450-e98f-4fd9-bb79-a1462e681399",
   "metadata": {},
   "source": [
    "> __WARNING__: ***Results of `LET*`, `LET`, and `LETREC` are undefined if the body is not an [`Application`](#application) or $\\Xi$.***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fc1dbb1-fc95-42b3-8ae3-b2e95b687a9c",
   "metadata": {},
   "source": [
    "## LET_STAR<a id=\"let-star\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3f83dd4e-056e-4fd9-b71d-31d3aa2be956",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LET_STAR(\n",
    "        binding_pairs: List[Tuple[str, Expression]],\n",
    "        body: Expression, \n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    if len(binding_pairs) == 0:  # <~~~ Empty bindings are allowed.\n",
    "        ρ = EVAL(body, π)\n",
    "        return ρ\n",
    "    key, val = binding_pairs[0]\n",
    "    E1 = Environment(lambda: None, π)\n",
    "    setattr(E1.ϕ, key, EVAL(val, π))\n",
    "    if len(binding_pairs) == 1:\n",
    "        return EVAL(body, E1)\n",
    "    else:\n",
    "        return LET_STAR(binding_pairs[1:], body, E1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d24f55f-08aa-4c39-b328-9ad8d748e99a",
   "metadata": {},
   "source": [
    "### Examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71ab923a-0e08-4038-ae3d-66e455479614",
   "metadata": {},
   "source": [
    "Test depth 0, no bindings. The final expression -- the returned value -- can be a `Procedure`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "2217f772-2cdc-4066-a918-49bd79fd77ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'env': 'ΓΠ', 'parms': \"['x']\", 'Λ': '5480'}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([], \n",
    "         Λ(lambda π: 43 * π.x, ['x']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70128539-16ac-46a8-901d-99e710471f72",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "b7d280ea-4c1b-4d9b-b8ad-07ab559bbe49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x: 43 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d0bd2b6-cb07-434d-be0a-5ed59590f685",
   "metadata": {},
   "source": [
    "Which can be called:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "c13ff80b-c3e1-4856-ae03-312090574db6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([], \n",
    "         Λ(lambda π: 43 * π.x, ['x']))(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e89b5b0-cc54-45b6-88ee-8ef81aec5bc0",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "53666b85-4713-4e13-8c1c-a592f6a1a050",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x: 43 * x)(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef99c7a-6fff-4d06-b635-32fa6c41ee09",
   "metadata": {},
   "source": [
    "Applications are evaluated in place:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "501a9d8a-acf7-4689-839e-207969d5746b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([], \n",
    "         Ξ(Λ(lambda π: 43 * 42)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e90316c-53f8-4828-87fd-11537ec2c866",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "a69a59f7-b4f2-4192-8780-53cdabfd3787",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda: 43 * 42)()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14cc0e3c-affe-4c01-abd1-1152b84a38d3",
   "metadata": {},
   "source": [
    "The `LET_STAR` chains bindings in environments and evaluates applications in the chain. Procedures in applications enjoy free variables from any environments in the chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "7f0ec588-0b25-47ed-b38e-3de98f53a9e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (6710) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42)],\n",
    "        Ξ(Λ(lambda π: ECHO('π', π).z * π.z)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74c5c33d-cec0-4b81-8cdf-402a531e2b54",
   "metadata": {},
   "source": [
    "Python does not have `LET`. Local variables must be defined in `def`s with made-up names (we use [Greek](#greek) to avoid collision with user names. Equivalent to the above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "8a130bc5-7dab-4909-8c7e-5ee5e8a93851",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ004():\n",
    "    z = 42  # <~~~ Local variables must be args or defined in defs.\n",
    "    ρ = (lambda: z * z)()  # <~~~ Evaluating Ξ calls its Λ.\n",
    "    return ρ\n",
    "γ004()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffe4409c-65f0-4f18-911e-64485de131a5",
   "metadata": {},
   "source": [
    "Alternative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "e4e559af-e420-40b0-86cb-27467448023e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ005(z):  # <~~~ Local vars can be args.\n",
    "    ρ = (lambda: z * z)()  # <~~~ Ξ call\n",
    "    return ρ\n",
    "γ005(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e860f1d7-dac5-4c3b-8d5b-00f1ef2eb2f8",
   "metadata": {},
   "source": [
    "Later bindings can acces and can shadow earlier ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "2d2aa16c-5159-4060-b2cb-38052287f674",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (7250) \"['z']\">(71c0) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1849"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42),\n",
    "          ('z', Ξ(Λ(lambda π: π.z + 1)))],\n",
    "        Ξ(Λ(lambda π: ECHO('π', π).z * π.z)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "516130ad-df18-4594-98aa-b5ab7377aee9",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "7cfcd946-8967-4935-9089-a6e4944173e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1849"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ006():\n",
    "    z = 42\n",
    "    def γ007():  # <~~~ Cust have a def; can't sequence 'nonlocal' stmt in a λ\n",
    "        nonlocal z  # <~~~ necessary; refers to outer z.\n",
    "        z = (lambda: z + 1)()  # <~~~ Ξ call\n",
    "        return z\n",
    "    z = γ007()  # <~~~ Old z is shadowed.\n",
    "    ρ = (lambda: z * z)()  # <~~~ Ξ call\n",
    "    return ρ\n",
    "γ006()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62671836-4990-4107-b2cc-b14ac762671e",
   "metadata": {},
   "source": [
    "Returned `Procedure` is a closure over local variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "d8187599-ccef-47c9-bf5a-348760c1f77a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'env': (77f0) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\",\n",
       " 'parms': '[]',\n",
       " 'Λ': '76d0'}"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42)],\n",
    "        Λ(lambda π: π.z * π.z))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19fe4c44-3ea9-4624-aca4-29f757af3ecf",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "4bc7e1e1-2eb5-4754-a4b2-91a40412d186",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.γ008.<locals>.<lambda>()>"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ008():\n",
    "    z = 42\n",
    "    ρ = lambda: z * z\n",
    "    return ρ\n",
    "γ008()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be48c327-189a-4bbd-9d14-29429346bd4d",
   "metadata": {},
   "source": [
    "As always, the returned procedure may be called externally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "a45cf789-1948-47a6-ae1e-0743cf9012ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42)],\n",
    "        Λ(lambda π: π.z * π.z))()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bee14d9f-194b-4f6f-aaa9-1829ac4d865d",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "908721da-d9dd-4ee9-a51c-0c1cae42cd29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ009():\n",
    "    z = 42\n",
    "    ρ = lambda: z * z\n",
    "    return ρ\n",
    "γ009()()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb9ab036-edad-4e66-bed6-8704c3593825",
   "metadata": {},
   "source": [
    "Test depth 1 (don't forget the `Var` in $\\Xi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "0584e527-b08d-4734-a768-dd5a71f7e376",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42)], \n",
    "         Ξ(ΓΠ.square, [Var('z')]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0617faf6-0bad-44b5-a134-8cf7973adeb1",
   "metadata": {},
   "source": [
    "Python equivalent; `Var('z')` is like `eval('z')`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "53d53060-fc0b-4afc-86c6-ff08748e3ec6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square(x):\n",
    "    ρ = x * x\n",
    "    return ρ\n",
    "def γ010():\n",
    "    z = 42\n",
    "    ρ = square(eval('z')) \n",
    "    return ρ\n",
    "γ010()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a11739-a9ce-4cf7-9887-3b595ca158c0",
   "metadata": {},
   "source": [
    "### Free Variables<a id=\"free-variables\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c829e85-53fa-4d1f-8b37-5428603f4cfb",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___free variable___ in the body of a lambda is a variable _NOT_ in the parameter list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03968775-31bc-4131-a485-f155f7a48356",
   "metadata": {},
   "source": [
    "`z`, `y`, and `y` are free in the $\\lambda$s below:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2bd15cd-bdca-44e5-8b45-903a138cad05",
   "metadata": {},
   "source": [
    "Test depth 2 with free variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "a9303158-5ada-43cc-ad31-4d1e90fe7fb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42), \n",
    "          ('y', 43)], \n",
    "         Ξ(Λ(lambda π: π.z * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62327362-9a24-4224-96dc-2540098e10d6",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "9d15c3a2-5525-451e-b516-63426cfbcc4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ011():  # <~~~ Environment here will have all bindings.\n",
    "    z = 42\n",
    "    y = None  # <~~~ inserted in second pass after 'y' is discovered\n",
    "    def γ012():\n",
    "        nonlocal y, z\n",
    "        y = 43\n",
    "    γ012()\n",
    "    ρ = z * y\n",
    "    return ρ\n",
    "γ011()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69ec4e94-c26d-47c0-8eb2-af4f0cfa3ebb",
   "metadata": {},
   "source": [
    "Inspect bindings with an `ECHO` around the environment variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "56940d9a-77d4-4bf0-86c3-307138d08d78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (d630) \"['y']\">(d5a0) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42), \n",
    "          ('y', 43)], \n",
    "         Ξ(Λ(lambda π: ECHO('π', π).z * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceeb290c-6aea-4e51-99ba-e745e24afb84",
   "metadata": {},
   "source": [
    "Test depth 3 with free varialbes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "0076db3f-7fa2-4546-9371-e8ebfe035e26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (da20) \"['w']\">(d990) \"['y']\">(d900) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42), \n",
    "          ('y', Ξ(Λ(lambda π: π.z + 1))), \n",
    "          ('w', Ξ(Λ(lambda π: π.z * π.y)))],\n",
    "         body=Ξ(Λ(lambda π: ECHO('π', π).w)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb0df7e5-29fc-427f-8974-2f70a5008a81",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "5182add1-1e83-42b9-97bd-34326cd3f153",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ013():\n",
    "    z = 42\n",
    "    y = None\n",
    "    w = None\n",
    "    def γ014():\n",
    "        nonlocal y, z  # <~~~ Build up the nonlocals.\n",
    "        y = z + 1\n",
    "        def γ015():\n",
    "            nonlocal w, y, z  # <~~~ Build up the nonlocals.\n",
    "            w = z * y\n",
    "        γ015()\n",
    "    γ014()\n",
    "    ρ = w\n",
    "    return ρ\n",
    "γ013()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58405f1a-83a7-4cf7-9a8d-0089ea6a65e3",
   "metadata": {},
   "source": [
    "### Bound Variables<a id=\"bound-variables\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be1bb3b3-0680-4134-a144-2205b1b605d4",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___bound variable___ in the body of a $\\lambda$ is a variable that appears in the parameter list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55336a2b-db28-4018-8cb7-dbb37ddb29ad",
   "metadata": {},
   "source": [
    "Remember that [this definition of bound variables is confusing](#confusing)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "925ca3c5-e6b1-4b95-802e-65afa73cde7f",
   "metadata": {},
   "source": [
    "### Closed Term<a id=\"closed-term\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6d059f5-452b-4464-9441-ebe7cf1b3ffb",
   "metadata": {},
   "source": [
    "> __DEFINITION__: A ___closed procedure___ or ___closed term___ is a procedure with no free variables (see [this web page](https://web.mat.bham.ac.uk/R.W.Kaye/logic/freevar.html))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e53d8194-80fc-45f6-9f30-367e7c6024ed",
   "metadata": {},
   "source": [
    "Test depth 3 with bound variables. To access earlier bindings, write an [`Application` or $\\Xi$](#application) that, when evaluated, [accesses earlier bindings as `Var`s](#var). Notice the bound vars shadow free vars with the same names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "cac34a72-3ea7-48bf-8b20-3b55ae35a35d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (e200) \"['z', 'y']\">(e0e0) \"['y']\">(e050) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n",
      "\n",
      "{'π0': (e170) \"['w']\">(e0e0) \"['y']\">(e050) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42), \n",
    "          ('y', Ξ(Λ(lambda π: π.z + 1, ['z']),  # <~~~ z shadows ...\n",
    "                  [Var('z')])),  # <~~~ ... this Var.\n",
    "          # Shadowing occurs here, too.\n",
    "          ('w', Ξ(Λ(lambda π: ECHO('π', π).z * π.y, ['z', 'y']), \n",
    "                  [Var('z'), Var('y')])\n",
    "          )], \n",
    "         body=Ξ(Λ(lambda π0: ECHO('π0', π0).w)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "012c4bca-7a4f-4b6a-bdea-9ed086f38b27",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "96bed408-8d8e-4c3e-af36-b89a115b9520",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ016():\n",
    "    z = 42\n",
    "    y = None\n",
    "    w = None\n",
    "    def γ017():\n",
    "        nonlocal y, z\n",
    "        y = (lambda z: z+1)(eval('z'))\n",
    "        def γ018():\n",
    "            nonlocal w, y, z\n",
    "            w = (lambda z, y: z * y)(eval('z'), eval('y'))\n",
    "        γ018()\n",
    "    γ017()\n",
    "    ρ = w\n",
    "    return ρ\n",
    "γ016()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27e8f29-4b00-447c-a138-b589bdfad431",
   "metadata": {},
   "source": [
    "The names of the bound variables do not matter. In this case, we avoid shadowing, so the names `z`, `y`, and `w` are available in the body of `w`'s procedure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "7bcf9efa-85e0-4264-bdb7-9d2584e01b75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (ea70) \"['zzz', 'yy']\">(e950) \"['y']\">(e8c0) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42), \n",
    "          ('y', Ξ(Λ(lambda π: π.zz + 1, ['zz']),\n",
    "                  [Var('z')])), \n",
    "          # Use parameters:\n",
    "          ('w', Ξ(Λ(lambda π: ECHO('π', π).zzz * π.yy, ['zzz', 'yy']), \n",
    "                  [Var('z'), Var('y')])\n",
    "          )], \n",
    "         body=Ξ(Λ(lambda π: π.w)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "534fcf0a-379f-4216-ad3a-84132fe7d262",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "a2cffe59-16f4-40f6-9410-3c4761ecfddb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ019():\n",
    "    z = 42\n",
    "    y = None\n",
    "    w = None\n",
    "    def γ020():\n",
    "        nonlocal y, z\n",
    "        y = (lambda zz: zz+1)(eval('z'))\n",
    "        def γ021():\n",
    "            nonlocal w, y, z\n",
    "            w = (lambda zzz, yy: zzz * yy)(eval('z'), eval('y'))\n",
    "        γ021()\n",
    "    γ020()\n",
    "    ρ = w\n",
    "    return ρ\n",
    "γ019()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a00f222-07c5-4424-a74b-9c797af653f8",
   "metadata": {},
   "source": [
    "Ignore parameters; use free variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "469590cb-b3da-401c-85c5-be9c57f669d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (f250) \"['zzz', 'yy']\">(f130) \"['y']\">(f0a0) \"['z']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('z', 42), \n",
    "          ('y', Ξ(Λ(lambda π: π.zz + 1, ['zz']),\n",
    "                  [Var('z')])), \n",
    "          # Ignore parameters; use free variables:\n",
    "          ('w', Ξ(Λ(lambda π: ECHO('π', π).z * π.y, ['zzz', 'yy']), \n",
    "                  [Var('z'), Var('y')])\n",
    "          )], \n",
    "         body=Ξ(Λ(lambda π: π.w)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5651aaa4-5cc4-4654-8b31-35b0d9b630b8",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "924d0948-c32f-4258-8e30-9720c62327ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ019():\n",
    "    z = 42\n",
    "    y = None\n",
    "    w = None\n",
    "    def γ020():\n",
    "        nonlocal y, z\n",
    "        y = (lambda zz: zz+1)(eval('z'))\n",
    "        # Ignore parameters; use free variables:\n",
    "        def γ021():\n",
    "            nonlocal w, y, z\n",
    "            w = (lambda zzz, yy: z * y)(eval('z'), eval('y'))\n",
    "        γ021()\n",
    "    γ020()\n",
    "    ρ = w\n",
    "    return ρ\n",
    "γ019()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d12b0cb5-d8a8-4231-9661-cd486fe7358c",
   "metadata": {},
   "source": [
    "### Closures<a id=\"closures\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e4d3f51-1441-410c-9849-356c0323f446",
   "metadata": {},
   "source": [
    "The body of this next example evaluates `g` without returning a closure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "6cbf4e85-acb7-44b5-8b77-7a3584e77386",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (f520) \"['g']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('g', Λ(lambda π: π.x * π.x, ['x']))],\n",
    "        body=Ξ(Λ(lambda π: ECHO('π', π).g(42))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c790b1-c7ed-4ff3-bd01-e85bbbedbd4a",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "c2e112c2-8d96-4706-92ee-d664be058a18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ022():\n",
    "    g = lambda x: x * x\n",
    "    ρ = g\n",
    "    return ρ\n",
    "γ022()(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44c62024-3941-4351-99c0-f3146003bbe9",
   "metadata": {},
   "source": [
    "But, we may return a closure, meaning that its environment chain is still alive. We may invoke it outside the `LET_STAR`.The application $\\Xi$ pulls the closure out of the environment created by `LET_STAR`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "1c33f60d-9a26-434c-aee0-716fd46f9f5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (fac0) \"['g']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "α = LET_STAR([('g', Λ(lambda π: π.x * π.x, ['x']))],\n",
    "             body=Ξ(Λ(lambda π: ECHO('π', π).g)))\n",
    "α(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44d09041-3fe8-44d8-b428-277e89e97316",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "1787f05a-e4f4-429a-a5c9-8730cd48c6f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ023():\n",
    "    g = lambda x: x * x\n",
    "    ρ = g\n",
    "    return ρ\n",
    "β = γ023()\n",
    "β(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ff5a659-ab5c-40e3-859e-b7d0b4e9b74f",
   "metadata": {},
   "source": [
    "Without he application `Ξ`, the value is an unevaluated procedure returning a closure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "97386a04-7568-4368-8743-3c4726cc8975",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'env': (c310) \"['g']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\",\n",
       " 'parms': '[]',\n",
       " 'Λ': 'c280'}"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('g', Λ(lambda π: π.x * π.x, ['x']))],\n",
    "        body=Λ(lambda π: π.g))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b13b75f-2afe-4615-be1a-e53fad6e8adc",
   "metadata": {},
   "source": [
    "We can evaluate the returned closure with an extra, explicit call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "12d0818f-7eb8-42f5-add4-d0d06bf4945e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = LET_STAR([('g', Λ(lambda π: π.x * π.x, ['x']))],\n",
    "               body=Λ(lambda π: π.g))\n",
    "foo()(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6336c839-0862-410e-89ad-624e5fad884f",
   "metadata": {},
   "source": [
    "The Python equivalents were demonstrated above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781b4b75-b89d-461f-aff7-5e91375c61cd",
   "metadata": {},
   "source": [
    "Ensure no leakage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "4e64bfaa-5ed9-4f99-9dd3-cb4442d611cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name g is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    ΓΠ.g\n",
    "except Exception as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91ff96c7-a6ab-42ad-b765-7f1d4b7ec35a",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "b1ad6734-ab5d-49cd-84de-b3e87bc21d06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'from Python': (\"name 'g' is not defined\",)}\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    _ = g\n",
    "except Exception as e:\n",
    "    print({'from Python': e.args})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f316b79-04b7-4f33-8f8b-48571570a17b",
   "metadata": {},
   "source": [
    "Procedures can be bound variables, too, with arbitrary names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "8bc49527-62dc-4b73-b82c-1dbabc9b0549",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('g', Λ(lambda π: π.x * π.x, ['x']))],\n",
    "         body=Ξ(Λ(lambda π: π.gg(42), ['gg']), [Var('g')]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc301d45-d23c-4312-9277-fa013e13b73a",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "361ee49e-8ad0-47a0-9a99-d9ed80a94133",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ024():\n",
    "    g = lambda x: x * x\n",
    "    ρ = (lambda gg: gg(42))(eval('g'))\n",
    "    return ρ\n",
    "γ024()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60ccc5da-fdf8-4874-83bb-1b4151ed001e",
   "metadata": {},
   "source": [
    "Unevaluated, it's still a closure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "a35211b4-2c58-44c1-a5ee-bbe45049ca6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([('g', Λ(lambda π: π.x * π.x, ['x']))],\n",
    "         body=Ξ(Λ(lambda π: π.gg, ['gg']), [Var('g')]))(\n",
    "42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a7edaee-8e30-4c29-ba2b-3960d7e33fec",
   "metadata": {},
   "source": [
    "Python equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "99c9ce42-4cd3-4f70-81ae-be9fab0c0c37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def γ025():\n",
    "    g = lambda x: x * x\n",
    "    ρ = (lambda gg: gg)(eval('g'))\n",
    "    return ρ\n",
    "γ025()(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf937c0a-6a6f-4b18-8238-cbe416eeaa07",
   "metadata": {},
   "source": [
    "## LET<a id=\"let\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "529efe77-d4e1-4da6-8eaf-407a86103d93",
   "metadata": {},
   "source": [
    "`LET` is parallel \"assignment.\" All \"local variables\" must be bound in the enclosing environment and may not depend on one another. This implementation is not curried. `body` is usually an [`Application`](#application) that automatically receives the local variables in its environment. The $\\Lambda$ argument of the `Application` receives this environment as its $\\pi$ parameter, so it may access the local variables as free variables in its body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "495699f6-16d8-4476-be69-11caba02a937",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LET(\n",
    "        pairs: List[Tuple[str, Expression]],\n",
    "        body: Expression,\n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    if len(pairs) == 0:\n",
    "        ρ = EVAL(body, π)\n",
    "        return ρ\n",
    "    E1 = Environment(lambda: None, π)\n",
    "    for p in pairs:\n",
    "        if isinstance(p[1], Procedure):\n",
    "            p[1].π = E1\n",
    "    _ = [setattr(E1.ϕ, p[0], EVAL(p[1], π))\n",
    "         for p in pairs]\n",
    "    ρ = EVAL(body, E1)\n",
    "    return ρ "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c786a33-ec48-4dd7-bb80-a9aa75fb9159",
   "metadata": {},
   "source": [
    "### Examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a89ae848-02f6-4a88-b3fc-f9d2d361b96d",
   "metadata": {},
   "source": [
    "Test depth 0; embedded $\\Lambda$ is a thunk (no parameters):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "f405f4b4-b22f-4413-bebd-3b87b31715b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1806\n"
     ]
    }
   ],
   "source": [
    "LET([], \n",
    "    Ξ(Λ(lambda π: print(43 * 42))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1e2e8d-deec-462d-935f-532ffc5535bc",
   "metadata": {},
   "source": [
    "Test depth 1; embedded `Procedure` takes one argument, supplied as a `Var` in the environment of the `LET`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "4828f755-1d66-4d7e-8c10-78236acd722f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('z', 42)], \n",
    "    Ξ(ΓΠ.square, [Var('z')]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9381bbde-ea94-464a-8243-8a83ac438874",
   "metadata": {},
   "source": [
    "Test depth 2; embedded `Procedure` receives an environment with bindings for the local variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "5eb6e591-53d6-489f-afda-1c37287c8761",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (e9e0) \"['z', 'y']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN']\"}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('z', 42), \n",
    "     ('y', 43)], \n",
    "    Ξ(Λ(lambda π: ECHO('π', π).z * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8cb844f-f32d-4253-9d34-a087a6245f47",
   "metadata": {},
   "source": [
    "Depth 2 with external invocation / evaluation; body -- return value -- of the `LET` is an un-called `Procedure`. The `Procedure` is evaluated, but not called, to propagate the environment, before it is returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "27f56a40-bfcb-42e2-98ee-b9fea3882d91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('z', 42), \n",
    "     ('y', 43)], \n",
    "    Λ(lambda π: π.z * π.y))()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44ad86a1-7993-4a72-998e-94ee5d3e64ca",
   "metadata": {},
   "source": [
    "Reversed; order does not matter in `LET`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "27af5f88-8d56-42b4-8898-0cdf1442f3a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('y', 42), \n",
    "     ('z', 43)], \n",
    "    Ξ(Λ(lambda π: π.z * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c318d4-1990-4051-8fab-4880f271edad",
   "metadata": {},
   "source": [
    "With applications as values for local variables, the inner `y` is evaluated in the local environment, not leaking down from the global environment $\\Gamma\\Pi$, where `y` is 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "4e70bec9-ac6b-4f55-8019-fe1036008287",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "DEFINE('y', 0)\n",
    "LET([('y', 42), \n",
    "     ('z', Ξ(Λ(lambda π: π.y + 1)))],  # Outer y = 0, not inner y = 42\n",
    "    Ξ(Λ(lambda π: print(π.z * π.y))))  # Inner y = 42 * inner z = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca4d28db-9a90-45d0-aebb-a53dd6b198b6",
   "metadata": {},
   "source": [
    "Order does not matter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "92c8b341-0805-41fc-8c24-a1afe81b449d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "LET([('z', Ξ(Λ(lambda π: π.y + 1))),  # Outer y = 0, not inner y = 42\n",
    "     ('y', 42)], \n",
    "    Ξ(Λ(lambda π: print(π.z * π.y)))) # Inner y = 42 * inner z = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "206d3031-4ce0-4031-a349-4bd1174df468",
   "metadata": {},
   "source": [
    "Print the environment to check that all symbols are bound in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "6375b3bf-e4aa-43cb-8299-0ed5a5dc7626",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "{'π': (fac0) \"['z', 'y']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN', 'y']\"}\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "LET([('z', Ξ(Λ(lambda π: π.y + 1))),  # Outer y = 0, not inner y = 42\n",
    "     ('y', 42)], \n",
    "    Ξ(Λ(lambda π: print(ECHO('π', π).z * π.y)))) # Inner y = 42 * inner z = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a4ce675-d0ef-4261-ab06-06b8e2e81358",
   "metadata": {},
   "source": [
    "Prove global `y` is unchanged and that `z` is bound only in local environment, not global."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "39d3eeb0-7aa6-4d74-8409-27317742e107",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'expect y = 0': 0}\n",
      "('Environment: Name z is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "print({'expect y = 0':  ΓΠ.y})\n",
    "try:\n",
    "    print(ΓΠ.z)\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1918279-fdf6-4fbd-b868-4038f36de04f",
   "metadata": {},
   "source": [
    "Test nested `LET`. Don't forget to chain the environments! The default is $\\Gamma\\Pi$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "15492364-219f-4d82-88e7-59ad47b40ea3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('z0', 42)],\n",
    "    Ξ(Λ(lambda π0:\n",
    "        LET([('y0', Ξ(Λ(lambda π1: π1.z0 + 1)))],\n",
    "            Ξ(Λ(lambda π2: π2.z0 * π2.y0)),\n",
    "            π=π0))))  # <~~~ Don't forget to chain!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bee9c699-e136-4e7d-b362-91e409eba454",
   "metadata": {},
   "source": [
    "The free variable `x` in the $\\lambda$ below is looked up in the local environment established by `LET`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "773117ec-0cd1-4564-ae73-5c34f1674e2f",
   "metadata": {},
   "source": [
    "First, delete `x` again, just in case, so we can check that it does not get bound accidentally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "67786cf7-c446-4654-915a-fa3392707544",
   "metadata": {},
   "outputs": [],
   "source": [
    "try: \n",
    "    del ΓΠ.ϕ.x\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "17a59513-eb4d-4821-87de-f1bedfa1fe87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('x', 42)],\n",
    "   Ξ(Λ(lambda π: π.x * π.x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44e0c8b0-b0df-4405-9831-9d0329b1b2d1",
   "metadata": {},
   "source": [
    "The variable `x` did not leak out of the local environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "f15f7bb5-a621-4ccb-8631-acbaf15b3a5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name x is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    ΓΠ.x\n",
    "except Exception as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "997bf7a1-dbb1-436b-a8f7-17f42ec02534",
   "metadata": {},
   "source": [
    "We can get the same result as above when the internal $\\lambda$ does not have free variables. When evaluating the application $\\Xi$, grab the local value of `x` as an actual argument and substitute it for the bound variable `y` in the body of the $\\lambda$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "81c275b0-298d-4207-bcd4-4aacf8756af2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1764"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET([('x', 42)],\n",
    "   Ξ(Λ(lambda π: π.y * π.y, ['y']), [Var('x')]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df52383-578a-4974-9b3f-c64cdc93f5dd",
   "metadata": {},
   "source": [
    "### Test `EVAL` on Collections<a id=\"test-collections\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9825bb18-482c-4a3c-855e-697f7cd38cfc",
   "metadata": {},
   "source": [
    "[Notice that `EVAL` recurses into Dicts, Tuples, Lists, and numpy arrays](#eval). `LET_STAR` and `LET` gives us good tools for testing that."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00fffc10-1741-4c03-b8fa-090c99789c23",
   "metadata": {},
   "source": [
    "Lists, with free variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "7b46cd90-c6d2-4128-9180-8dc6a94b567a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 43, 42, 43, 42, 43]"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([\n",
    "    ('forty_two', 42),\n",
    "    ('x', Ξ(Λ(lambda π: [π.forty_two, π.forty_two + 1]))),\n",
    "    ('y', 3)],\n",
    "   Ξ(Λ(lambda π: π.x * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97f6378c-476d-46cd-a9f6-c11589df87b9",
   "metadata": {},
   "source": [
    "With bound variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "ff78124f-5d42-4d0f-a2bf-4e4536511063",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 43, 42, 43, 42, 43]"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([\n",
    "    ('forty_two', 42),\n",
    "    ('x', Ξ(Λ(lambda π: [π.forty_two, π.forty_two + 1]))),\n",
    "    ('y', 3)],\n",
    "   Ξ(Λ(lambda π: π.xx * π.yy, ['xx', 'yy']), [Var('x'), Var('y')]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e02b1d-03eb-46a3-b764-f69653b63513",
   "metadata": {},
   "source": [
    "Tuples, with free variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "59bb00b3-99d9-4fe5-ac82-09cbee6b9f6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(42, 43, 42, 43, 42, 43)"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([\n",
    "    ('forty_two', 42),\n",
    "    ('x', Ξ(Λ(lambda π: (π.forty_two, π.forty_two + 1)))),\n",
    "    ('y', 3)],\n",
    "   Ξ(Λ(lambda π: π.x * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d32416b-49e1-4d52-948e-91e7bdb5c5df",
   "metadata": {},
   "source": [
    "Dictionaries, with free variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "37f15bc4-c42a-4ee3-bdc5-6ec3c0fa9133",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[42, 43, 42, 43, 42, 43]"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([\n",
    "    ('forty_two', 42),\n",
    "    ('x', Ξ(Λ(lambda π: {'π.forty_two': π.forty_two, \n",
    "                         'forty-three': π.forty_two + 1}))),\n",
    "    ('y', 3)],\n",
    "   Ξ(Λ(lambda π: [π.x['π.forty_two'], \n",
    "                  π.x['forty-three']] * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c46ac52-05ae-4f1a-9d31-3ab983966e79",
   "metadata": {},
   "source": [
    "Numpy arrays, with free variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "decb0ed0-ee2c-48f5-b1f1-9691aea25fcb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([126, 129])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LET_STAR([\n",
    "    ('forty_two', 42),\n",
    "    ('x', Ξ(Λ(lambda π: numpy.array(\n",
    "        [π.forty_two,\n",
    "         π.forty_two + 1])))),\n",
    "    ('y', 3)],\n",
    "    Ξ(Λ(lambda π: π.x * π.y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43b4a5b9-89c1-4b89-9893-3bbfef511201",
   "metadata": {},
   "source": [
    "## LETREC<a id=\"letrec\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a76f626-05d7-4029-8fb3-f2d9bbbe11d1",
   "metadata": {},
   "source": [
    "`LETREC` binds codependent values in a new environment _before_ evaluating them. `LET` evaluates values before binding them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "304565df-04c6-4ef1-8439-5a374d99e486",
   "metadata": {},
   "source": [
    "`LETREC` patches the environments of any contained procedures to ensure they have access to new bindings. [Lengthy code in `EVAL` does the monkey-patching for us](#eval) later. `LETREC` differs from `LET` only in the absence of `EVAL`s on the value side. Those `EVAL`s are done later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "f2954dc5-5536-4ba3-95b0-6cfe7370e39f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LETREC(\n",
    "        pairs: List[Tuple[str, Any]],\n",
    "        body: Expression,\n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    if len(pairs) == 0:\n",
    "        ρ = EVAL(body, π)  \n",
    "        return ρ\n",
    "    E1 = Environment(lambda: None, π)\n",
    "    for p in pairs:\n",
    "        if isinstance(p[1], Procedure):\n",
    "            p[1].π = E1\n",
    "    _ = [setattr(E1.ϕ, p[0], p[1]) for p in pairs]  # <~~~ DON'T EVAL!\n",
    "    ρ = EVAL(body, E1)\n",
    "    return ρ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dfb2246-f587-4f69-98ec-9afe3c7c8dda",
   "metadata": {},
   "source": [
    "### Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a489529-d904-43e5-b8bb-b94e8c3b4340",
   "metadata": {},
   "source": [
    "Factorial, familiar by now, accesses itself through the patched environment; `fact` is a free variable in the body of `fact`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "aac4f65f-5100-4994-94d8-bba37901d2e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LETREC([('fact', \n",
    "         Λ(lambda π: \n",
    "           (π.a\n",
    "            if π.m <= 0 \n",
    "            else π.fact(π.m - 1, π.m * π.a)),\n",
    "           ['m', 'a']))],\n",
    "       Ξ(Λ(lambda π: π.fact(6, 1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad3f80fa-a1d5-4d06-8482-5f2f55c1df48",
   "metadata": {},
   "source": [
    "Here is a version that fails if the patching is not done correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "f8875259-c09f-49a3-8a51-cd80e1dac9f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo: \n",
    "  LETREC([('fact', \n",
    "           Λ(lambda π: \n",
    "             (π.a\n",
    "              if π.m <= π.m0  # <~~~ Watch out!\n",
    "              else π.fact(π.m - 1, π.m * π.a)),\n",
    "             ['m', 'a']))],\n",
    "         Ξ(Λ(lambda π: π.fact(6, 1))),\n",
    "         πo),  # <~~~ access 'm0'\n",
    " ['m0'])(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c5e83a0-93fe-4f75-9f24-9aea753acee8",
   "metadata": {},
   "source": [
    "Now fully parameterized:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "6ae5af3a-9aac-4fd1-910d-3019c9a2f544",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo: \n",
    "  LETREC([('fact', \n",
    "           Λ(lambda π: \n",
    "             (π.a\n",
    "              if π.m <= π.m0  # <~~~ Watch out!\n",
    "              else π.fact(π.m - 1, π.m * π.a)),\n",
    "             ['m', 'a']))],\n",
    "         Ξ(Λ(lambda π: π.fact(π.n, 1))),\n",
    "         πo),  # <~~~ access 'm0' and 'n'\n",
    " ['m0', 'n'])(0, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf591ce-b570-47e2-8b7e-51aba24de601",
   "metadata": {},
   "source": [
    "The final application $\\Xi$ is necessary to actually evaluate the final $\\Lambda$, lest it be simply returned unevaluated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "1e99af43-d37b-4d5a-a76a-e6d1fefe8de5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'env': (2dd0) \"['fact']\">(cc10,ΓΠ) \"['square', 'Υ1', 'Υ3', 'Ρ3', 'Υ2C', 'Υ2', 'Ρ2', 'Υ5', 'Ρ5', 'ΡN', 'ΥN', 'y']\",\n",
       " 'parms': '[]',\n",
       " 'Λ': '2d40'}"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LETREC([('fact', \n",
    "         Λ(lambda π: \n",
    "           (π.a\n",
    "            if π.m <= 0 \n",
    "            else π.fact(π.m - 1, π.m * π.a)),\n",
    "           ['m', 'a']))],\n",
    "       Λ(lambda π: π.fact(6, 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a53ed687-b2b3-42b8-8947-9a573d29afc5",
   "metadata": {},
   "source": [
    "But we can evaluate it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "3a40030f-15c7-42bc-b2cd-4249772c940b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LETREC([('fact', \n",
    "         Λ(lambda π: \n",
    "           (π.a\n",
    "            if π.m <= 0 \n",
    "            else π.fact(π.m - 1, π.m * π.a)),\n",
    "           ['m', 'a']))],\n",
    "       Λ(lambda π: π.fact(6, 1)))()  # <~~~ extra evaluation!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2061ac59-9441-43d3-8f3d-d196b0884f39",
   "metadata": {},
   "source": [
    "One can unroll the final application into formal parameters and actual arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "654accf6-a478-43d3-b069-13742f8292bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LETREC([('fact', \n",
    "         Λ(lambda π: \n",
    "           (π.a\n",
    "            if π.m <= 0 \n",
    "            else π.fact(π.m - 1, π.m * π.a)),\n",
    "           ['m', 'a']))],\n",
    "       Ξ(Λ(lambda π: π.fact(π.n, π.b), \n",
    "           ['n', 'b']),  # <~~~ formal parameters\n",
    "         [6, 1]))  # <~~~ actual arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e72b8809-d6fd-4353-b83f-50aebbbc59c8",
   "metadata": {},
   "source": [
    "Mutually codependent procedures are OK:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "5c2ec481-1941-411c-a435-282ab87786c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1806"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LETREC([('z0', Λ(lambda π: 1 + π.y0(), ['y0'])),\n",
    "        ('y0', Λ(lambda π: 42))],\n",
    "      Ξ(Λ(lambda π: π.y0() * π.z0(π.y0))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1d26990-363f-4c18-ab2c-5e41b3d5df6e",
   "metadata": {},
   "source": [
    "Check that `y0` does not leak into the global environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "769a33a1-484b-4ee1-a223-e3f369b0b2ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name y0 is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.y0)\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b961ac-bb58-41a3-af29-fb474813994f",
   "metadata": {},
   "source": [
    "The following shows that `z0` also does not leak from `LETREC`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "63760902-b138-49bb-8606-44dffdf24e17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Environment: Name z0 is unbound.',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(ΓΠ.z0)\n",
    "except NameError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e59d618a-2c97-460c-8a4e-6acbc79c3f3d",
   "metadata": {},
   "source": [
    "The following example is [borrowed from the Racket documentation](https://docs.racket-lang.org/reference/let.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "942af98b-8cda-481f-8858-9687463d6e28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, False, True)"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LETREC([('is_even',\n",
    "         Λ(lambda π: True if π.n == 0 else (not π.is_odd(π.n)), \n",
    "           ['n'])),\n",
    "        ('is_odd', \n",
    "         Λ(lambda π: π.n != 0 and π.is_even(abs(π.n) - 1),\n",
    "           ['n']))],\n",
    "      Ξ(Λ(lambda π: (\n",
    "          π.is_even( 42),\n",
    "          π.is_even(-43),\n",
    "          π.is_odd (-42),\n",
    "          π.is_odd ( 43),\n",
    "      ))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9f3829e-2e86-4bc0-98e8-fbcf63fc1735",
   "metadata": {},
   "source": [
    "### TODO: Tanai"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7491e732-4bc7-449a-b0ff-bfa81a69f23b",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Tak](https://en.wikipedia.org/wiki/Tak_(function))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35d5a990-3f6a-46fb-af9f-8190e9972062",
   "metadata": {},
   "source": [
    "Here is [`tak`](https://en.wikipedia.org/wiki/Tak_(function)) in ordinary Python, with a global counter of number of calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "aad7c10d-988b-4101-bb44-064ed3904e73",
   "metadata": {},
   "outputs": [],
   "source": [
    "ntakcalls = 0\n",
    "def tak(x, y, z):\n",
    "    global ntakcalls\n",
    "    ntakcalls += 1\n",
    "    r = (tak(tak(x - 1, y, z),\n",
    "             tak(y - 1, z, x),\n",
    "             tak(z - 1, x, y))\n",
    "         if y < x else\n",
    "         z)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "543c8327-bb0e-473b-9813-58a9b57e96df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "{'ntakcalls': 5}\n"
     ]
    }
   ],
   "source": [
    "ntakcalls = 0\n",
    "print(tak(3, 2, 1))\n",
    "\n",
    "print({\"ntakcalls\": ntakcalls})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "6ec38069-5fe0-4eb9-baad-9a6bc233a22e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "{'ntakcalls': 1733}\n"
     ]
    }
   ],
   "source": [
    "from contextlib import contextmanager\n",
    "\n",
    "@contextmanager\n",
    "def wtak():\n",
    "    global ntakcalls\n",
    "    ntakcalls = 0\n",
    "    yield\n",
    "    print({\"ntakcalls\": ntakcalls})\n",
    "\n",
    "with wtak():\n",
    "    print(tak(12, 8, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "74bc394f-0942-430e-915b-7cb171f613f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "{'ntakcalls': 63609}\n"
     ]
    }
   ],
   "source": [
    "with wtak():\n",
    "    print(tak(18, 12, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "d9b41ac7-5207-4b74-81f0-f5b041fa1f7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "{'ntakcalls': 2493349}\n"
     ]
    }
   ],
   "source": [
    "with wtak():\n",
    "    print(tak(28, 20, 12))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0df2a9d8-a0db-477e-a921-7ae67aa12e6a",
   "metadata": {},
   "source": [
    "#### Functional Instrumented Tak"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d46b0c79-2efd-465e-a518-af2e4e1896f5",
   "metadata": {},
   "source": [
    "Here is a functional flavoring of the instrumentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "23eec7e3-8cd5-4222-b050-76fa62f33a0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def itak(c, x, y, z):\n",
    "    \"\"\"c is the number of tak calls so far.\"\"\"\n",
    "    itakx = lambda c: itak(c, x - 1, y, z)\n",
    "    itaky = lambda c: itak(c, y - 1, z, x)\n",
    "    itakz = lambda c: itak(c, z - 1, x, y)\n",
    "    if y < x:\n",
    "        lx = itakx(c + 1)\n",
    "        ly = itaky(lx[0] + 1)\n",
    "        lz = itakz(ly[0] + 1)\n",
    "        lr = itak(lz[0] + 1, lx[1], ly[1], lz[1])\n",
    "        return lr\n",
    "    else:\n",
    "         return (c, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "5b33f254-8399-440e-9231-1b1b2478939d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 2)"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itak(1, 3, 2, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "d8f17364-6992-43b4-8341-11aa274aef30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1733, 5)"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itak(1, 12, 8, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "f70a85d6-7d00-46d5-b73c-9e583a7dc9b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(63609, 7)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itak(1, 18, 12, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "0258eac8-394b-495c-a02e-3beee394bc2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2493349, 13)"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itak(1, 28, 20, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eacf1d48-8727-4141-99e1-e25b54572db9",
   "metadata": {},
   "source": [
    "#### Instrumented Recursive Tak"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f4299a7-8155-44a9-a408-8248599ac96f",
   "metadata": {},
   "source": [
    "Scheme equivalent:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f2b90425-0500-43ef-83d9-28f845e304ea",
   "metadata": {},
   "source": [
    "(define (itak c x y z)\n",
    "  (let ((itakx (lambda (c) (itak c (- x 1) y z)))\n",
    "        (itaky (lambda (c) (itak c (- y 1) z x)))\n",
    "        (itakz (lambda (c) (itak c (- z 1) x y))))\n",
    "    (if (< y x)\n",
    "     (let* ((lx (itakx (+ c 1)))\n",
    "            (ly (itaky (+ (car lx) 1)))\n",
    "            (lz (itakz (+ (car ly) 1))))\n",
    "       (itak (+ (car lz) 1) (cadr lx) (cadr ly) (cadr lz)))\n",
    "     (list c z))))\n",
    "\n",
    "(pp (itak 1  3  2  1))  ; (5 2)\n",
    "(pp (itak 1 12  8  4))  ; (1733 5)\n",
    "(pp (itak 1 18 12  6))  ; (63609 7)\n",
    ";; (pp (itak 1 28 20 12))  ; (2493349 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d51b915f-58e0-4b67-8ac9-f983baea5e28",
   "metadata": {},
   "source": [
    "Schemulator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "54e07999-c281-4b17-aeed-b5986d0471dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFINE('irtak',\n",
    "       Λ(lambda πo:\n",
    "         LET([('itakx', Λ(lambda π: ΓΠ.irtak(π.c, π.x - 1, π.y, π.z), ['c'])),\n",
    "              ('itaky', Λ(lambda π: ΓΠ.irtak(π.c, π.y - 1, π.z, π.x), ['c'])),\n",
    "              ('itakz', Λ(lambda π: ΓΠ.irtak(π.c, π.z - 1, π.x, π.y), ['c']))],\n",
    "             Ξ(Λ(lambda πi:\n",
    "                 LET_STAR(\n",
    "                     [('lx', Ξ(Λ(lambda π: π.itakx(π.c + 1)))),\n",
    "                      ('ly', Ξ(Λ(lambda π: π.itaky(π.lx[0] + 1)))),\n",
    "                      ('lz', Ξ(Λ(lambda π: π.itakz(π.ly[0] + 1))))],\n",
    "                     Ξ(Λ(lambda πii:\n",
    "                         ΓΠ.irtak(\n",
    "                             πii.lz[0] + 1,\n",
    "                             πii.lx[1],\n",
    "                             πii.ly[1],\n",
    "                             πii.lz[1]))),\n",
    "                     π=πi  # <~~~ don't forget me!\n",
    "                 ) if πi.y < πi.x\n",
    "                 else\n",
    "                 (πi.c, πi.z)\n",
    "                )),\n",
    "             π=πo),\n",
    "         ['c', 'x', 'y', 'z']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "567c779d-d405-447b-8f5f-da2b611c9a6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 2)"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ΓΠ.irtak(1, 3, 2, 1)  # expect (5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "f00ab315-c5ec-4964-864c-cfeec902a35f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1733, 5)"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ΓΠ.irtak(1, 12, 8, 4)  # expect(1733, 5)  # 72msec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "5016999e-0f99-4fcd-a3f3-73379b829542",
   "metadata": {},
   "outputs": [],
   "source": [
    "# assert ΓΠ.irtak(1, 18, 12, 6) == (63609, 7)  # 2sec 521msec\n",
    "# assert ΓΠ.irtak(1, 28, 20, 12) == (2493349, 13)  # 1min 36sec"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d250f93b-90ec-46f0-b2db-fce4c6fb448c",
   "metadata": {},
   "source": [
    "#### Tak with $\\Upsilon$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "0e46691c-225b-45a1-aa5d-200d834b5e7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DEFINE('tak',\n",
    "      Λ(lambda πt:\n",
    "        Λ(lambda π:\n",
    "          π.tak(\n",
    "              π.tak(π.x - 1, π.y, π.z),\n",
    "              π.tak(π.y - 1, π.z, π.x),\n",
    "              π.tak(π.z - 1, π.x, π.y))\n",
    "          if π.y < π.x else\n",
    "          π.z, ['x', 'y', 'z'], πt),\n",
    "        ['tak']))\n",
    "ΓΠ.ΥN(ΓΠ.tak, ['xt', 'yt', 'zt'])(18, 12, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09541f7f-edd8-470c-8eeb-c3c4350b63a1",
   "metadata": {},
   "source": [
    "Too slow: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "a79c0d66-46ae-42a0-9562-c208471d5364",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ΓΠ.Υ3(ΓΠ.tak)(28, 20, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a72e3989-91ce-4f1e-b3ad-e03e16a8cad3",
   "metadata": {},
   "source": [
    "# LABELS<a id=\"labels\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f55b1de-ce43-4a4b-b2d4-8afefc3ce2f5",
   "metadata": {},
   "source": [
    "`LABELS` is a special case of `LETREC` where all the values are mutually codependent procedures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "c9f7dd11-555a-44da-a771-e0b15e7b6393",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LABELS(\n",
    "        binding_pairs: List[Tuple[str, Any]], \n",
    "        body: Application, \n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    for pair in binding_pairs:\n",
    "        if not isinstance(pair[1], Procedure):\n",
    "            raise IllegalArgumentsError(\n",
    "                f'all values in labels must be Procedures; '\n",
    "                f'this value {pair[1]} is not')\n",
    "    result = LETREC(binding_pairs, body, π)\n",
    "    return result  # <~~~ Hang breakpoint here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54d7e25d-e521-4242-ab0c-38c5db542252",
   "metadata": {},
   "source": [
    "Our old friend, factorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "647755df-14df-463c-b6ed-8341f98f174a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LABELS([('fact_iter_nom',\n",
    "        Λ(lambda π: \n",
    "        (π.a \n",
    "         if π.m <= 0 \n",
    "         else π.fact_iter_nom(π.m - 1, π.a * π.m)),\n",
    "       ['m', 'a']))],\n",
    "      Ξ(Λ(lambda π: π.fact_iter_nom(6, 1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03ee3244-c682-460d-aaa8-40f3e877c9cf",
   "metadata": {},
   "source": [
    "Test monkey patching again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "7e27c9e6-a208-409f-9abd-15fbafccf385",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo: \n",
    "  LABELS([('fact_iter_nom',\n",
    "           Λ(lambda π: \n",
    "             (π.a \n",
    "              if π.m <= π.m0  # <~~~ Watch out!\n",
    "              else π.fact_iter_nom(π.m - 1, π.a * π.m)),\n",
    "             ['m', 'a']))],\n",
    "         Ξ(Λ(lambda π: π.fact_iter_nom(6, 1))),\n",
    "         πo),\n",
    "  ['m0'])(1)  # <~~~ Works with 1, also."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02e4d11a-108c-4ca2-a65d-e9f90c755dd3",
   "metadata": {},
   "source": [
    "# DO<a id=\"do\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd4ff505-5836-4b85-9b15-20888ec5a2fc",
   "metadata": {},
   "source": [
    "Here is the specification of `DO` from Steele's paper, without further explanation here:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d954695a-44e1-4352-a9e7-ef751ee6735a",
   "metadata": {},
   "source": [
    "```\n",
    "(DO ((<var1> <init1> <step1>)\n",
    "     (<var2> <init2> <step2>)\n",
    "     ...\n",
    "     (<varN> <initN> <stepN>))\n",
    "    (<pred> <value>) \n",
    "    <optional body>)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44a909ff-5152-4cb4-a129-475a2650525d",
   "metadata": {},
   "source": [
    "First, a non-tail-recursive version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "319848ba-3751-403a-bf93-43abf0c6fbc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CHECK_TYPE(x: Any, t: Any) -> Any:\n",
    "    assert isinstance(x, t)\n",
    "    return x\n",
    "\n",
    "def DO_NTC(\n",
    "        triples: List[Tuple[str, Expression, Procedure]],\n",
    "        pred: Procedure,\n",
    "        value: Expression,\n",
    "        body: Procedure,\n",
    "        π: Environment = ΓΠ\n",
    ") -> Any:\n",
    "    \"\"\"(DO ((<var1> <init1> <λstep1>)\n",
    "            (<var2> <init2> <λstep2>\n",
    "            . . .\n",
    "            (<varñ> <initñ> <λstepñ))\n",
    "            (<λpred> <λvalue>)\n",
    "            <λbody>\n",
    "            <env=None>).\n",
    "    Steps are evaluated sequentially.\n",
    "    Tail-recursive version requires a LOOPN.\n",
    "    \"\"\"\n",
    "    vars = [CHECK_TYPE(t[0], str) for t in triples]\n",
    "    inits = [t[1] for t in triples]\n",
    "    steps = [CHECK_TYPE(t[2], Procedure) for t in triples]\n",
    "    E1 = Environment(lambda: None, π)\n",
    "    _ = [setattr(E1.ϕ, f'σteps_{i}', step)\n",
    "         for i, step in enumerate(steps)]\n",
    "    setattr(E1.ϕ, 'πred', CHECK_TYPE(pred, Procedure))\n",
    "    setattr(E1.ϕ, 'vaλue', CHECK_TYPE(value, Procedure))\n",
    "    setattr(E1.ϕ, 'βody', CHECK_TYPE(body, Procedure))\n",
    "    r = LABELS([(\n",
    "        'λoop',\n",
    "        Λ(lambda πb:\n",
    "          (EVAL(Ξ('vaλue'), πb)\n",
    "           if EVAL(Ξ('πred'), πb)\n",
    "           else πb.λoop(  # <~~~ non-tail recursion\n",
    "              EVAL(Ξ('βody'), πb),\n",
    "              *[EVAL(Ξ(f'σteps_{i}'), πb)\n",
    "                for i in range(len(steps))])),\n",
    "          ['βody_result', *vars]))],\n",
    "        Ξ('λoop',\n",
    "          [None, *[EVAL(init, E1) for init in inits]]),\n",
    "        E1)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3f97b4c-7686-40c0-bdb2-6220aa1c49f7",
   "metadata": {},
   "source": [
    "Our old friend, factorial, as non-tail-recursive `DO`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "9a6316da-2f46-4e63-a162-a3a3d9404185",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo:\n",
    "  DO_NTC([('m', πo.m, Λ(lambda π: π.m - 1)),\n",
    "          ('a', 1, Λ(lambda π: π.a * π.m))],\n",
    "         pred=Λ(lambda π: π.m <= 1),\n",
    "         value=Λ(lambda π: π.a),\n",
    "         body=Λ(lambda π: None),\n",
    "         π=πo),\n",
    "  ['m'])(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eb44bbc-5da9-47c9-b902-58307c521b98",
   "metadata": {},
   "source": [
    "This blows recursion, naturally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "883b659c-f1dd-41d9-9507-8f1edaea0508",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('maximum recursion depth exceeded',)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    Λ(lambda πo:\n",
    "      DO_NTC([('m', πo.m, Λ(lambda π: π.m - 1)),\n",
    "              ('a', 1, Λ(lambda π: π.a * π.m))],\n",
    "             pred=Λ(lambda π: π.m <= 1),\n",
    "             value=Λ(lambda π: π.a),\n",
    "             body=Λ(lambda π: None),\n",
    "             π=πo),\n",
    "      ['m'])(800)\n",
    "except RecursionError as e:\n",
    "    print(e.args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60af703e-e7df-4fbe-8199-47764876ad9c",
   "metadata": {},
   "source": [
    "A tail-recursive version, with the natural name `DO`. This uses `LOOPN`, defined earlier. Because tail-recursion must be the base case in Schemulator, we don't bother to test $\\Upsilon{}N$, here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "2bfec8e1-b311-46f4-8b6b-9d197f77596e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def DO(\n",
    "        triples: List[Tuple[str, Expression, Procedure]],\n",
    "        pred: Procedure,\n",
    "        value: Procedure,\n",
    "        body: Procedure,\n",
    "        π: Environment = ΓΠ):\n",
    "    \"\"\"(DO ((<var1> <init1> <λstep1>)\n",
    "            (<var2> <init2> <λstep2>\n",
    "            . . .\n",
    "            (<varñ> <initñ> <λstepñ))\n",
    "            (<λpred> <λvalue>)\n",
    "            <λbody>\n",
    "            <env=None>).\n",
    "    Steps are evaluated sequentially.\n",
    "    Tail-recursive version requires a LOOPN.\n",
    "    \"\"\"\n",
    "    vars = [CHECK_TYPE(t[0], str) for t in triples]\n",
    "    inits = [t[1] for t in triples]\n",
    "    steps = [CHECK_TYPE(t[2], Procedure) for t in triples]\n",
    "    E1 = Environment(lambda: None, π)\n",
    "    _ = [setattr(E1.ϕ, f'σteps_{i}', step)\n",
    "         for i, step in enumerate(steps)]\n",
    "    setattr(E1.ϕ, 'πred', CHECK_TYPE(pred, Procedure))\n",
    "    setattr(E1.ϕ, 'vaλue', CHECK_TYPE(value, Procedure))\n",
    "    setattr(E1.ϕ, 'βody', CHECK_TYPE(body, Procedure))\n",
    "    r = LABELS([(\n",
    "        'λoop',\n",
    "        Λ(lambda πd:  # Domain code is a functino of 'λf', ...\n",
    "          Λ(lambda πb:  # ... which is busines code of N params.\n",
    "            (EVAL(Ξ('vaλue'), πb)\n",
    "             if EVAL(Ξ('πred'), πb)\n",
    "             else πb.λf(  # <~~~ tail recursion\n",
    "                EVAL(Ξ('βody'), πb),\n",
    "                *[EVAL(Ξ(f'σteps_{i}'), πb)\n",
    "                  for i in range(len(steps))])),\n",
    "            ['βody_result', *vars], π=πd),\n",
    "          ['λf'], π=E1))],\n",
    "        Ξ(Λ(lambda πl:\n",
    "            LOOPN(πl.λoop, ['βody_result', *vars])  # <~~~ Tail Recursion\n",
    "            (None, *[EVAL(init, E1) for init in inits]))),\n",
    "        E1)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "2cf2b18b-032c-41db-a100-60c32d347167",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo:\n",
    "  DO([('m', πo.m, Λ(lambda π: π.m - 1)),\n",
    "      ('a', 1, Λ(lambda π: π.a * π.m))],\n",
    "     pred=Λ(lambda π: π.m <= 1),\n",
    "     value=Λ(lambda π: π.a),\n",
    "     body=Λ(lambda π: None),\n",
    "     π=πo),\n",
    "  ['m'])(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "330f1b31-1222-4119-a655-a0b4c162cfe0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "771053011335386004144639397775028360595556401816010239163410994033970851827093069367090769795539033092647861224230677444659785152639745401480184653174909762504470638274259120173309701702610875092918816846985842150593623718603861642063078834117234098513725265045402523056575658860621238870412640219629971024686826624713383660963127048195572279707711688352620259869140994901287895747290410722496106151954257267396322405556727354786893725785838732404646243357335918597747405776328924775897564519583591354080898117023132762250714057271344110948164029940588827847780442314473200479525138318208302427727803133219305210952507605948994314345449325259594876385922128494560437296428386002940601874072732488897504223793518377180605441783116649708269946061380230531018291930510748665577803014523251797790388615033756544830374909440162270182952303329091720438210637097105616258387051884030288933650309756289188364568672104084185529365727646234588306683493594765274559497543759651733699820639731702116912963247441294200297800087061725868223880865243583365623482704395893652711840735418799773763054887588219943984673401051362280384187818611005035187862707840912942753454646054674870155072495767509778534059298038364204076299048072934501046255175378323008217670731649519955699084482330798811049166276249251326544312580289357812924825898217462848297648349400838815410152872456707653654424335818651136964880049831580548028614922852377435001511377656015730959254647171290930517340367287657007606177675483830521499707873449016844402390203746633086969747680671468541687265823637922007413849118593487710272883164905548707198762911703545119701275432473548172544699118836274377270607420652133092686282081777383674487881628800801928103015832821021286322120460874941697199487758769730544922012389694504960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Λ(lambda πo:\n",
    "  DO([('m', πo.m, Λ(lambda π: π.m - 1)),\n",
    "      ('a', 1, Λ(lambda π: π.a * π.m))],\n",
    "     pred=Λ(lambda π: π.m <= 1),\n",
    "     value=Λ(lambda π: π.a),\n",
    "     body=Λ(lambda π: None),\n",
    "     π=πo),\n",
    "  ['m'])(800)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c49ae6ee-7afa-4d3d-a258-63b5937feaa5",
   "metadata": {},
   "source": [
    "# GOTO"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7f30c19-b34b-49d7-90e7-e416d1c7b9cd",
   "metadata": {},
   "source": [
    "TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97681661-302d-41dd-96d1-da6d95d460ef",
   "metadata": {},
   "source": [
    "# COND"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7af12c5-2dad-4e65-8be3-25e2ec23a12f",
   "metadata": {},
   "source": [
    "TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c8ab79e-f72c-4b70-97e1-27c04868749e",
   "metadata": {},
   "source": [
    "# Junkyard / Workshop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "767801fa-a7e5-40d5-bc10-b5b2fa8b2194",
   "metadata": {},
   "source": [
    "Ignore everything below. It's saved in case we need it someday."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd40440b-a5dd-4223-8c95-b50aa8cd779e",
   "metadata": {},
   "source": [
    "## Named Let"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2277e957-8aa5-4239-a513-53170112a626",
   "metadata": {},
   "source": [
    "## Partial Evaluation and Automatic Currying"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a935e76-9d80-48be-8b6c-b3f654312f91",
   "metadata": {},
   "source": [
    "## QUOTE, QUASIQUOTE, UNQUOTE, MACROS<a id=\"quote\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0177c7f0-0dc6-410e-814c-80086b629b69",
   "metadata": {},
   "source": [
    "## Normal-Order (Lazy) Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a71d117-a9af-4673-9875-b67ce98f8168",
   "metadata": {},
   "source": [
    "## Streams (scons, scar, scdr, ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "690bfd89-a92a-4835-9516-a6b98bc8a4f0",
   "metadata": {},
   "source": [
    "## Tanai"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d2640b3-b2ac-45b6-8436-73265a3b17a7",
   "metadata": {},
   "source": [
    "## Laziest Tanai"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,md"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "toc-autonumbering": true,
  "toc-showcode": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}