inductive-data-types-lab.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Lab: Recursion, Inductive Data Types, and Abstract Syntax Trees\n",
        "\n",
        "<!-- 3 Expressions -->\n",
        "\n",
        "<!-- 4 Binding and Scope -->\n",
        "\n",
        "<!-- 8 Recursion -->\n",
        "\n",
        "<!-- 9 Inductive Data Types -->\n",
        "\n",
        "### Learning Goals\n",
        "\n",
        "The primary learning goals of this assignment are to build intuition for\n",
        "the following:\n",
        "\n",
        "Functional Programming Skills  \n",
        "Representing data structures using algebraic data types.\n",
        "\n",
        "Programming Languages Ideas  \n",
        "Representing programs as abstract syntax.\n",
        "\n",
        "### Instructions\n",
        "\n",
        "A version of project files for this lab resides in the public\n",
        "[pppl-lab1](https://github.com/csci3155/pppl-lab1) repository. Please\n",
        "follow separate instructions to get a private clone of this repository\n",
        "for your work.\n",
        "\n",
        "You will be replacing `???` in the `Lab1.scala` file with solutions to\n",
        "the coding exercises described below. Make sure that you remove the\n",
        "`???` and replace it with the answer.\n",
        "\n",
        "You may add additional tests to the `Lab1Spec.scala` file. In the\n",
        "`Lab1Spec.scala`, there is empty test class `Lab1StudentSpec` that you\n",
        "can use to separate your tests from the given tests in the `Lab1Spec`\n",
        "class. You are also likely to edit `Lab1.worksheet.sc` for any scratch\n",
        "work.\n",
        "\n",
        "Single-file notebooks are convenient when experimenting with small bits\n",
        "of code, but they can become unwieldy when one needs a multiple-file\n",
        "project instead. In this case, we use standard build tools (e.g., `sbt`\n",
        "for Scala), IDEs (e.g., Visual Studio Code with Metals), and source\n",
        "control systems (e.g., `git` with GitHub). While it is almost overkill\n",
        "to use these standard software engineering tools for this lab, we get\n",
        "practice using these tools in the small.\n",
        "\n",
        "If you like, you may use this notebook for experimentation. However,\n",
        "**please make sure your code is in `Lab1.scala`; this notebook will not\n",
        "graded.**\n",
        "\n",
        "## Recursion\n",
        "\n",
        "### Repeat String\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 1**</span> Write a recursive\n",
        "function `repeat`"
      ],
      "id": "92f9e633-98c1-40cf-b3d4-aaa22299cc07"
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">repeat</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def repeat(s: String, n: Int): String = ???"
      ],
      "id": "f7013900"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "where `repeat(s, n)` returns a string with `n` copies of `s`\n",
        "concatenated together. For example, `repeat(\"a\",3)` returns `\"aaa\"`.\n",
        "Implement by this function by direct recursion. Do not use any Scala\n",
        "library methods.\n",
        "\n",
        "### Square Root\n",
        "\n",
        "In this exercise, we will implement the square root function. To do so,\n",
        "we will use Newton’s method (also known as Newton-Raphson).\n",
        "\n",
        "Recall from Calculus that a root of a differentiable function can be\n",
        "iteratively approximated by following tangent lines. More precisely, let\n",
        "$f$ be a differentiable function, and let $x_0$ be an initial guess for\n",
        "a root of $f$. Then, Newton’s method specifies a sequence of\n",
        "approximations $x_0, x_1, \\ldots$ with the following recursive equation:\n",
        "\n",
        "$$\n",
        "x_{n + 1} = x_n - \\frac{f(x_n)}{f'(x_n)}\n",
        "\\;.$$\n",
        "\n",
        "The square root of a real number $c$ for $c > 0$, written $\\sqrt{c}$, is\n",
        "a positive $x$ such that $x^2 = c$. Thus, to compute the square root of\n",
        "a number $c$, we want to find the positive root of the function: $$\n",
        "f(x) = x^2 - c\n",
        "\\;.$$ Thus, the following recursive equation defines a sequence of\n",
        "approximations for $\\sqrt{c}$: $$\n",
        "x_{n + 1} = x_n - \\frac{x_n^2 - c}{2 x_n}\n",
        "\\;.$$\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 2**</span> First, implement a\n",
        "function `sqrtStep`"
      ],
      "id": "ece5f8df-de5f-477f-9ead-16f6d9fa4b14"
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">sqrtStep</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def sqrtStep(c: Double, xn: Double): Double = ???"
      ],
      "id": "c539e344"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "that takes one step of approximation in computing $\\sqrt{c}$ (i.e.,\n",
        "computes $x_{n + 1}$ from $x_n$).\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 3**</span> Next, implement a\n",
        "function `sqrtN`"
      ],
      "id": "64c433e8-cb3d-48bd-a462-5fe64faec136"
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">sqrtN</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def sqrtN(c: Double, x0: Double, n: Int): Double = ???"
      ],
      "id": "9bb776bd"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "that computes the $n$th approximation $x_n$ from an initial guess $x_0$.\n",
        "You will want to call `sqrtStep` implemented in the previous part.\n",
        "\n",
        "You need to implement this function using recursion and no mutable\n",
        "variables (i.e., `var`s)—you will want to use a recursive helper\n",
        "function. It is also quite informative to compare your recursive\n",
        "solution with one using a `while` loop.\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 4**</span> Now, implement a\n",
        "function `sqrtErr`"
      ],
      "id": "f1a4b424-2ed8-4002-8c2b-5346eee0e41b"
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">sqrtErr</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def sqrtErr(c: Double, x0: Double, epsilon: Double): Double = ???"
      ],
      "id": "5bfde3b8"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "that is very similar to `sqrtN` but instead computes approximations\n",
        "$x_n$ until the approximation error is within $\\varepsilon$ (`epsilon`),\n",
        "that is, $|x_n^2 - c| < \\varepsilon \\;.$ You can use your absolute value\n",
        "function `abs` implemented in a previous part. A wrapper function `sqrt`\n",
        "is given in the template that simply calls `sqrtErr` with a choice of\n",
        "`x0` and `epsilon`.\n",
        "\n",
        "You need to implement this function using recursion, though it is useful\n",
        "to compare your recursive solution to one with a `while` loop.\n",
        "\n",
        "## Data Structures Review: Binary Search Trees\n",
        "\n",
        "In this question, we review implementing operations on binary search\n",
        "trees from Data Structures. Balanced binary search trees are common in\n",
        "standard libraries to implement collections, such as sets or maps. For\n",
        "simplicity, we do not worry about balancing in this question.\n",
        "\n",
        "Trees are important structures in developing interpreters, so this\n",
        "question is also critical practice in implementing tree manipulations.\n",
        "\n",
        "A binary search tree is a binary tree that satisfies an ordering\n",
        "invariant. Let $n$ be any node in a binary search tree whose left child\n",
        "is $l$, data value is $d$, and right child is $r$. The ordering\n",
        "invariant is that all of the data values in the subtree rooted at $l$\n",
        "must be $< d$, and all of the data values in the subtree rooted at $r$\n",
        "must be $\\geq d$. We will represent a binary trees containing integer\n",
        "data using the following Scala `case class`es:"
      ],
      "id": "8d9b3bb9-eb9b-475f-a0ed-de8fc18b4bb7"
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">trait</span> <span class=\"ansi-cyan-fg\">Tree</span>\n",
              "defined <span class=\"ansi-green-fg\">object</span> <span class=\"ansi-cyan-fg\">Empty</span>\n",
              "defined <span class=\"ansi-green-fg\">class</span> <span class=\"ansi-cyan-fg\">Node</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "sealed trait Tree\n",
        "case object Empty extends Tree\n",
        "case class Node(l: Tree, d: Int, r: Tree) extends Tree"
      ],
      "id": "d3700708"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "A `Tree` is either `Empty` or a `Node` with left child `l`, data value\n",
        "`d`, and right child `r`.\n",
        "\n",
        "For this question, we will implement the following four functions.\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 5**</span> The function `repOk`"
      ],
      "id": "9649819f-34ea-4195-bfcf-fa944863f935"
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">repOk</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def repOk(t: Tree): Boolean = {\n",
        "  def check(t: Tree, min: Int, max: Int): Boolean = t match {\n",
        "    case Empty => true\n",
        "    case Node(l, d, r) => ???\n",
        "  }\n",
        "  check(t, Int.MinValue, Int.MaxValue)\n",
        "}"
      ],
      "id": "2d4949ff"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "checks that an instance of `Tree` is valid binary search tree. In other\n",
        "words, it checks using a traversal of the tree the ordering invariant\n",
        "described above. This function is useful for testing your\n",
        "implementation.\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 6**</span> The function `insert`"
      ],
      "id": "54710b04-2f5c-49aa-9562-c729c52ac152"
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">insert</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def insert(t: Tree, n: Int): Tree = ???"
      ],
      "id": "5792d194"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "inserts an integer into the binary search tree. Observe that the return\n",
        "type of `insert` is a `Tree`. This choice suggests a functional style\n",
        "where we construct and return a new output tree that is the input tree\n",
        "`t` with the additional integer `n` as opposed to destructively updating\n",
        "the input tree.\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 7**</span> The function\n",
        "`deleteMin`"
      ],
      "id": "e11a2e5f-8805-4156-b997-e118f16f0677"
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">deleteMin</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def deleteMin(t: Tree): (Tree, Int) = {\n",
        "  require(t != Empty)\n",
        "  (t: @unchecked) match {\n",
        "    case Node(Empty, d, r) => (r, d)\n",
        "    case Node(l, d, r) =>\n",
        "      val (l1, m) = deleteMin(l)\n",
        "      ???\n",
        "  }\n",
        "}"
      ],
      "id": "25a13b75"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "deletes the smallest data element in the search tree (i.e., the leftmost\n",
        "node). It returns both the updated tree and the data value of the\n",
        "deleted node. This function is intended as a helper function for the\n",
        "`delete` function.\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 8**</span> The function `delete`"
      ],
      "id": "3ed65074-b1f2-4368-880e-4324bc5dbf06"
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">delete</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def delete(t: Tree, n: Int): Tree = ???"
      ],
      "id": "6fe5bb5f"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "removes the first node with data value equal to `n`. This function is\n",
        "trickier than `insert` because what should be done depends on whether\n",
        "the node to be deleted has children or not. We advise that you take\n",
        "advantage of pattern matching to organize the cases.\n",
        "\n",
        "## Interpreter: JavaScripty Calculator\n",
        "\n",
        "In this question, we consider the arithmetic sub-language of JavaScripty\n",
        "(i.e., a basic calculator). We represent the abstract syntax for this\n",
        "sub-language in Scala using the following inductive data type:"
      ],
      "id": "738311cf-3d72-4276-8c78-dec80f97ddc6"
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">trait</span> <span class=\"ansi-cyan-fg\">Expr</span>\n",
              "defined <span class=\"ansi-green-fg\">class</span> <span class=\"ansi-cyan-fg\">N</span>\n",
              "defined <span class=\"ansi-green-fg\">class</span> <span class=\"ansi-cyan-fg\">Unary</span>\n",
              "defined <span class=\"ansi-green-fg\">class</span> <span class=\"ansi-cyan-fg\">Binary</span>\n",
              "defined <span class=\"ansi-green-fg\">trait</span> <span class=\"ansi-cyan-fg\">Uop</span>\n",
              "defined <span class=\"ansi-green-fg\">object</span> <span class=\"ansi-cyan-fg\">Neg</span>\n",
              "defined <span class=\"ansi-green-fg\">trait</span> <span class=\"ansi-cyan-fg\">Bop</span>\n",
              "defined <span class=\"ansi-green-fg\">object</span> <span class=\"ansi-cyan-fg\">Plus</span>\n",
              "defined <span class=\"ansi-green-fg\">object</span> <span class=\"ansi-cyan-fg\">Minus</span>\n",
              "defined <span class=\"ansi-green-fg\">object</span> <span class=\"ansi-cyan-fg\">Times</span>\n",
              "defined <span class=\"ansi-green-fg\">object</span> <span class=\"ansi-cyan-fg\">Div</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "sealed trait Expr                                            // e ::=\n",
        "case class N(n: Double) extends Expr                         //   n\n",
        "case class Unary(uop: Uop, e1: Expr) extends Expr            // | uop e1\n",
        "case class Binary(bop: Bop, e1: Expr, e2: Expr) extends Expr // | e1 bop e2\n",
        "\n",
        "sealed trait Uop              // uop ::=\n",
        "case object Neg extends Uop   //   -\n",
        "\n",
        "sealed trait Bop              // bop ::=\n",
        "case object Plus extends Bop  //   +\n",
        "case object Minus extends Bop // | -\n",
        "case object Times extends Bop // | *\n",
        "case object Div extends Bop   // | /"
      ],
      "id": "32b17391"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In comments, we give a grammar that connects the abstract syntax with\n",
        "the concrete syntax of the language. We consider grammars in more detail\n",
        "subsequently<span class=\"hidden\">in **?@sec-grammars**</span>. For now,\n",
        "it is fine to ignore the concrete syntax or use your intuition for the\n",
        "connection. ow, given the inductive data type `Expr` defining the\n",
        "abstract syntax:\n",
        "\n",
        "<span class=\"theorem-title\">**Exercise 9**</span> Implement the `eval`\n",
        "function"
      ],
      "id": "17db896e-d8f3-4697-b7e9-30a06f898152"
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">eval</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def eval(e: Expr): Double = e match {\n",
        "  case N(n) => ???\n",
        "  case _  => ???\n",
        "}"
      ],
      "id": "054fca87"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "that evaluates the Scala representation of a JavaScripty expression `e`\n",
        "to the Scala double-precision floating point number corresponding to the\n",
        "Scala representation of the JavaScripty *value* of `e`. At this point,\n",
        "you have implemented your first language interpreter!\n",
        "\n",
        "To go in more detail, consider a JavaScripty expression $e$, and imagine\n",
        "$e$ to be concrete syntax. This text is parsed into a JavaScripty AST\n",
        "`e`, that is, a Scala value of type `Expr`. Then, the result of `eval`\n",
        "is a Scala number of type `Double` and should match the interpretation\n",
        "of $e$ as a JavaScript expression. These distinctions can be subtle but\n",
        "learning to distinguish between them will go a long way in making sense\n",
        "of programming languages.\n",
        "\n",
        "To see what a JavaScripty expression $e$ should evaluate to, you may\n",
        "want to run $e$ through a JavaScript interpreter to see what the value\n",
        "should be. For example,"
      ],
      "id": "23ce5925-fdc4-4463-8c46-95f8c09f1994"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {}
        }
      ],
      "source": [
        "3 + 4"
      ],
      "id": "9cc948e3-535c-4e3d-86e6-56a39fe8e9dc"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {}
        }
      ],
      "source": [
        "1 / 7"
      ],
      "id": "5b1eefac-aef6-4734-ae00-c5a879766914"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {}
        }
      ],
      "source": [
        "6 * 4 - 2 + 10"
      ],
      "id": "4ef1f8d2-0118-4ef4-a68e-66e6fcb73c5c"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Experiment in a Worksheet\n",
        "\n",
        "Scala worksheets provide an interactive interface in the context of a\n",
        "multi-file project. A worksheet is a good place to start for\n",
        "experimenting with an implementation, whether on existing code or code\n",
        "that you are in the process of writing. A scratch worksheet\n",
        "`Lab1.worksheet.sc` is provided for you in the code repository.\n",
        "\n",
        "To test and experiment with your `eval` function, you can write\n",
        "JavaScripty expressions directly in abstract syntax like above. You can\n",
        "also make use of a parser that is provided for you: it reads in a\n",
        "JavaScripty program-as-a-`String` and converts into an abstract syntax\n",
        "tree of type `Expr`.\n",
        "\n",
        "For your convenience, we have also provided in the template `Lab1.scala`\n",
        "file, an overloaded `eval: String => Double` function that calls the\n",
        "provided parser and then delegates to your `eval: Expr => Double`\n",
        "function.\n",
        "\n",
        "### Test-Driven Development and Regression Testing\n",
        "\n",
        "Once you have experimented enough in your worksheet to have some tests,\n",
        "it is useful to save those tests to run over-and-over again as you work\n",
        "on your implementation. The idea behind test-driven development is that\n",
        "we first write a test for what we expect our implementation to do.\n",
        "Initially, we expect our implementation to fail the test, and then we\n",
        "work on our implementation until the test succeeds. IDEs have features\n",
        "to support this workflow. While a test suite can never be exhaustive, we\n",
        "have provided a number of initial tests for you in `Lab1Spec.scala` to\n",
        "partially drive your test-driven development of the functions in this\n",
        "assignment.\n",
        "\n",
        "### Additional Notes\n",
        "\n",
        "While you may not need them in this assignment, the `ast.scala` file\n",
        "also includes some basic helper functions for working with the AST, such\n",
        "as"
      ],
      "id": "e9a5acfa-ce65-4f47-bbf4-e431d5bf6a5c"
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">isValue</span>\n",
              "<span class=\"ansi-cyan-fg\">e_minus4_2</span>: <span class=\"ansi-green-fg\">N</span> = <span class=\"ansi-yellow-fg\">N</span>(n = <span class=\"ansi-green-fg\">-4.2</span>)\n",
              "<span class=\"ansi-cyan-fg\">res12_2</span>: <span class=\"ansi-green-fg\">Boolean</span> = true\n",
              "<span class=\"ansi-cyan-fg\">e_neg_4_2</span>: <span class=\"ansi-green-fg\">Unary</span> = <span class=\"ansi-yellow-fg\">Unary</span>(uop = Neg, e1 = <span class=\"ansi-yellow-fg\">N</span>(n = <span class=\"ansi-green-fg\">4.2</span>))\n",
              "<span class=\"ansi-cyan-fg\">res12_4</span>: <span class=\"ansi-green-fg\">Boolean</span> = false</pre>"
            ]
          }
        }
      ],
      "source": [
        "def isValue(e: Expr): Boolean = e match {\n",
        "  case N(_) => true\n",
        "  case _ => false\n",
        "}\n",
        "\n",
        "val e_minus4_2 = N(-4.2)\n",
        "isValue(e_minus4_2)\n",
        "\n",
        "val e_neg_4_2 = Unary(Neg, N(4.2))\n",
        "isValue(e_neg_4_2)"
      ],
      "id": "3ec9b583"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "the defines which expressions are values. In this case, literal number\n",
        "expressions `N(` $n$ `)` are values where $n$ is the meta-variable for\n",
        "JavaScripty numbers. We represent JavaScripty numbers in Scala with\n",
        "Scala values of type `Double`.\n",
        "\n",
        "We also define functions to pretty-print, that is, convert abstract\n",
        "syntax to concrete syntax:"
      ],
      "id": "62b76a67-c494-454d-b33a-e52126203895"
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre>defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">prettyNumber</span>\n",
              "defined <span class=\"ansi-green-fg\">function</span> <span class=\"ansi-cyan-fg\">pretty</span>\n",
              "<span class=\"ansi-cyan-fg\">res13_2</span>: <span class=\"ansi-green-fg\">String</span> = <span class=\"ansi-green-fg\">\"4.2\"</span>\n",
              "<span class=\"ansi-cyan-fg\">res13_3</span>: <span class=\"ansi-green-fg\">String</span> = <span class=\"ansi-green-fg\">\"10\"</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "def prettyNumber(n: Double): String =\n",
        "  if (n.isWhole) \"%.0f\" format n else n.toString\n",
        "\n",
        "def pretty(v: Expr): String = {\n",
        "  require(isValue(v))\n",
        "  (v: @unchecked) match {\n",
        "    case N(n) => prettyNumber(n)\n",
        "  }\n",
        "}\n",
        "\n",
        "pretty(N(4.2))\n",
        "pretty(N(10))"
      ],
      "id": "769e512d"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We only define `pretty` for values, and we do not override the\n",
        "`toString` method so that the abstract syntax can be printed as-is."
      ],
      "id": "2b2a871c-1da0-42ac-9850-068def51fa74"
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "output_type": "display_data",
          "metadata": {},
          "data": {
            "text/html": [
              "<pre><span class=\"ansi-cyan-fg\">res14_0</span>: <span class=\"ansi-green-fg\">String</span> = <span class=\"ansi-green-fg\">\"N(-4.2)\"</span>\n",
              "<span class=\"ansi-cyan-fg\">res14_1</span>: <span class=\"ansi-green-fg\">String</span> = <span class=\"ansi-green-fg\">\"Unary(Neg,N(4.2))\"</span></pre>"
            ]
          }
        }
      ],
      "source": [
        "e_minus4_2.toString\n",
        "e_neg_4_2.toString"
      ],
      "id": "222fbd39"
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The `@unchecked` annotation tells the Scala compiler that we know the\n",
        "pattern match is non-exhaustive syntactically, so we do not want to be\n",
        "warned about it. However, we see that our definition of `isValue` rules\n",
        "out the potential for a match error at run time (right?).\n",
        "\n",
        "## Submission\n",
        "\n",
        "If you are a University of Colorado Boulder student, we use Gradescope\n",
        "for assignment submission. In summary,\n",
        "\n",
        "-   [ ] Create a private GitHub repository by clicking on a GitHub\n",
        "    Classroom link from the corresponding Canvas assignment entry.\n",
        "-   [ ] Clone your private GitHub repository to your development\n",
        "    environment (using the `<> Code` button on GitHub to get the\n",
        "    repository URL).\n",
        "-   [ ] Work on this lab from your cloned repository. Use Git to save\n",
        "    versions on GitHub (e.g., `git add`, `git commit`, `git push` on the\n",
        "    command line or via VSCode).\n",
        "-   [ ] Submit to the corresponding Gradescope assignment entry for\n",
        "    grading by choosing GitHub as the submission method.\n",
        "\n",
        "You need to have a GitHub identity and must have your full name in your\n",
        "GitHub profile in case we need to associate you with your submissions."
      ],
      "id": "6bba5f69-742f-4b49-ba99-172564f8a9c8"
    }
  ],
  "nbformat": 4,
  "nbformat_minor": 5,
  "metadata": {
    "kernelspec": {
      "name": "scala",
      "display_name": "Scala",
      "language": "scala",
      "path": "/Users/bec/Library/Jupyter/kernels/scala"
    },
    "language_info": {
      "name": "scala",
      "codemirror_mode": "text/x-scala",
      "file_extension": ".sc",
      "mimetype": "text/x-scala",
      "nbconvert_exporter": "script",
      "version": "2.13.4"
    }
  }
}