notebooks/Reference Guide for Calysto Scheme.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/logo-64x64.png\"/>\n",
    "<h1>Reference Guide for Calysto Scheme</h1>\n",
    "\n",
    "[Calysto Scheme](https://github.com/Calysto/calysto_scheme) is a real Scheme programming language, with full support for continuations, including call/cc. It can also use all Python libraries. Also has some extensions that make it more useful (stepper-debugger, choose/fail, stack traces), or make it better integrated with Python.\n",
    "\n",
    "In Jupyter notebooks, because Calysto Scheme uses [MetaKernel](https://github.com/Calysto/metakernel/blob/master/README.rst), it has a fully-supported set of \"magics\"---meta-commands for additional functionality. This includes running Scheme in parallel. See all of the [MetaKernel Magics](https://github.com/Calysto/metakernel/blob/master/metakernel/magics/README.md).\n",
    "\n",
    "Calysto Scheme is written in Scheme, and then translated into Python (and other backends). The entire functionality lies in a single Python file: https://github.com/Calysto/calysto_scheme/blob/master/calysto_scheme/scheme.py However, you can easily install it (see below).\n",
    "\n",
    "## Installation\n",
    "\n",
    "You can install Calysto Scheme with Python3:\n",
    "\n",
    "```\n",
    "pip3 install --upgrade calysto-scheme --user -U\n",
    "python3 -m calysto_kernel install --user\n",
    "```\n",
    "\n",
    "or in the system kernel folder with:\n",
    "\n",
    "```\n",
    "sudo pip3 install --upgrade calysto-scheme -U\n",
    "sudo python3 -m calysto_kernel install\n",
    "```\n",
    "\n",
    "Change pip3/python3 to use a different pip or Python. The version of Python used will determine how Calysto Scheme is run.\n",
    "\n",
    "Use it in the console, qtconsole, or notebook with IPython 3:\n",
    "\n",
    "```\n",
    "ipython console --kernel calysto_scheme\n",
    "ipython qtconsole --kernel calysto_scheme\n",
    "ipython notebook --kernel calysto_scheme\n",
    "```\n",
    "\n",
    "In addition to all of the following items, Calysto Scheme also has access to all of Python's builtin functions, and all of Python's libraries. For example, you can use `(complex 3 2)` to create a complex number by calling Python's complex function.\n",
    "\n",
    "## Jupyter Enhancements\n",
    "\n",
    "When you run Calysto Scheme in Jupyter (console, notebook, qtconsole, etc.) you get:\n",
    "\n",
    "* TAB completions of Scheme functions and variable names\n",
    "* display of rich media\n",
    "* stepper/debugger\n",
    "* magics (% macros)\n",
    "* shell commands (! command)\n",
    "* LaTeX equations\n",
    "* LaTeX-style variables\n",
    "* Python integration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LaTeX-style variables\n",
    "\n",
    "Calysto Scheme allows you to use LaTeX-style variables in code. For example, if you type:\n",
    "\n",
    "```\n",
    "\\beta\n",
    "```\n",
    "\n",
    "with the cursor right after the 'a' in beta, and then press TAB, it will turn into the unicode character:\n",
    "\n",
    "```\n",
    "β\n",
    "```\n",
    "\n",
    "There are nearly 1300 different symbols defined (thanks to the Julia language) and documented here:\n",
    "\n",
    "http://docs.julialang.org/en/release-0.4/manual/unicode-input/#man-unicode-input\n",
    "\n",
    "Calysto Scheme may not implement all of those. Some useful and suggestive ones:\n",
    "\n",
    "* \\pi - π\n",
    "* \\Pi - Π\n",
    "* \\Sigma - Σ\n",
    "* \\_i - subscript i, such as vectorᵢ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(define α 67)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "α"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define i 2)\n",
    "(define vectorᵢ (vector-ref (vector 0 6 3 2) i))\n",
    "vectorᵢ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rich media"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(calysto)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import \"calysto.display\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "This is <b>bold</b>, <i>italics</i>, <u>underlined</u>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(calysto.display.HTML \"This is <b>bold</b>, <i>italics</i>, <u>underlined</u>.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(calysto)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import \"calysto.graphics\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(define canvas (calysto.graphics.Canvas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define ball (calysto.graphics.Circle '(150 150) 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASwAAAEsCAYAAAB5fY51AAAABmJLR0QA/wD/AP+gvaeTAAAak0lE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\nIiIiIiIiIiIiIiIiIiJx8P8Ae/mYKPy+T60AAAAASUVORK5CYII=\n",
      "image/svg+xml": [
       "<svg baseProfile=\"full\" height=\"300\" version=\"1.1\" width=\"300\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:ev=\"http://www.w3.org/2001/xml-events\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs /><circle cx=\"150\" cy=\"150\" fill=\"#800080\" r=\"100\" stroke=\"#000000\" stroke-width=\"1\" /></svg>"
      ],
      "text/plain": [
       "<Canvas (300, 300)>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ball.draw canvas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shell commands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "config-err-7810dL  \u001b[0m\u001b[01;34memacs1000\u001b[0m  unity_support_test.0  \u001b[01;34muploads\u001b[0m\n",
      "/home/dblank/Desktop/ProgLangBook\n",
      "config-err-7810dL  \u001b[0m\u001b[01;34memacs1000\u001b[0m  unity_support_test.0  \u001b[01;34muploads\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "! ls /tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stepper/Debugger\n",
    "\n",
    "Here is what the debugger looks like:\n",
    "\n",
    "<img src=\"images/stepper_debugger.png\">\n",
    "\n",
    "It has breakpoints (click in left margin). You must press Stop to exit the debugger."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```scheme\n",
    "%%debug\n",
    "\n",
    "(begin\n",
    " (define x 1)\n",
    " (set! x 2)\n",
    ")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Integration\n",
    "\n",
    "You can import and use any Python library in Calysto Scheme.\n",
    "\n",
    "In addition, if you wish, you can execute expressions and statements in a Python environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(python-eval \"1 + 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(python-exec \n",
    "\"\n",
    "def mypyfunc(a, b):\n",
    "    return a * b\n",
    "\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a shared environment with Scheme:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(mypyfunc 4 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `func` to turn a Scheme procedure into a Python function, and `define!` to put it into the shared enviornment with Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define! mypyfunc2 (func (lambda (n) n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(python-eval \"mypyfunc2(34)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Differences Between Languages\n",
    "\n",
    "## Major differences between Scheme and Python\n",
    "\n",
    "1. In Scheme, double quotes are used for strings and may contain newlines\n",
    "1. In Scheme, a single quote is short for (quote ...) and means \"literal\"\n",
    "1. In Scheme, everything is an expression and has a return value\n",
    "1. Python does not support macros (e.g., extending syntax)\n",
    "1. In Python, \"if X\" is false if X is None, False, [], (,) or 0. In Scheme, \"if X\" is only false if X is #f or 0\n",
    "1. Calysto Scheme uses continuations, not the call stack. However, for debugging there is a pseudo-stack when an error is raised. You can trun that off with (use-stack-trace #f)\n",
    "1. Scheme procedures are not Python functions, but there are means to use one as the other.\n",
    "\n",
    "## Major Differences Between Calysto Scheme and other Schemes\n",
    "\n",
    "1. define-syntax works slightly differently\n",
    "1. In Calysto Scheme, #(...) is short for '#(...)\n",
    "1. Calysto Scheme is missing many standard functions (see list at bottom)\n",
    "1. Calysto Scheme has a built-in amb operator called `choose`\n",
    "1. For debugging there is a pseudo-stack when errors are raised in Calysto Scheme. You can trun that off with (use-stack-trace #f)\n",
    "\n",
    "### Stack Trace\n",
    "\n",
    "Calysto Scheme acts as if it has a call stack, for easier debugging. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define fact\n",
    "    (lambda (n)\n",
    "      (if (= n 1)\n",
    "           q\n",
    "           (* n (fact (- n 1))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"In [5]\", line 1, col 1, in 'fact'\n",
      "  File \"In [4]\", line 5, col 17, in 'fact'\n",
      "  File \"In [4]\", line 5, col 17, in 'fact'\n",
      "  File \"In [4]\", line 5, col 17, in 'fact'\n",
      "  File \"In [4]\", line 5, col 17, in 'fact'\n",
      "  File \"In [4]\", line 4, col 12\n",
      "RunTimeError: unbound variable 'q'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "(fact 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To turn off the stack trace on error:\n",
    "\n",
    "```scheme\n",
    "(use-stack-trace #f)\n",
    "```\n",
    "That will allow infinite recursive loops without keeping track of the \"stack\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calysto Scheme Variables\n",
    "\n",
    "## SCHEMEPATH\n",
    "SCHEMEPATH is a list of search directories used with (load NAME). This is a reference, so you should append to it rather than attempting to redefine it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\".\" \"/usr/local/lib/python3.4/dist-packages/calysto_scheme/modules\")"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCHEMEPATH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(set-cdr! (cdr SCHEMEPATH) (list \"/var/modules\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\".\" \"/usr/local/lib/python3.4/dist-packages/calysto_scheme/modules\" \"/var/modules\")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCHEMEPATH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calysto Scheme Procedures\n",
    "\n",
    "The following are implemented as macros and are syntactic sugar on simpler forms:\n",
    "\n",
    "* let\n",
    "* letrec\n",
    "* let*\n",
    "* and\n",
    "* or\n",
    "* cond\n",
    "* case\n",
    "* cases\n",
    "* record-case\n",
    "* define-datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## % (modulo)\n",
    "(% arg0 arg1): modulo procedure for two arguments (aliases mod and modulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(% 5 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## * (multiply)\n",
    "(* ...): multiplication procedure; multiplies all arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 2 3 4 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## + (addition)\n",
    "(+ ...): addition procedure; adds all arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(+ 1 1 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## - (subtraction)\n",
    "(- ...): subtraction procedure; subtracts all arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(- 5 4 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## / (real division)\n",
    "(/ ...): division procedure; divides all arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3/2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(/ 3 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## // (integer division)\n",
    "(// arg0 arg1): quotient procedure for rationals/ints; divides arg0 by arg1 (aliases div and quotient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(// 3 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## < (less than)\n",
    "(< arg0 arg1): less-than procedure for two arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(< 6 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <= (less than or equals to)\n",
    "(<= arg0 arg1): less-than or equal procedure for two arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(<= 5.5 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## = (numeric equals)\n",
    "(= arg0 arg1): numeric equality procedure for two arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(= 7 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## > (greater than)\n",
    "(> arg0 arg1): greater-than procedure for two arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(> 8 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## >= (greater than or equals to)\n",
    "(>= arg0 arg1): greater-than or equal procedure for two arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(>= 9 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## abort\n",
    "(abort) : aborts processing and returns to top level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(abort)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## abs\n",
    "(abs value): absolute value procedure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(abs -67)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## and\n",
    "(and ITEM ...)\n",
    "\n",
    "`and` is defined via a macro (define-syntax)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(and #f (/ 6 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## append\n",
    "(append ...): append lists together into a single list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3 4 5)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(append '(1 2 3) '(4 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## apply\n",
    "(apply PROCEDURE '(args...)): apply the PROCEDURE to the args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(apply + '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## assq\n",
    "(assv KEY ((ITEM VALUE) ...)): look for KEY in ITEMs; return matching (ITEM VALUE) or #f if not found. Uses eq? to look for key. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(key 2)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(assq 'key '((apple 1)(key 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(assq 'key '((apple 1)(banana 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## assv\n",
    "(assv KEY ((ITEM VALUE) ...)): look for KEY in ITEMs; return matching (ITEM VALUE) or #f if not found. Uses eqv? to look for key. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(key 2)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(assv 'key '((apple 1)(key 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## atom?\n",
    "(atom? ITEM): return #t if ITEM is a atom, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(atom? (cons 1 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(atom? 'a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## boolean?\n",
    "(boolean? ITEM): return #t if ITEM is a boolean value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(boolean? #t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caaaar\n",
    "caaaar LIST): return the caaaar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(hello there)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caaaar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caaadr\n",
    "(caaadr LIST): return the caaadr of the LIST "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "in"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caaadr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caaar\n",
    "(caaar LIST): return the caaar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((hello there) this is a test)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caaar '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caadar\n",
    "(caadar LIST): return the caadar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1 2 3) 4 5 6)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caadar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caaddr\n",
    "(caaddr LIST): return the caaddr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "the"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caaddr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caadr\n",
    "(caadr LIST): return the caadr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(in)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caadr '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caar\n",
    "(caar LIST): return the caar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(((hello there) this is a test) what is this)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caar '(((((hello there) this is a test) what is this) \n",
    "         (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cadaar\n",
    "(cadaar LIST): return the cadaar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "what"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cadaar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cadadr\n",
    "(cadadr LIST): return the cadadr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "another"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cadadr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in) another) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cadar\n",
    "(cadar LIST): return the cadar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(((1 2 3) 4 5 6) 7 8 9)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cadar '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caddar\n",
    "(caddar LIST): return the caddar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "another"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caddar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cadddr\n",
    "(cadddr LIST): return the cadddr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cadddr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## caddr\n",
    "(caddr LIST): return the (car (cdr (cdr LIST)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(the)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(caddr '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cadr\n",
    "(cadr LIST): return the (car (cdr LIST))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((in))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cadr '(((((hello there) this is a test) what is this) \n",
    "         (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## call-with-current-continuation\n",
    "(call-with-current-continuation PROCEDURE): \n",
    "\n",
    "See call/cc for examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## call/cc\n",
    "(call/cc PROCEDURE): call-with-current-continuation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (call/cc (lambda (k) 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (call/cc (lambda (k) (+ 1 (k 4)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (call/cc (lambda (k) \n",
    "                 (+ 1 (call/cc \n",
    "                       (lambda (j) \n",
    "                         (+ 2 (j (k 5)))))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (call/cc (lambda (k) \n",
    "                 (+ 1 (call/cc \n",
    "                       (lambda (j) \n",
    "                         (+ 2 (k (j 5)))))))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## car\n",
    "(car LIST) returns the first element of LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((((hello there) this is a test) what is this) (((1 2 3) 4 5 6) 7 8 9) another item)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(car '(((((hello there) this is a test) what is this) \n",
    "        (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## case\n",
    "(case ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(case 'thing1 (thing2 1) (thing1 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(case 'thing1 (thing2 1) ((thing1 thing3) 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(case 'thingx (thing2 1) ((thing1 thing3) 2) (else 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(case 'banana\n",
    "    (apple 'no)\n",
    "    ((cherry banana) 1 2 3)\n",
    "    (else 'no))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cases\n",
    "(cases...)\n",
    "\n",
    "See examples in define-datatype."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cd\n",
    "(cd [PATH]): get the current directory, or set it if PATH is given (alias current-directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"/\""
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cd \"/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdaaar\n",
    "(cdaaar LIST): return the cdaaar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(this is a test)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdaaar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdaadr\n",
    "(cdaadr LIST): return the cdaadr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdaadr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdaar\n",
    "(cdaar LIST): return the cdaar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(what is this)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdaar '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdadar\n",
    "(cdadar LIST): return the cdadar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7 8 9)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdadar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdaddr\n",
    "(cdaddr LIST): return the cdaddr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdaddr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdadr\n",
    "(cdadr LIST): return the cdadr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdadr '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdar\n",
    "(cdar LIST): return the cdar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((((1 2 3) 4 5 6) 7 8 9) another item)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdar '(((((hello there) this is a test) what is this) \n",
    "         (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cddaar\n",
    "(cddaar LIST): return the cddaar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(is this)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cddaar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cddadr\n",
    "(cddadr LIST): return the cddadr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(other)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cddadr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in) some other) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cddar\n",
    "(cddar LIST): return the cddar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(another item)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cddar '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdddar\n",
    "(cdddar LIST): return the cdddar of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(item)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdddar '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cddddr\n",
    "(cddddr LIST): return the cddddr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cddddr '(((((hello there) this is a test) what is this) \n",
    "           (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdddr\n",
    "(cdddr LIST): return the cddr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(list)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdddr '(((((hello there) this is a test) what is this) \n",
    "          (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cddr\n",
    "(cddr LIST): return the cddr of the LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((the) list)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cddr '(((((hello there) this is a test) what is this) \n",
    "         (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cdr\n",
    "(cdr LIST) returns rest of LIST after (car LIST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(((in)) (the) list)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cdr '(((((hello there) this is a test) what is this) \n",
    "        (((1 2 3) 4 5 6) 7 8 9) another item) ((in)) (the) list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char->integer\n",
    "(char->integer CHAR): return associated number of CHAR "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char->integer #\\1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char->string\n",
    "(char->string CHAR): return the character as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a\""
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char->string #\\a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char-alphabetic?\n",
    "(char-alphabetic? CHAR): return #t if CHAR is an alphabetic character, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char-alphabetic? #\\1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char-alphabetic? #\\a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char-numeric?\n",
    "(char-numeric? CHAR): return #t if CHAR is a whitespace character, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char-numeric? #\\2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char-whitespace?\n",
    "(char-whitespace? CHAR): return #t if CHAR is a whitespace character, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char-whitespace? #\\tab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char=?\n",
    "(char=? CHAR1 CHAR2): return #t if CHAR1 has the same values as CHAR2, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char=? #\\1 #\\2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## char?\n",
    "(char? ITEM): return #t if ITEM is a character, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char? \"h\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## choose\n",
    "\n",
    "This is the main interface to the non-deterministic interface. Using (choose options) combined with (require BOOLEAN-TEST) you can go back and select another option.\n",
    "\n",
    "(choose OPTIONS): pick one, with ability to go back and pick another later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define x (choose 1 2 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(require #f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(require #f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"no more choices\""
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(require #f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can solve many problems in a concise manner with choose/require. The following puzzle (taken from Dinesman 1968) is typical of a large class of simple logic puzzles:\n",
    "\n",
    "> Baker, Cooper, Fletcher, Miller, and Smith live on different floors of an apartment house that contains only five floors. Baker does not live on the top floor. Cooper does not live on the bottom floor. Fletcher does not live on either the top or the bottom floor. Miller lives on a higher floor than does Cooper. Smith does not live on a floor adjacent to Fletcher's. Fletcher does not live on a floor adjacent to Cooper's. Where does everyone live?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define floors2\n",
    "  (lambda ()\n",
    "    (let ((baker (choose 1 2 3 4 5)))\n",
    "      (require (not (= baker 5)))\n",
    "      (let ((fletcher (choose 1 2 3 4 5)))\n",
    "        (require (not (= fletcher 5)))\n",
    "        (require (not (= fletcher 1)))\n",
    "        (let ((cooper (choose 1 2 3 4 5)))\n",
    "          (require (not (= cooper 1)))\n",
    "          (require (not (= (abs (- fletcher cooper)) 1)))\n",
    "          (let ((smith (choose 1 2 3 4 5)))\n",
    "            (require (not (= (abs (- smith fletcher)) 1)))\n",
    "            (let ((miller (choose 1 2 3 4 5)))\n",
    "              (require (> miller cooper))\n",
    "              (require (distinct? (list baker cooper fletcher miller smith)))\n",
    "              (list\n",
    "                (list 'baker: baker)\n",
    "                (list 'cooper: cooper)\n",
    "                (list 'fletcher: fletcher)\n",
    "                (list 'miller: miller)\n",
    "                (list 'smith: smith)))))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define distinct?\n",
    "  (lambda (nums)\n",
    "    (or (null? nums)\n",
    "        (null? (cdr nums))\n",
    "        (and (not (member (car nums) (cdr nums)))\n",
    "             (distinct? (cdr nums))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((baker: 3) (cooper: 2) (fletcher: 4) (miller: 5) (smith: 1))"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(floors2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cond\n",
    "(cond CONDITIONS): CONDITIONS are composed of (TEST RETURN). cond will return the first RETURN where TEST is #t. `else` is considered to be #t."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cond \n",
    " (#f 1) \n",
    " (else 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cons\n",
    "(cons ITEM1 ITEM2): return a list with ITEM1 as car and ITEM2 as cdr (ITEM2 is typically a list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 . 2)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cons 1 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## contains\n",
    "(contains DICTIONARY ITEM): returns #t if DICTIONARY contains ITEM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(contains (dict '((a 1) (b 2))) 'b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## current-directory\n",
    "(current-directory [PATH]): get the current directory, or set it if PATH is given (alias cd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"/\""
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(current-directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"/tmp\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cd \"/tmp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## current-environment\n",
    "(current-environment): returns the current environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<environment>"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(current-environment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## current-time\n",
    "(current-time): returns the current time as number of seconds since 1970-1-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1470252063.6648307"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(current-time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cut\n",
    "(cut ARGS...): return to toplevel with ARGS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cut 1 2 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(23)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(letrec ((loop (lambda (n) \n",
    "                 (if (= n 0) \n",
    "                     (set! var (cut 23)) \n",
    "                     (loop (- n 1)))))\n",
    "         (var 0))\n",
    "  (loop 10)\n",
    "  var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define my-odd? 'undefined)\n",
    "(define my-even? 'undefined)\n",
    "\n",
    "(letrec\n",
    "    ((odd (lambda (n) (if (= n 0) #f (even (- n 1)))))\n",
    "     (even (lambda (n) (if (= n 0) #t (odd (- n 1))))))\n",
    "  (set! my-odd? odd)\n",
    "  (set! my-even? even))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(my-odd? 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(my-even? 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(my-odd? 43)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(my-even? 43)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## define\n",
    "(define SYMBOL VALUE): bind a symbol to a value in the top-level-environment  \n",
    "(define (SYMBOL ARGS) VALUE): the MIT-define"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define x 1)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define (f a b) (+ a b)) ;; MIT-style (hidden lambda)\n",
    "(f 5 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define f\n",
    "  (lambda (a b)\n",
    "    (+ a b)))\n",
    "(f 5 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "(begin\n",
    " (define y 2)\n",
    " (print y)\n",
    ")\n",
    "(print y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## define! \n",
    "\n",
    "Define an item in the shared environment with Python.\n",
    "\n",
    "(define! NAME VALUE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(define! myvar 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(python-eval \"myvar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## define-datatype\n",
    "(define-datatype TYPE TYPE-TEST-NAME COMPONENTS): define a new datatype. Creates the constructors and tests for the datatype and components. For use with `cases`. See below for example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define-datatype lc-exp lc-exp?\n",
    "  (var-exp \n",
    "   (var symbol?))\n",
    "  (lambda-exp \n",
    "   (bound-var symbol?)\n",
    "   (body lc-exp?))\n",
    "  (app-exp\n",
    "   (rator lc-exp?)\n",
    "   (rand lc-exp?)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(var-exp a)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(var-exp 'a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(lambda-exp a (var-exp a))"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda-exp 'a (var-exp 'a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(app-exp (lambda-exp a (var-exp a)) (var-exp a))"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(app-exp (lambda-exp 'a (var-exp 'a)) (var-exp 'a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define un-parse\n",
    "  (lambda (exp)\n",
    "    (cases lc-exp exp\n",
    "       (var-exp (var) var)\n",
    "       (lambda-exp (bound-var body) (list bound-var body))\n",
    "       (app-exp (rator rand) (list rator rand)))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(un-parse (var-exp 'a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a (var-exp a))"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(un-parse (lambda-exp 'a (var-exp 'a)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((lambda-exp a (var-exp a)) (var-exp a))"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(un-parse (app-exp (lambda-exp 'a (var-exp 'a)) (var-exp 'a)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## define-syntax\n",
    "(define-syntax NAME RULES): a method for creating macros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define-syntax time \n",
    "  [(time ?exp) (let ((start (current-time)))\n",
    "                 ?exp\n",
    "                 (- (current-time) start))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0002892017364501953"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(time (car '(1 2 3 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    ";;---------------------------------------------------------------------\n",
    ";; collect is like list comprehension in Python\n",
    "\n",
    "(define-syntax collect\n",
    "  [(collect ?exp for ?var in ?list)\n",
    "   (filter-map (lambda (?var) ?exp) (lambda (?var) #t) ?list)]\n",
    "  [(collect ?exp for ?var in ?list if ?condition)\n",
    "   (filter-map (lambda (?var) ?exp) (lambda (?var) ?condition) ?list)])\n",
    "\n",
    "(define filter-map\n",
    "  (lambda (f pred? values)\n",
    "    (if (null? values)\n",
    "      '()\n",
    "      (if (pred? (car values))\n",
    "          (cons (f (car values)) (filter-map f pred? (cdr values)))\n",
    "          (filter-map f pred? (cdr values))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0 1 4 9 16 25 36 49 64 81)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(collect (* n n) for n in (range 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25 64 121 196 289)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(collect (* n n) for n in (range 5 20 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(36 49 64 81)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(collect (* n n) for n in (range 10) if (> n 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    ";;---------------------------------------------------------------------\n",
    ";; for loops\n",
    "\n",
    "(define-syntax for\n",
    "  [(for ?exp times do . ?bodies)\n",
    "   (for-repeat ?exp (lambda () . ?bodies))]\n",
    "  [(for ?var in ?exp do . ?bodies)\n",
    "   (for-iterate1 ?exp (lambda (?var) . ?bodies))]\n",
    "  [(for ?var at (?i) in ?exp do . ?bodies)\n",
    "   (for-iterate2 0 ?exp (lambda (?var ?i) . ?bodies))]\n",
    "  [(for ?var at (?i ?j . ?rest) in ?exp do . ?bodies)\n",
    "   (for ?var at (?i) in ?exp do\n",
    "     (for ?var at (?j . ?rest) in ?var do . ?bodies))])\n",
    "\n",
    "(define for-repeat\n",
    "  (lambda (n f)\n",
    "    (if (< n 1)\n",
    "      'done\n",
    "      (begin\n",
    "        (f)\n",
    "        (for-repeat (- n 1) f)))))\n",
    "\n",
    "(define for-iterate1\n",
    "  (lambda (values f)\n",
    "    (if (null? values)\n",
    "      'done\n",
    "      (begin\n",
    "        (f (car values))\n",
    "        (for-iterate1 (cdr values) f)))))\n",
    "\n",
    "(define for-iterate2\n",
    "  (lambda (i values f)\n",
    "    (if (null? values)\n",
    "      'done\n",
    "      (begin\n",
    "        (f (car values) i)\n",
    "        (for-iterate2 (+ i 1) (cdr values) f)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define matrix2d\n",
    "  '((10 20)\n",
    "    (30 40)\n",
    "    (50 60)\n",
    "    (70 80)))\n",
    "\n",
    "(define matrix3d\n",
    "  '(((10 20 30) (40 50 60))\n",
    "    ((70 80 90) (100 110 120))\n",
    "    ((130 140 150) (160 170 180))\n",
    "    ((190 200 210) (220 230 240))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(begin \n",
    " (define hello 0)\n",
    " (for 5 times do (set! hello (+ hello 1)))\n",
    " hello\n",
    " )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "done"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(for sym in '(a b c d) do (define x 1) (set! x sym) x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "done"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(for n in (range 10 20 2) do n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "done"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(for n at (i j) in matrix2d do (list n 'coords: i j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "done"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(for n at (i j k) in matrix3d do (list n 'coords: i j k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(define-syntax scons\n",
    "  [(scons ?x ?y) (cons ?x (lambda () ?y))])\n",
    "\n",
    "(define scar car)\n",
    "\n",
    "(define scdr\n",
    "  (lambda (s)\n",
    "    (let ((result ((cdr s))))\n",
    "      (set-cdr! s (lambda () result))\n",
    "      result)))\n",
    "\n",
    "(define first\n",
    "  (lambda (n s)\n",
    "    (if (= n 0)\n",
    "      '()\n",
    "      (cons (scar s) (first (- n 1) (scdr s))))))\n",
    "\n",
    "(define nth\n",
    "  (lambda (n s)\n",
    "    (if (= n 0)\n",
    "      (scar s)\n",
    "      (nth (- n 1) (scdr s)))))\n",
    "\n",
    "(define smap\n",
    "  (lambda (f s)\n",
    "    (scons (f (scar s)) (smap f (scdr s)))))\n",
    "\n",
    "(define ones (scons 1 ones))\n",
    "\n",
    "(define nats (scons 0 (combine nats + ones)))\n",
    "\n",
    "(define combine\n",
    "  (lambda (s1 op s2)\n",
    "    (scons (op (scar s1) (scar s2)) (combine (scdr s1) op (scdr s2)))))\n",
    "\n",
    "(define fibs (scons 1 (scons 1 (combine fibs + (scdr fibs)))))\n",
    "\n",
    "(define facts (scons 1 (combine facts * (scdr nats))))\n",
    "\n",
    "(define ! (lambda (n) (nth n facts)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(! 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(nth 10 facts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10946"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(nth 20 fibs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(first 30 fibs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dict\n",
    "(dict '((KEY VALUE)...)): creates a Python dictionary\n",
    "(dict '((KEY : VALUE)...)): optional syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{a: 1, b: 2}"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dict '((a 1)(b 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{a: 1, b: 2}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dict '((a : 1)(b : 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dir\n",
    "(dir [ITEM]): return items in environment, or, if ITEM is given, the items in module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(! % * + - / // < <= = > >= SCHEMEPATH abort abs and app-exp append apply assq assv atom? boolean? caaaar caaadr caaar caadar caaddr caadr caar cadaar cadadr cadar caddar cadddr caddr cadr call-with-current-continuation call/cc car case cases cd cdaaar cdaadr cdaar cdadar cdaddr cdadr cdar cddaar cddadr cddar cdddar cddddr cdddr cddr cdr char->integer char->string char-alphabetic? char-numeric? char-whitespace? char=? char? collect combine cond cons contains current-directory current-environment current-time cut define-datatype dict dir display distinct? div eq? equal? eqv? error eval eval-ast even? exit fact facts fibs filter-map first float floors2 for for-each for-iterate1 for-iterate2 for-repeat format get get-stack-trace getitem globals hello import import-as import-from int integer->char iter? lambda-exp lc-exp? length let let* letrec list list->string list->vector list-ref list? load load-as make-set make-vector map matrix2d matrix3d max member memq memv min mod modulo my-even? my-odd? nats newline not nth null? number->string number? odd? ones or pair? parse parse-string print printf procedure? property python-eval python-exec quotient rac range rational rdc read-string record-case remainder require reset-toplevel-env reverse round scar scdr scons set-car! set-cdr! setitem smap snoc sort sqrt string string->list string->number string->symbol string-append string-length string-ref string-split string<? string=? string? substring symbol symbol->string symbol? time typeof un-parse unparse unparse-procedure use-lexical-address use-stack-trace use-tracing var-exp vector vector->list vector-length vector-ref vector-set! vector? void x y zero?)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(__abs__ __add__ __bool__ __class__ __delattr__ __dir__ __divmod__ __doc__ __eq__ __float__ __floordiv__ __format__ __ge__ __getattribute__ __getnewargs__ __gt__ __hash__ __init__ __int__ __le__ __lt__ __mod__ __mul__ __ne__ __neg__ __new__ __pos__ __pow__ __radd__ __rdivmod__ __reduce__ __reduce_ex__ __repr__ __rfloordiv__ __rmod__ __rmul__ __rpow__ __rsub__ __rtruediv__ __setattr__ __sizeof__ __str__ __sub__ __subclasshook__ __truediv__ conjugate imag real)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dir complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## display\n",
    "(display ITEM): display the ITEM as output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello"
     ]
    }
   ],
   "source": [
    "(display \"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## div\n",
    "(div arg0 arg1): quotient procedure for rationals/ints; divides arg0 by arg1 (aliases // and quotient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(div 5 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eq?\n",
    "(eq? ITEM1 ITEM2): return #t if ITEM1 is eq to ITEM2, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eq? '(1 2) '(1 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## equal?\n",
    "(equal? ITEM1 ITEM2): return #t if ITEM1 is equal to ITEM2, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(equal? '(1 2) '(1 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eqv?\n",
    "(eqv? ITEM1 ITEM2): return #t if ITEM1 and ITEM2 have the same value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eqv? '(1 2) '(1 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## error\n",
    "(error NAME FORMATTED-MESSAGE ARGS...): create an exception in NAME with MESSAGE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"In [130]\", line 1, col 1, in 'error'\n",
      "  File \"In [130]\", line 1, col 1\n",
      "RunTimeError: Error in 'procedure-name': What is huh?\n",
      "\n"
     ]
    }
   ],
   "source": [
    "(error \"procedure-name\" \"What is ~a\" 'huh?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eval\n",
    "(eval LIST): evaluates the LIST as a Scheme expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eval '(+ 1 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## eval-ast\n",
    "(eval-ast AST): evaluates the Abstract Syntax Tree as a Scheme expression (see parse and parse-string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eval-ast (parse-string \"(+ 1 2)\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## even?\n",
    "(even? NUMBER): returns #t if NUMBER is odd, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(even? 12121)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## exit\n",
    "(exit): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(exiting the interpreter)"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(exit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## float\n",
    "(float NUMBER): return NUMBER as a floating point value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34.0"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(float 34)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for-each\n",
    "(for-each PROCEDURE LIST): apply PROCEDURE to each item in LIST; like `map` but don't return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "(for-each (lambda (n) (print n)) '(3 4 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## format\n",
    "(format STRING ITEM ...): format the string with ITEMS as arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"This uses formatting apple apple \\n\""
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(format \"This uses formatting ~a ~s ~%\" 'apple 'apple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## func\n",
    "\n",
    "Turns a lambda into a Python function.\n",
    "\n",
    "(func (lambda ...))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function dlr_func.<locals>.f at 0x7f7733b9c6a8>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(func (lambda (n) n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## get\n",
    "\n",
    "Get an item from a loaded module/environment.\n",
    "\n",
    "(get ENVIRONMENT ITEM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scheme Unit tests\n",
      "................................................................................................................................................................................................................................................\n",
      "\n",
      "Results:\n",
      "    right = 240\n",
      "    wrong = 0 \n",
      "Time: 4.101226091384888 seconds\n"
     ]
    }
   ],
   "source": [
    "(load-as \"test_all.ss\" 'test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "."
     ]
    }
   ],
   "source": [
    "((get 'test 'verify) \"test-name\" 1 = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((get 'test '!) 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## get-stack-trace\n",
    "(get-stack-trace): return the current stack trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((app-aexp (lexical-address-aexp 0 74 get-stack-trace (\"In [141]\" 1 2 2 1 16 16)) () (\"In [141]\" 1 1 1 1 17 17)))"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(get-stack-trace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## getitem\n",
    "(getitem DICTIONARY ITEM): returns the VALUE of DICTIONARY[ITEM]  \n",
    "(getitem vector ITEM): returns the VALUE of VECTOR[ITEM]  \n",
    "(getitem OBJECT \"ATTRIBUTE\"): return the Python ATTRIBUTE of an OBJECT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(getitem #(1 2 3) 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(getitem (dict '((a 100))) 'a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<built-in method keys of dict object at 0x7f0338b1e648>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(getitem (globals) \"keys\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## globals\n",
    "(globals): get global Python environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"apply_proc\" \"apply_prim\" \"GLOBALS\" \"assignment_q_hat\" \"apply_macro\" \"_staruse_stack_trace_star\" \"LessThan\" \"ap_reg\" \"assq_prim\" \"append_all\" \"ap1_reg\" \"association_q\" \"association_q_hat\" \"adatum_reg\" \"apply_action\" \"amacro_error\" \"append_prim\" \"action_reg\" \"__doc__\" \"abs_prim\" \"apair_q\" \"atom_tag\" \"_starreader_generates_annotated_sexps_q_star\" \"append\" \"_starneed_newline_star\" \"Symbol\" \"apply_cont2\" \"assv_prim\" \"application_q_hat\" \"aparse_sexps\" \"__spec__\" \"__version__\" \"REP_fail\" \"apply_fail\" \"Apply\" \"apply_star\" \"Range\" \"apply_cont\" \"abort_prim\" \"anything_q\" \"GreaterThanEqual\" \"DebugException\" \"__loader__\" \"GreaterThan\" \"Char\" \"apply_cont3\" \"__name__\" \"aparse\" \"PY3\" \"CHARS\" \"atom_q_prim\" \"__builtins__\" \"SYMBOLS\" \"apply_handler\" \"app_aexp\" \"SCHEMEPATH\" \"args_reg\" \"append2\" \"apply_sub_hat\" \"add_binding\" \"Vector\" \"apply_comparison\" \"annotated_q\" \"all_numeric_q\" \"avar_reg\" \"aclauses_reg\" \"_starlast_fail_star\" \"_startracing_on_q_star\" \"Map\" \"association_aexp\" \"_startokens_left_star\" \"assv\" \"_trace_pause\" \"apply_state\" \"_staruse_lexical_address_star\" \"annotate_cps\" \"__file__\" \"assq\" \"aparse_error\" \"atom_q\" \"ax_reg\" \"ENVIRONMENT\" \"assign_aexp\" \"Iterable\" \"apair2_reg\" \"REP_handler\" \"apply_cont4\" \"adatum_list_reg\" \"__package__\" \"aatom_q\" \"association\" \"REP_k\" \"_closure_depth\" \"and_transformer_hat\" \"List\" \"apair1_reg\" \"__cached__\" \"apply_handler2\" \"apattern_q\" \"ap2_reg\" \"aparse_all\" \"at_hat\" \"aunparse\" \"atom_q_hat\" \"all_char_q\" \"LessThanEqual\" \"_starstack_trace_star\")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define-syntax collect\n",
    "  [(collect ?exp for ?var in ?list)\n",
    "   (filter-map (lambda (?var) ?exp) (lambda (?var) #t) ?list)]\n",
    "  [(collect ?exp for ?var in ?list if ?condition)\n",
    "   (filter-map (lambda (?var) ?exp) (lambda (?var) ?condition) ?list)])\n",
    "\n",
    "(define filter-map\n",
    "  (lambda (f pred? values)\n",
    "    (if (null? values)\n",
    "      '()\n",
    "      (if (pred? (car values))\n",
    "          (cons (f (car values)) (filter-map f pred? (cdr values)))\n",
    "          (filter-map f pred? (cdr values))))))\n",
    "\n",
    "(collect x for x in (map (lambda (n) n) ((getitem (globals) \"keys\"))) if (string<? x \"b\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import\n",
    "\n",
    "Use import, import-from, and import-as to load Python libraries. Use load and load-as to load Scheme files.\n",
    "\n",
    "(import MODULE...): import host-system modules; MODULEs are strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(math)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try \n",
    "    (import \"math\")\n",
    "(catch e e \n",
    "    (import \"Graphics\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8253356149096783"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(math.cos 0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import-as\n",
    "\n",
    "Use import, import-from, and import-as to load Python libraries. Use load and load-as to load Scheme files.\n",
    "\n",
    "(import-as MODULE NAME): import a host-system module; MODULE is a string, and NAME is a symbol or string. Use * for NAME to import into toplevel environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(m)"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import-as \"math\" 'm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5646424733950354"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(m.sin 0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import-from\n",
    "\n",
    "Use import, import-from, and import-as to load Python libraries. Use load and load-as to load Scheme files.\n",
    "\n",
    "(import-from MODULE NAME...): import from host-system module; MODULE is a string, and NAME is a symbol or string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(sin cos)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import-from \"math\" \"sin\" \"cos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.479425538604203"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(sin .5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## int\n",
    "(int NUMBER): return NUMBER as an integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int 4.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## integer->char\n",
    "(integer->char INTEGER): return the assocated character of INTEGER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#\\N"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(integer->char 78)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## iter?\n",
    "(iter? ITEM): return #t if ITEM is a iterator, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(iter? 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define g (globals))\n",
    "(iter? (g.keys))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## lambda\n",
    "\n",
    "(lambda (VARIABLE...) BODY)  \n",
    "(lambda VARIABLE BODY) - called mu-lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<procedure>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda (n) n) ;; identity function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "89"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (i) i) 89)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### mu-lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3 4 5)"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda x x) 1 2 3 4 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 (2 3 4 5))"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (x . y) (list x y)) 1 2 3 4 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 (3 4 5))"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b . z) (list a b z)) 1 2 3 4 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 (3))"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b . z) (list a b z)) 1 2 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 ())"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b . z) (list a b z)) 1 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"not enough arguments given\""
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try ((lambda (a b . z) (list a b z)) 1)\n",
    "   (catch e e \"not enough arguments given\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## length\n",
    "(length LIST): returns the number of elements in top level of LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(length '(1 2 3 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## let\n",
    "(let ((VARIABLE VALUE)...) BODY): define variables with a scope in BODY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#3(1 2 a)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((v (vector 1 2 3))) \n",
    "  (vector-set! v 2 'a) \n",
    "  v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "blastoff!"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (let loop ((n 5))\n",
    "            n\n",
    "            (if (= n 0)\n",
    "                (raise 'blastoff!))\n",
    "            (loop (- n 1)))\n",
    "(catch e e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## let*\n",
    "(let* ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let* ((a 1) (b a))\n",
    "  b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## letrec\n",
    "(letrec ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(letrec \n",
    "  ((fact (lambda (n)\n",
    "           (if (= n 1)\n",
    "               1\n",
    "               (* (fact (- n 1)) n)))))\n",
    "  (fact 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list\n",
    "(list ITEM ...): returns a list composed of all of the items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3 4)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(list 1 2 3 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list->string\n",
    "(list->string LIST): returns the LIST as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"12\""
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(list->string '(#\\1 #\\2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list->vector\n",
    "(list->vector LIST): returns the LIST as a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#3(1 2 3)"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(list->vector '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list-ref\n",
    "(list-ref LIST INDEX): returns the item in LIST at INDEX (zero-based)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(list-ref '(1 2 3) 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list?\n",
    "(list? ITEM): return #t if ITEM is a list, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(list? 123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## load\n",
    "(load FILENAME...): loads the given FILENAMEs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sllgen.ss 2000-09-25 11:48\n"
     ]
    }
   ],
   "source": [
    "(load \"sllgen.ss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## load-as\n",
    "(load-as FILENAME MODULE-NAME): load the filename, putting items in MODULE-NAME namespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sllgen.ss 2000-09-25 11:48\n"
     ]
    }
   ],
   "source": [
    "(load-as \"sllgen.ss\" 'sll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<environment>"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## make-set\n",
    "(make-set LIST): returns a list of unique items from LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(make-set '(1 2 3 1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## make-vector\n",
    "(make-vector LENGTH): returns a vector of length LENGTH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#8(0 0 0 0 0 0 0 0)"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(make-vector 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## map\n",
    "(map PROCEDURE LIST...): apply PROCEDURE to each element of LIST; like for-each but returns results.\n",
    "\n",
    "`map` and `for-each` can iterate over lists and Python iterators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5 6 7)"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(map (lambda (n) (+ n 2)) '(3 4 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<void> <void> <void>)"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(map (lambda (n) (print n)) '(3 4 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## max\n",
    "(max ...): returns the maximum value from the list of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(max (range 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## member\n",
    "(member ITEM LIST): return LIST if ITEM in top level of LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(member 10 (range 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0 1 2 3 4 5 6 7 8 9)"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(member 0 (range 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"b\" \"c\")"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(member \"b\" '(\"a\" \"b\" \"c\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## memq\n",
    "(memq ITEM LIST): check for member using eq? in LIST. Returns entire list if found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(b c)"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(memq 'b '(a b c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(memq 2 '(1.0 2.0 3.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## memv\n",
    "(memv ITEM LIST): check for member using eqv? in LIST. Returns entire list if found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0 3.0)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(memv 2 '(1.0 2.0 3.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## min\n",
    "(min ...): returns the minimum value from the list of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(min (range 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## mod\n",
    "(mod arg0 arg1): modulo procedure for two arguments (aliases % and modulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(mod 7 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## modulo\n",
    "(modulo arg0 arg1): modulo procedure for two arguments (aliases mod and %)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(modulo 7 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## newline\n",
    "(newline): displays a new line in output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "(newline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## not\n",
    "(not ITEM): returns the boolean not of ITEM; ITEM is only #t when #t, otherwise #f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(not #f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(not #t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## null?\n",
    "(null? ITEM): return #t if ITEM is empty list, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(null? '())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(null? '(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## number->string\n",
    "(number->string NUMBER): return NUMBER as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"76.23\""
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(number->string 76.23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## number?\n",
    "(number? ITEM): return #t if ITEM is a number, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(number? 7623.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## odd?\n",
    "(odd? NUMBER): returns #t if NUMBER is even, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(odd? 65)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## or\n",
    "(or ITEM...)\n",
    "\n",
    "`or` is defined via a macro (define-syntax)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(or #t (/ 8 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pair?\n",
    "(pair? ITEM): returns #t if ITEM is a cons cell (a proper or improper list). Note that the empty list is a symbol, but not an actual list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pair? '())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pair? (cons 1 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## parse\n",
    "(parse LIST): parse a list; returns Abstract Syntax Tree (AST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(app-aexp (lexical-address-aexp 0 1 + none) ((lit-aexp 2 none) (lit-aexp 3 none)) none)"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(parse '(+ 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## parse-string\n",
    "(parse-string STRING): parse a string; returns Abstract Syntax Tree (AST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(app-aexp (lexical-address-aexp 0 1 + (stdin 1 2 2 1 2 2)) ((lit-aexp 1 (stdin 1 4 4 1 4 4)) (lit-aexp 2 (stdin 1 6 6 1 6 6))) (stdin 1 1 1 1 7 7))"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(parse-string \"(+ 1 2)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## print\n",
    "(print ITEM): output the ITEM as if by write (alias for write)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"this string\"\n"
     ]
    }
   ],
   "source": [
    "(print \"this string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## printf\n",
    "(printf FORMAT ARGS...): formatted print. Uses standard scheme formatting symbols:\n",
    "\n",
    "* ~a - shown as if by display\n",
    "* ~s - shown as if by write\n",
    "* ~% - newline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "many possible things \"and etc\""
     ]
    }
   ],
   "source": [
    "(printf \"many possible ~a ~s\" 'things \"and etc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## procedure?\n",
    "(procedure? ITEM): return #t if ITEM is a procedure, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(procedure? procedure?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## property\n",
    "\n",
    "Create a Python property. Under development for creating Python classes from Scheme.\n",
    "\n",
    "(property NAME VALUE): "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python-eval\n",
    "(python-eval PYTHON-EXPRESSION [globals [locals]]): return the result of evaluating PYTHON-EXPRESSION string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(python-eval \"1 + 4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python-exec\n",
    "(python-exec PYTHON-STATEMENTS [globals [locals]]): return the result of evaluating PYTHON-STATEMENTS string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "(python-exec \n",
    "\"\n",
    "x = 1\n",
    "print(x)\n",
    "\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## quasiquote\n",
    "(quasiquote LIST): quasiquote allows commas in front of expressions in a list which will be evaluated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(list 3 4)"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`(list ,(+ 1 2) 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## quote\n",
    "\n",
    "(quote ITEM): treat ITEM as a literal (data). Can also be written as the single-quote mark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(quote (1 2 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'(1 2 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#3(1 2 3)"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'#(1 2 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#2(1 6)"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`#(1 ,(+ 2 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## quotient\n",
    "(quotient arg0 arg1): quotient procedure for rationals/ints; divides arg0 by arg1 (aliases // and div)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(quotient 7 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## rac\n",
    "(rac LIST): return the last item of LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rac '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## range\n",
    "(range END), (range START END), or (RANGE START END STEP): (all integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0 1 2 3 4 5 6 7 8 9)"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(range 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## rational\n",
    "(rational NUMERATOR DENOMINTAOR): return a rational number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3/4"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rational 3 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## rdc\n",
    "(rdc LIST): return everything but last item in LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2)"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rdc '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## raise\n",
    "\n",
    "See try/catch/finally for examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## read-string\n",
    "(read-string LIST): returns low-level format used in read. Not generally useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((pair) ((atom) 1 (stdin 1 2 2 1 2 2)) ((pair) ((atom) 2 (stdin 1 4 4 1 4 4)) ((pair) ((atom) 3 (stdin 1 6 6 1 6 6)) ((atom) () none) none) none) (stdin 1 1 1 1 7 7))"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(read-string '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## record-case\n",
    "(record-case RECORD CASES): match a record to a sequence of CASES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((6) orange 5)"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(record-case (cons 'banana (cons 'orange (cons (* 2 3) '())))\n",
    "    (apple (a b c) (list c b a r))\n",
    "    ((cherry banana) (a . b) (list b a 5))\n",
    "    ((orange) () 'no)\n",
    "    (else 2 3 4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## remainder\n",
    "(remainder NUMBER1 NUMBER2): returns the remainder after dividing NUMBER1 by NUMBER2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(remainder 6 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## require\n",
    "(require EXPR): require something to be true. Used with (choose)\n",
    "\n",
    "See choose for example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## reset-toplevel-env\n",
    "(reset-toplevel-env): reset the toplevel environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(reset-toplevel-env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## reverse\n",
    "(reverse LIST): return the top-level items in a list in reverse order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3 2 1)"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(reverse '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## round\n",
    "(round NUMBER): round NUMBER to the nearest integer (may return float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(round 34.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## set!\n",
    "(set! VARIABLE VALUE): set a variable to a value\n",
    "\n",
    "Note that for objects, you currently need to:\n",
    "\n",
    "```scheme\n",
    "(setitem OBJ \"PROPERTY\" VALUE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(define x 12)\n",
    "(set! x 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## set-car!\n",
    "(set-car! LIST ITEM): set the car of LIST to be ITEM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7 2 3)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define a '(1 2 3))\n",
    "(set-car! a 7)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## set-cdr!\n",
    "(set-cdr! LIST ITEM): set the car of LIST to be ITEM (which is typically a list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 4 5)"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define a '(1 2 3))\n",
    "(set-cdr! a '(4 5))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## setitem\n",
    "(setitem DICTIONARY ITEM VALUE): sets DICTIONARY[ITEM] with VALUE and returns it  \n",
    "(setitem VECTOR POSITION VALUE): sets VECTOR[POSITION] with VALUE and returns it  \n",
    "(setitem OBJ \"PROPERTY\" VALUE): sets OBJ.PROPERY with VALUE, and returns it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(conx)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import \"conx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(setitem conx \"x\" 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(getitem conx \"x\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conx.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{a: 1, b: 6}"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(define d (dict '((a 1)(b 2))))\n",
    "(setitem d 'b 6)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## snoc\n",
    "(snoc ITEM LIST): cons the ITEM onto the end of LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3 0)"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(snoc '0 '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sort\n",
    "(sort PROCEDURE LIST): sort the list using PROCEDURE to compare items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0 1 2 2 3 6 9)"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(sort (lambda (a b) (< a b)) '(9 6 2 3 1 2 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0 1 2 2 3 6 9)"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(sort < '(9 6 2 3 1 2 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sqrt\n",
    "(sqrt NUMBER): return the square root of NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(sqrt 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string\n",
    "(string ITEM): returns ITEM as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\t\""
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string #\\tab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string->list\n",
    "(string->list STRING): string STRING as a list of characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#\\h #\\e #\\l #\\l #\\o #\\space #\\w #\\o #\\r #\\l #\\d #\\!)"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string->list \"hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string->number\n",
    "(string->number STRING): return STRING as a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.3"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string->number \"23.3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string->symbol\n",
    "(string->symbol STRING): return STRING as a symbol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "apple"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string->symbol \"apple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string-append\n",
    "(string-append STRING1 STRING2): append two strings together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"abc123\""
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string-append \"abc\" \"123\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string-length\n",
    "(string-length STRING): returns the length of a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string-length \"how long?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string-ref\n",
    "(string-ref STRING INDEX): return the character of STRING at position INDEX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#\\1"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string-ref \"0123\" 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string-split\n",
    "(string-split STRING CHAR): return a list with substrings of STRING where split by CHAR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"1\" \"34\")"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string-split \"1234\" #\\2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string<?\n",
    "(string<? STRING1 STRING2): compare two strings to see if STRING1 is less than STRING2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string<? \"apple\" \"zebra\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string=?\n",
    "(string=? STRING1 STRING2): return #t if STRING1 is the same as STRING2, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string=? \"apple\" \"apple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## string?\n",
    "(string? ITEM): return #t if ITEM is a string, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(string? 'apple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## substring\n",
    "(substring STRING START [END]): return the substring of STRING starting with position START and ending before END. If END is not provided, it defaults to the length of the STRING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"12\""
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(substring \"01234\" 1 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## symbol\n",
    "(symbol STRING): turn STRING into a symbol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "apple"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(symbol \"apple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## symbol->string\n",
    "(symbol->string SYMBOL): return SYMBOL as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"apple\""
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(symbol->string 'apple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## symbol?\n",
    "(symbol? ITEM): return #t if ITEM is a symbol, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(symbol? \"apple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## try/catch/finally\n",
    "(try ... catch ...): attempt to execute an expression, with a method of catching errors, and running code at end regardless of outcome. Note that the finally clause runs, but the return value comes from try or catch. See below for examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can't do that!"
     ]
    }
   ],
   "source": [
    "(try \n",
    "    (/ 1 0)\n",
    "(catch e e \n",
    "    (printf \"Can't do that!\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try 3 \n",
    "(finally (define did-it #t)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "did-it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n",
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(\"RunTimeError\" \"division by zero\" \"In [32]\" 1 6 ((\"In [32]\" 1 6 /)))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (/ 3 0)\n",
    "     (catch e e)\n",
    "     (finally (print 'yes 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "yes"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (raise 'yes) \n",
    "(catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "yes"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (try (raise 'yes)) \n",
    "(catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "oops"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (try (begin 'one (raise 'oops) 'two)) \n",
    "(catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (try (begin 'one (raise 'oops) 'two)\n",
    "      (catch ex 3 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (try (begin 'one 'two 5)\n",
    "      (catch ex 3 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(* 10 (try (begin 'one (raise 'oops) 5)\n",
    "      (catch ex (list 'ex: ex) 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "oops"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (* 10 (try (begin 'one (raise 'oops) 5)\n",
    "           (catch ex (list 'ex: ex) (raise ex) 4))) \n",
    "(catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two\n",
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "oops"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (* 10 (try (begin 'one (raise 'oops) 5)\n",
    "              (catch ex (list 'ex: ex) (raise ex) 4)\n",
    "              (finally (print 'two 7))))\n",
    "     (catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "77"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (* 10 (try (begin 'one (raise 'oops) 5)\n",
    "              (catch ex (list 'ex: ex) (raise 'bar) 4)))\n",
    "   (catch x 'hello 77))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n",
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try 3 \n",
    "     (finally (print 'hi 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"division by zero\""
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (div 10 0) \n",
    "     (catch e (cadr e)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"division by zero\""
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (let ((x \n",
    "            (try (div 10 0)))) x) \n",
    "     (catch e (cadr e)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((x (try (div 10 2) \n",
    "              (catch e -1)))) x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((x \n",
    "       (try (div 10 0) \n",
    "            (catch e -1)))) x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "closing-files\n",
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((x (try (div 10 2) \n",
    "              (catch e -1) \n",
    "              (finally (print 'closing-files 42)))))  x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "closing-files\n",
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((x (try (div 10 0) \n",
    "              (catch e -1) \n",
    "              (finally (print 'closing-files 42)))))  x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "closing-files\n",
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((x (try (div 10 2) \n",
    "              (finally (print 'closing-files 42)))))  x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "closing-files\n",
      "42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "foo"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (let ((x (try (div 10 0) \n",
    "                   (catch e -1 (raise 'foo)) \n",
    "                   (finally (print 'closing-files 42)))))  x) (catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ack"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (let ((x (try (div 10 0)\n",
    "        (catch e -1 (raise 'foo))\n",
    "        (finally (print 'closing-files (raise 'ack) 42)))))\n",
    "x) (catch e e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "closing-outer-files\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (let ((x (try (div 10 0)\n",
    "             (catch e -1 (raise 'foo))\n",
    "             (finally (print 'closing-files (raise 'ack) 42)))))\n",
    "    x)\n",
    "(catch e (if (equal? e 'ack) 99 (raise 'doug)))\n",
    "(finally (print 'closing-outer-files)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "closing-outer-files\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "doug"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(try (try (let ((x (try (div 10 0)\n",
    "             (catch e -1 (raise 'foo))\n",
    "             (finally 'closing-files (raise 'ack) 42))))\n",
    "    x)\n",
    "(catch e (if (equal? e 'foo) 99 (raise 'doug)))\n",
    "(finally (print 'closing-outer-files))) (catch e e))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## typeof\n",
    "(typeof ITEM): returns type of ITEM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class 'float'>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(typeof 23.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## unparse\n",
    "(unparse AST): given an AST, turn it back into Scheme code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(+ 1 2)"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(unparse (parse '(+ 1 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## unparse-procedure\n",
    "(unparse-procedure PROCEDURE): given a procedure, show the body as Scheme code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(+ x 1)"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(unparse-procedure (lambda (x) (+ x 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## use-lexical-address\n",
    "(use-lexical-address [BOOLEAN]): get lexical-address setting, or set it on/off if BOOLEAN is given"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(use-lexical-address #t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## use-stack-trace\n",
    "(use-stack-trace BOOLEAN): set stack-trace usage on/off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(use-stack-trace #t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## use-tracing\n",
    "(use-tracing [BOOLEAN]): get tracing setting, or set it on/off if BOOLEAN is given"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(use-tracing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call: (define fact (lambda (n) (if (= n 1) 1 (* n (fact (- n 1))))))\n",
      "call: (lambda (n) (if (= n 1) 1 (* n (fact (- n 1)))))\n",
      "(lambda (n) (if (= n 1) 1 (* n (fact (- n 1))))) => #<procedure>\n",
      "(define fact (lambda (n) (if (= n 1) 1 (* n (fact (- n 1)))))) => <void>\n",
      "call: (fact 1)\n",
      "call: 1\n",
      "1 => 1\n",
      "call: fact\n",
      "fact => #<procedure>\n",
      "call: (if (= n 1) 1 (* n (fact (- n 1))))\n",
      "call: (= n 1)\n",
      "call: n\n",
      "n => 1\n",
      "call: 1\n",
      "1 => 1\n",
      "call: =\n",
      "= => #<procedure>\n",
      "(= n 1) => #t\n",
      "call: 1\n",
      "1 => 1\n",
      "(if (= n 1) 1 (* n (fact (- n 1)))) => 1\n",
      "(fact 1) => 1\n",
      "call: (use-tracing #f)\n",
      "call: #f\n",
      "#f => #f\n",
      "call: use-tracing\n",
      "use-tracing => #<procedure>\n",
      "(use-tracing #f) => <void>\n"
     ]
    }
   ],
   "source": [
    "(use-tracing #t)\n",
    "(define fact\n",
    "    (lambda (n)\n",
    "      (if (= n 1)\n",
    "           1\n",
    "           (* n (fact (- n 1))))))\n",
    "(fact 1)\n",
    "(use-tracing #f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## vector\n",
    "(vector [ITEMS]...): return ITEMs as a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#3(1 2 6)"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(vector 1 2 (+ 3 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## vector->list\n",
    "(vector->list VECTOR): return VECTOR as a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(vector->list #(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## vector-length\n",
    "(vector-length VECTOR): returns length of VECTOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(vector-length #(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## vector-ref\n",
    "(vector-ref VECTOR INDEX): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(vector-ref #(1 2 3) 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## vector-set!\n",
    "(vector-set! VECTOR INDEX VALUE): sets the item at INDEX of VECTOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#3(1 4 3)"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let ((v #(1 2 3)))\n",
    "  (vector-set! v 1 4)\n",
    "  v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## vector?\n",
    "(vector? ITEM): return #t if ITEM is a vector, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#f"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(vector? '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## void\n",
    "(void): The null value symbol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(void)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## zero?\n",
    "(zero? NUMBER): return #t if NUMBER is equal to zero, #f otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#t"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(zero? 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Work in progress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Named parameters and defaults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 281,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda ((n : 1)) n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda ((n : 2)) n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda ((n : 1)) n) 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b c) (list a b c)) 1 2 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b c) (list a b c)) 1 2 (c : 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b c) (list a b c)) 1 (b : 2) (c : 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b c) (list a b c)) (a : 1) (b : 2) (c : 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1 2 3)"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda (a b c) (list a b c)) 1 (c : 3) (b : 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((lambda ((n : 1)) n) (n : 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Missing functions common in other Scheme implementations\n",
    "\n",
    "The following items are currently missing from Calysto Scheme. However, much of their functionality can be achieved by using Python versions. For example you can use the Python `bin` function to create a binary representation, since the Scheme `binary` predicate has not been defined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Exponents\n",
    "* angle\n",
    "* binary\n",
    "* bytevector?\n",
    "* ceiling\n",
    "* char-ci<=?\n",
    "* char-ci<?\n",
    "* char-ci=?\n",
    "* char-ci>=?\n",
    "* char-ci>?\n",
    "* char-downcase\n",
    "* char-titlecase\n",
    "* char-upcase\n",
    "* char<=?\n",
    "* char<?\n",
    "* char>=?\n",
    "* char>?\n",
    "* complex?\n",
    "* cons*\n",
    "* cos\n",
    "* denominator\n",
    "* div-and-mod\n",
    "* div0\n",
    "* div0-and-mod0\n",
    "* exact\n",
    "* exact->inexact\n",
    "* exact-integer-sqrt\n",
    "* exact?\n",
    "* exp\n",
    "* file-exists\n",
    "* filter\n",
    "* find\n",
    "* finite?\n",
    "* floor\n",
    "* gcd\n",
    "* hashtable?\n",
    "* hexadecimal\n",
    "* imag-part\n",
    "* inexact\n",
    "* inexact->exact\n",
    "* inexact?\n",
    "* inifinite?\n",
    "* integer->char\n",
    "* integer-valued?\n",
    "* integer?\n",
    "* lcm\n",
    "* list-sort\n",
    "* list-tail\n",
    "* log\n",
    "* magnitude\n",
    "* make-polar\n",
    "* make-rectangular\n",
    "* make-string\n",
    "* mod0\n",
    "* nan?\n",
    "* negative?\n",
    "* numbers\n",
    "* numerator\n",
    "* octal\n",
    "* partition\n",
    "* positive?\n",
    "* rational-valued?\n",
    "* rational?\n",
    "* rationalize\n",
    "* real-part\n",
    "* real-valued?\n",
    "* real?\n",
    "* remove\n",
    "* remp\n",
    "* remq\n",
    "* remv\n",
    "* sin\n",
    "* string-set!\n",
    "* tan\n",
    "* truncate"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Calysto Scheme 3",
   "language": "scheme",
   "name": "calysto_scheme"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "scheme"
   },
   "mimetype": "text/x-scheme",
   "name": "scheme",
   "pygments_lexer": "scheme"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}