{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Call by Value vs. Call by Reference\n", "Originally by Sriram Sankaranarayanan \n", "\n", "Modified by Ravi Mangal \n", "\n", "Last Modified: Mar 26, 2025.\n", "\n", "---\n", "\n", "With the introduction of explicit and implicit references, we will need to dive a little deeper into how function calls are handled and understand the key concepts of call by value vs. other calling conventions. Many languages provide both conventions in some form and this is something we need to understand in the context of Lettuce with mutables. \n", "\n", "As a result of this lecture, you will be able to understand some confusing aspects of languages like Scala (and Python) behave.\n", "\n", "### Scala Example 1\n", "\n", "Let us start with a simple example of a Scala program.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "defined \u001b[32mfunction\u001b[39m \u001b[36mfoo\u001b[39m\n", "\u001b[36mx\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m10\u001b[39m\n", "\u001b[36mres0_2\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m5\u001b[39m" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def foo(x: Int): Int = {\n", " if (x % 2 == 1)\n", " 3 * x + 1\n", " else \n", " x/2\n", "}\n", "\n", "val z = 10\n", "foo(z) // Function call first evals the argument and then passes the \"value\" of the arg into foo." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "The program above should return the value `5`. It is very easy to reason why. When we call `foo(x)`, the value of `x` is bound to `10`. The function `foo` is then called with the arugment `10` and the rest is easy to reason about.\n", "\n", "\n", "### Scala Program A \n", "\n", "Consider a different program where we pass a mutable var as an argument to a function.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "cmd0.sc:2: reassignment to val\n", " x = 25 // Assigns x to 25\n", " ^Compilation Failed" ] }, { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "Compilation Failed" ] } ], "source": [ "// Program A\n", "def bar(x: Int) : Int = { // Parameters to function calls are vals\n", " x = 25 // Assigns x to 25\n", " 2 * x // returns 2 * x\n", "}\n", "\n", "var z: Int = 12 // mutable z\n", "bar(z) // mutable z's value is being passed to bar." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The program above declares a __mutable__ variable `z`, assigns it to 12. When we try to pass it to the function `bar` as `x` and assign it to `25` inside `x`, it does not work. The program complains that that `x` is a `val` and cannot be reassigned. Let us try the same thing but in a different context.\n", "\n", "### Scala Program B" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before call to bar -- > w.x = 0\n", "After call to bar -- > w.x = 25\n" ] }, { "data": { "text/plain": [ "defined \u001b[32mclass\u001b[39m \u001b[36mWrapper\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mbar\u001b[39m\n", "\u001b[36mw\u001b[39m: \u001b[32mWrapper\u001b[39m = \u001b[33mWrapper\u001b[39m(\u001b[32m25\u001b[39m)\n", "\u001b[36mres0_4\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m50\u001b[39m" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "// Program B\n", "case class Wrapper(var x : Int) // field x which is mutable\n", "\n", "def bar(z: Wrapper): Int = {\n", " z.x = 25 // assigns z.x to 25\n", " 2 * z.x // return 2 * z.x\n", "}\n", "\n", "val w = Wrapper(0) // Let's create a wrapper with x initialized to 0\n", "println(\"Before call to bar -- > w.x = \" + w.x)\n", "bar(w) // w is being \"passed by value\"\n", "println(\"After call to bar -- > w.x = \" + w.x)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Something very funny is happening here: \n", " - In program A, we passed a mutable integer into a function `bar` but it refuses to reassign it and complains that we cannot reassign it.\n", " - In program B, we wrap the mutable in a `class Wrapper` and declare it/pass an instance of the wrapper `w` as a `val` but it not only allows us to reassign but also updates the value of `w.x`. \n", "\n", "We will understand this once we study things in the simple case of Lettuce." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Call By Value\n", "\n", "Call by value means that whenever we call a function on an argument,\n", "\n", "~~~\n", " funcCalled (argument)\n", "~~~\n", "\n", "the argument is (fully) evaluated and its value is passed into the function call.\n", "\n", "\n", "Consider the following Lettuce program:\n", "\n", "~~~\n", "\n", "let x = 10 in \n", " let f = function (z) \n", " 2 * z\n", " in \n", " f (x + 20)\n", "\n", "~~~\n", "\n", "There is a function call to `f` at the very last line with argument `x + 20`. The call by value semantics of Lettuce tells us to do the following:\n", "\n", "- First evaluate the argument: it evaluates to the number 30\n", "- Next, call the function on the value of the argument. \n", " - The formal parameter `z` is now `30`\n", " - The function returns a `60`.\n", " \n", " \n", "Call by value is straightforward to reason about once you understand this principle. What will the following Lettuce program evaluate to?\n", "\n", "~~~\n", "let bar = function (x) \n", " let dummy1 = assignref(x, 25) in \n", " 2 * deref(x)\n", "in \n", " let z = newref(12) in \n", " bar(z)\n", "~~~\n", "\n", "\n", "Once again there is a function call `bar(z)`. The rule for call by value is to evaluate the argument.\n", "- The value of the argument `z` is `Reference(0)`: a reference to a memory cell 0, which has the value 12 in it.\n", "- The code now executes and assigns 25 to the reference that was passed in (now bound to the formal parameter x)\n", "- As a result, the contents of the cell `0` in the memory are updated to `25`.\n", "- The result of the program is 50.\n", "\n", "\n", "In other words, call by value is able to achieve side effects when the value that is being passed in to a function is a pointer.\n", "\n", "\n", "### Scala always does call by value as default\n", "\n", "Scala supports two basic conventions: Call by value and somewhat esoteric calling conventions such as __call by name__ and __call by need__ for which you have to use special syntax. Let us ignore call by name and call by need. We will focus just on the call by value.\n", "\n", "Let us go back to program A above (recalled here):\n", "\n", "~~~\n", "def bar(x: Int) : Int = {\n", " x = 25\n", " 2 * x\n", "}\n", "\n", "var z = 12\n", "bar(z)\n", "~~~\n", "\n", "It fails for two reasons: \n", "- The parameters for functions in Scala are always vals and thus immutable. Thus the parameter `x` for function `bar` in the code above is an immutable and therefore it is not reassignable.\n", "- The value of `z` in the call to `bar(z)` is `12`. It is passed as a number `12` after it is evaluated.\n", "\n", "\n", "There are languages where this program would be accepted but still not work. eg., Python. Try the same\n", "version of the program below in Python3:\n", "\n", "~~~\n", "def bar(x): \n", " x = 25\n", " return 2 * x\n", "\n", "z = 12\n", "t = bar(z)\n", "print('t = ', t)\n", "print('z= ' , z)\n", "~~~\n", "\n", "Python will print\n", "\n", "~~~\n", "t = 50\n", "z = 12\n", "~~~\n", "\n", "In other words, in Python3, \n", "- We treat function parameters as var. Therefore, the assignment `x = 25` in the function `bar(x)` is not a problem.\n", "- However, we still do call by value. Therefore, the call `t = bar(z)` passes the value `12` and not a reference to the parameter `z`.\n", "\n", "\n", "\n", "In a similar vein, the Lettuce program with implicit refs will also fail:\n", "\n", "~~~\n", "let bar = function (x) \n", " let d1 = assignVar(x, 25) in \n", " 2 * x\n", "in \n", " let var z = 12 in \n", " bar(z)\n", "~~~\n", "\n", "In the Lettuce language with implicit references, we still do call by value. \n", "- We evaluate the argument to \n", "`bar(z)`, which looks in the abstract syntax as `FunCall( Ident(\"bar\"), Ident(\"z\"))`.\n", " - `Ident(\"z\")` in the semantics of Ident, evaluates not to the reference but to the actual contents of the memory, which is `12`.\n", " - The call to `bar` fails because, we try to do `assignVar` on an identifier `x` that is not a reference.\n", " \n", " \n", "How do we then explain the behavior of Program B (recalled below):\n", "\n", "~~~\n", "case class Wrapper(var x : Int)\n", "\n", "def bar(z: Wrapper): Int = {\n", " // z = Wrapper(1)\n", " z.x = 25\n", " 2 * z.x\n", "}\n", "\n", "val w = Wrapper(0)\n", "println(\"Before call to bar -- > w.x = \" + w.x)\n", "bar(w)\n", "println(\"After call to bar -- > w.x = \" + w.x)\n", "~~~\n", "\n", "Once again, Scala will do call by value. Therefore the call to `bar(w)` passes the object `w` we just created by value.\n", "\n", "- However, the value of an object (something declared as a class or object) in Scala is a pointer/reference to the object. Therefore, `w` is passed in as some kind of a `Reference( ..wherever w is stored..)`. As a result, we are allowed to access `z.x` in the program which is a `var` and is in fact the very same thing as `w.x` from outside the function call. \n", "\n", "## Why special treatment for objects?\n", "\n", "Languages like Scala (and Java, Python etc..) treat objects differently from basic types such as integers, floats and chars. The basic difference is that the `value` of an integer, float or a char in the context of \"call by value\" is itself, whereas the \"value\" ascribed to an object in \"call by value\" is not a copy of the object but a reference to the contents of the object. You can see the difference in this program directly." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Inside bar: Passed in value w = ammonite.$sess.cmd3$Helper$Wrapper@62eb1af6\n", "Inside foo: passed in x = 20\n" ] }, { "data": { "text/plain": [ "defined \u001b[32mclass\u001b[39m \u001b[36mWrapper\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mbar\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mfoo\u001b[39m\n", "\u001b[36mx1\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m10\u001b[39m\n", "\u001b[36mx2\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m20\u001b[39m" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class Wrapper(var x: Int)\n", "\n", "def bar(w: Wrapper): Int = {\n", " println(\"Inside bar: Passed in value w = \" + w)\n", " w.x\n", "}\n", "\n", "def foo(x: Int): Int = {\n", " println(\"Inside foo: passed in x = \" + x)\n", " x\n", "}\n", "\n", "val x1 = bar(new Wrapper(10))\n", "val x2 = foo(20)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Languages like C and C++ do not do this kind of special treatment. When you ask them to use call by value, they will make\n", "a copy of everything to implement call by value. This can be quite expensive.\n", "\n", "\n", "~~~\n", "\n", "struct BigDataStruct {\n", " \n", " int w;\n", " char z;\n", " int x;\n", " std::vector vec;\n", " \n", " BigDataStruct(int w_, char z_, int x_): w(w_), z(z_), x(x_) {};\n", " \n", "};\n", "\n", "\n", "int foo( BigDataStruct bds0){\n", " bds0.w = 20;\n", " bds0.z = 'c'\n", " bds0.x = 45;\n", " bds0.vec = std::vector({10, 20, 45,50, 69})\n", " return 0;\n", "}\n", "\n", "\n", "int main(){\n", " BigDataStruct bds(10, 20, 45);\n", " foo (bds) // CALL by value: Make a full copy of every field of bds into a new struct and call foo.\n", " // Even though foo modifies bds0, none of the changes reflect back on bds.\n", "}\n", "\n", "~~~\n", "\n", "To mitigate this, C/C++ allows us to do call by reference as well as call by value.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Call by Reference\n", "\n", "In call by reference semantics, the value of the parameters are not passed but rather the parameters are passed as references. This was originally implemented in Fortran. Let us take an example in \"Fortran\"-like syntax.\n", "\n", "~~~\n", "SUBROUTINE SWAP( X , Y) \n", " TMP = X\n", " X = Y\n", " Y = TMP\n", " \n", "A = 45\n", "B = 55\n", "SWAP(A,B)\n", "~~~\n", "\n", "Here, we define a \"subroutine\" called SWAP with two arguments, X and Y: it exchanges their values. In regular call by value semantics, this program has no effect on A and B outside the function call. This is because, in call by value, SWAP is called on the numbers 45 and 55. In call by reference, the call to the function SWAP maps the parameter X to A and Y to B. \n", "\n", "Therefore, the assignments that happen to X, Y inside the function reflect on the variables A, B in the caller of the function.\n", "\n", "C++ supports call by reference by placing an `&` in front of the parameter in the function definition as below:\n", "\n", "~~~\n", "void swap (int & x, int & y){\n", " int tmp = x;\n", " x = y;\n", " y = tmp;\n", "}\n", "\n", "int main(){\n", " int a = 45;\n", " int b = 55;\n", " swap(a,b);\n", " // a is now assigned to 55 and b is now assigned to 45.\n", "}\n", "~~~\n", "\n", "Call by reference is useful because it allows the following advantages:\n", "- Allow \"return parameters\" which are assigned inside the function as multiple return values.\n", "- Allow lower cost passing of large data structures since call by value will perform a copy.\n", "\n", "Going back to the previous example, we can write the function foo with call by reference. This stops\n", "the compiler from performing a copy of the entire BigDataStruct contents when foo is called. \n", "\n", "~~~\n", "int foo( BigDataStruct & bds0){\n", " bds0.w = 20;\n", " bds0.z = 'c'\n", " bds0.x = 45;\n", " bds0.vec = std::vector({10, 20, 45,50, 69})\n", " return 0;\n", "}\n", "~~~" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implementing Call by Reference Semantics in Lettuce\n", "\n", "\n", "We would like to implement something similar to a call by reference semantics in Lettuce. For instance, we would like to support programs like this \n", "\n", "~~~ \n", "let bar = function (& x) \n", " let dummy = assignVar(x, x + x) in\n", " x + 20 \n", "in \n", " let var y = 15 in \n", " let z = bar(y) in \n", " y\n", "~~~\n", "\n", "\n", "We place an ampersend (`&`) before the `x` in the function definition for `bar` to state that we would like `x` to be passed by reference in the function bar. As a result, we would like the call `bar(y)` to pass the parameter `y` by reference and therefore, the assignment to `x` inside function `bar` should assign `y` and the program itself should return the value `30`.\n", "\n", "How do we achieve something like this?\n", "- First, we have to create special flag that tells us whether functions expect arguments to be passed by reference or by value. To do so, we will modify the function definitions like thus:\n", "\n", "$$\\mathbf{Expr}\\ \\Rightarrow\\ \\text{FunDef}(\\mathbf{Identifier}, \\mathbf{Expr}, \\mathbf{Boolean}) $$\n", "\n", "The extra $\\mathbf{Boolean}$ field is set to true for call by value and false for call by reference. The rest of the grammar is the same as that of Lettuce with implicit references.\n", "\n", "\n", "\n", "$$\\begin{array}{rcll}\n", "\\mathbf{Program} & \\rightarrow & TopLevel(\\mathbf{Expr}) \\\\[5pt]\n", "\\mathbf{Expr} & \\rightarrow & Const(\\mathbf{Number}) \\\\\n", " & | & Ident(\\mathbf{Identifier}) \\\\\n", " & | & Plus(\\mathbf{Expr}, \\mathbf{Expr}) \\\\\n", " & | & Minus(\\mathbf{Expr}, \\mathbf{Expr}) \\\\\n", " & | & Mult (\\mathbf{Expr}, \\mathbf{Expr}) \\\\\n", " & | & Geq (\\mathbf{Expr}, \\mathbf{Expr}) \\\\\n", " & | & Eq (\\mathbf{Expr}, \\mathbf{Expr}) \\\\\n", " & | & IfThenElse(\\mathbf{Expr}, \\mathbf{Expr}, \\mathbf{Expr}) & \\text{if (expr) then expr else expr} \\\\\n", " & | & Let( \\mathbf{Identifier}, \\mathbf{Expr}, \\mathbf{Expr}) & \\text{let identifier = expr in expr} \\\\\n", " & | & \\color{red}{FunDef( \\mathbf{Identifier}, \\mathbf{Expr},\\mathbf{Boolean})}& \\text{function (identifier-formal-parameter) expr with boolean flag}\\\\\n", " & & & \\text{that is true for call by value and false for call by ref.} \\\\[5pt]\n", " & | & FunCall(\\mathbf{Expr}, \\mathbf{Expr}) & \\text{function call - expr(expr)} \\\\\n", " & | & {LetVar}(\\mathbf{Identifier}, \\mathbf{Expr}, \\mathbf{Expr}) & \\text{let var stmt -- compare to let binding.}\\\\\n", " & | & {AssignVar}(\\mathbf{Identifier}, \\mathbf{Expr}) & \\text{assign a var to a value. }\n", "\\end{array}$$\n", "\n", "Note that the only change is in the function definition, where we note the parameter passing convention.\n", "\n", "\n", "How do we implement `eval` for such a language? \n", "\n", "First, we extend the closures to also track whether they are call by value closures or call by reference closures.\n", "\n", "$$\\begin{array}{rcl}\n", "\\mathbf{Value}\\ &\\Rightarrow&\\ \\text{NumValue} (\\mathbf{Double}) \\\\\n", "& \\Rightarrow & \\text{BoolValue}(\\mathbf{Boolean}) \\\\\n", "& \\Rightarrow & \\text{CallByValueClosure}(\\mathbf{String}, \\mathbf{Expr}, \\mathbf{Env}) \\\\\n", "& \\Rightarrow & \\text{CallByReferenceClosure}(\\mathbf{String}, \\mathbf{Expr}, \\mathbf{Env}) \\\\\n", "& \\Rightarrow & \\text{Reference}(\\mathbf{Address})\\\\\n", "& \\Rightarrow & \\text{error} \\\\\n", "\\end{array}$$\n", "\n", "\n", "Next, we define two types of eval function: `eval` (as before) and `evalRef` (specially for handling call by reference). \n", "\n", "\n", "Recall the rule for identifiers from Lettuce with implicit references:\n", "$$\\newcommand\\semRule[3]{\\begin{array}{c} #1 \\\\ \\hline #2 \\\\\\end{array}\\ \\ \\text{(#3)}} $$\n", "$$\\newcommand\\eval{\\mathbf{eval}}$$\n", "\n", "$$\\semRule{x \\in \\text{domain}(\\sigma),\\ \\sigma(x) = \\texttt{Reference}(j), \\texttt{lookupCell}(s, j) = v}{ \\eval(\\texttt{Ident(x)}, \\sigma, s) = (v, s) }{ident-var-ok}$$\n", "\n", "The rule says \"suppose we wish to evaluate an expression of the form `Ident(x)`\".\n", "- __If__ `x` is currently a reference to memory address `j` and\n", " - looking up the value of address `j` in store `s` yields the value `v`,\n", "- __Then__ return the value `v` and store `s`.\n", "\n", "\n", "Note that `evalRef` is the same as eval for all expressions except for Ident:\n", "\n", "$$ \\semRule{ e \\ \\text{is not of the form}\\ \\texttt{Ident}(x),\\ \\eval(e, \\sigma, s) = (v,s') }{\\textbf{evalRef}(e, \\sigma, s) = (v, s') }{evalref-same-as-eval}$$\n", "\n", "However, for Ident expressions, evalRef differs from eval as follows:\n", "\n", "$$\\semRule{x \\in \\text{domain}(\\sigma),\\ \\sigma(x) = v}{ \\textbf{evalRef}(\\texttt{Ident(x)}, \\sigma, s) = (v, s) }{eval-ref-ident-ok}$$\n", "\n", "In other words, evalRef does not do the \"double indirection\" for pointers. It returns whatever `x` maps to in $\\sigma$ as is.\n", "\n", "Next, function definitions will be as follows (for both eval and evalRef):\n", "\n", "\n", "$$\\semRule{}{\\eval(\\texttt{FunDef}(x, e, true), \\sigma, s) = \\text{CallByValueClosure}(x, e, \\sigma) }{(fundef-call-by-val)}$$\n", "\n", "\n", "$$\\semRule{}{\\eval(\\texttt{FunDef}(x, e, false), \\sigma, s) = \\text{CallByReferenceClosure}(x, e, \\sigma) }{(fundef-call-by-ref)}$$\n", "\n", "Finally, all the action now happens when we call a function. Here are the call by value semantics.\n", "\n", "$$\\semRule{\\eval(e_1, \\sigma, s) = (v_1, s_1),\\ v_1 \\in \\text{CallByValueClosure}(x, \\texttt{fbody}, \\sigma_{cl}),\\ \\eval(e_2, \\sigma, s_1) = (v_2, s_2),\\ v_2 \\not=\\ \\mathbf{error},\\ \\eval(\\texttt{fbody}, \\sigma_{cl} \\circ [ x \\mapsto v_2], s_2) = (v_3, s_3)}{\\eval(\\texttt{FunCall}(e_1, e_2), \\sigma, s) = (v_3, s_3) }{(funcall-by-value)}$$\n", "\n", "Next, here is the call by reference semantics:\n", "\n", "\n", "$$\\semRule{\\eval(e_1, \\sigma, s) = (v_1, s_1),\\ v_1 \\in \\text{CallByReferenceClosure}(x, \\texttt{fbody}, \\sigma_{cl}),\\ \\mathbf{\\color{red}{evalRef}}(e_2, \\sigma, s_1) = (v_2, s_2),\\ v_2 \\not=\\ \\mathbf{error},\\ \\eval(\\texttt{fbody}, \\sigma_{cl} \\circ [ x \\mapsto v_2], s_2) = (v_3, s_3)}{\\eval(\\texttt{FunCall}(e_1, e_2), \\sigma, s) = (v_3, s_3) }{(funcall-by-reference)}$$\n", "\n", "Notice the main difference boils down to a minor detail. We will simply use $\\mathbf{evalRef}$ to evaluate for the argument of the call rather than just $\\mathbf{eval}$. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "defined \u001b[32mtrait\u001b[39m \u001b[36mProgram\u001b[39m\n", "defined \u001b[32mtrait\u001b[39m \u001b[36mExpr\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mTopLevel\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mConst\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mIdent\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mPlus\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mMinus\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mMult\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mGeq\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mEq\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mIfThenElse\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mLet\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mFunDef\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mFunCall\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mLetVar\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mAssignVar\u001b[39m" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sealed trait Program\n", "sealed trait Expr\n", "\n", "case class TopLevel(e: Expr) extends Program\n", "\n", "case class Const(v: Double) extends Expr // Expr -> Const(v)\n", "case class Ident(s: String) extends Expr // Expr -> Ident(s)\n", "\n", "// Arithmetic Expressions\n", "case class Plus(e1: Expr, e2: Expr) extends Expr // Expr -> Plus(Expr, Expr)\n", "case class Minus(e1: Expr, e2: Expr) extends Expr // Expr -> Minus(Expr, Expr)\n", "case class Mult(e1: Expr, e2: Expr) extends Expr // Expr -> Mult (Expr, Expr)\n", "\n", "// Boolean Expressions\n", "case class Geq(e1: Expr, e2:Expr) extends Expr\n", "case class Eq(e1: Expr, e2: Expr) extends Expr\n", "\n", "//If then else\n", "case class IfThenElse(e: Expr, eIf: Expr, eElse: Expr) extends Expr\n", "\n", "//Let bindings\n", "case class Let(s: String, defExpr: Expr, bodyExpr: Expr) extends Expr\n", "\n", "//Function definition\n", "case class FunDef(param: String, bodyExpr: Expr, callByValue: Boolean) extends Expr\n", "\n", "// Function call\n", "case class FunCall(funCalled: Expr, argExpr: Expr) extends Expr\n", "\n", "// Let Var\n", "case class LetVar(x: String, e1: Expr, e2: Expr) extends Expr\n", "\n", "// Assign Var\n", "case class AssignVar(x: String, e: Expr) extends Expr" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "defined \u001b[32mtrait\u001b[39m \u001b[36mValue\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mNumValue\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mBoolValue\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mCallByValueClosure\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mCallByReferenceClosure\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mReference\u001b[39m\n", "defined \u001b[32mobject\u001b[39m \u001b[36mErrorValue\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mvalueToNumber\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mvalueToBoolean\u001b[39m\n", "defined \u001b[32mclass\u001b[39m \u001b[36mImmutableStore\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mcreateNewCell\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mlookupCellValue\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36massignToCell\u001b[39m" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "// Copy from the case for implicit references\n", "sealed trait Value\n", "case class NumValue(f: Double) extends Value\n", "case class BoolValue(b: Boolean) extends Value\n", "case class CallByValueClosure(x: String, e: Expr, pi: Map[String, Value]) extends Value \n", "case class CallByReferenceClosure(x: String, e: Expr, pi: Map[String, Value]) extends Value \n", "case class Reference(j: Int) extends Value\n", "case object ErrorValue extends Value\n", "\n", "\n", "/*2. Operators on values */\n", "\n", "def valueToNumber(v: Value): Double = v match {\n", " case NumValue(d) => d\n", " case _ => throw new IllegalArgumentException(s\"Error: Asking me to convert Value: $v to a number\")\n", "}\n", "\n", "def valueToBoolean(v: Value): Boolean = v match {\n", " case BoolValue(b) => b\n", " case _ => throw new IllegalArgumentException(s\"Error: Asking me to convert Value: $v to a boolean\")\n", "}\n", "\n", "/*3. Immutable Store */\n", "\n", "case class ImmutableStore(val nCells: Int, val storeMap: Map[Int, Value])\n", " \n", "def createNewCell(s: ImmutableStore, v: Value): (ImmutableStore, Int) = {\n", " /*- make a new cell -*/\n", " val j = s.nCells\n", " val nMap = s.storeMap + (j -> v)\n", " val nStore = ImmutableStore(s.nCells + 1, nMap) // Make a new store with one more cell\n", " (nStore, j)\n", "}\n", " \n", "def lookupCellValue(s: ImmutableStore, j: Int): Value = {\n", " if (s.storeMap.contains(j)){\n", " s.storeMap(j)\n", " } else {\n", " throw new IllegalArgumentException(s\"Illegal lookup of nonexistant location $j\")\n", " }\n", "}\n", " \n", "def assignToCell(s: ImmutableStore, j: Int, v: Value): ImmutableStore = {\n", " if (s.storeMap.contains(j)){\n", " val nMap = s.storeMap + (j -> v) // Update the store map.\n", " ImmutableStore(s.nCells, nMap)\n", " } else {\n", " throw new IllegalArgumentException(s\"Illegal assignment to nonexistent location $j\")\n", " }\n", " }\n", " " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "defined \u001b[32mfunction\u001b[39m \u001b[36mevalExpr\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mevalExprRef\u001b[39m\n", "defined \u001b[32mfunction\u001b[39m \u001b[36mevalProgram\u001b[39m" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def evalExpr(e: Expr, env: Map[String, Value], store: ImmutableStore): (Value, ImmutableStore) = {\n", " /* Method to deal with binary arithmetic operations */\n", " \n", " def applyArith2 (e1: Expr, e2: Expr) (fun: (Double , Double) => Double) = {\n", " val (v1, store1) = evalExpr(e1, env, store)\n", " val (v2, store2) = evalExpr(e2, env, store1)\n", " val v3 = fun(valueToNumber(v1), valueToNumber(v2))\n", " (NumValue(v3), store2)\n", " } /* -- We have deliberately curried the method --*/\n", " \n", " /* Helper method to deal with unary arithmetic */\n", " def applyArith1(e: Expr) (fun: Double => Double) = {\n", " val (v,store1) = evalExpr(e, env, store)\n", " val v1 = fun(valueToNumber(v))\n", " (NumValue(v1), store1)\n", " }\n", " \n", " /* Helper method to deal with comparison operators */\n", " def applyComp(e1: Expr, e2: Expr) (fun: (Double, Double) => Boolean) = {\n", " val (v1, store1) = evalExpr(e1, env, store)\n", " val (v2, store2) = evalExpr(e2, env, store1)\n", " val v3 = fun(valueToNumber(v1), valueToNumber(v2))\n", " (BoolValue(v3), store2)\n", " }\n", " \n", " e match {\n", " case Const(f) => (NumValue(f), store)\n", " \n", " case Ident(x) => {\n", " if (env contains x) {\n", " val v = env(x)\n", " v match {\n", " case Reference(j) => {\n", " val v1 = lookupCellValue(store, j)\n", " (v1, store) \n", " }\n", " case _ => (v, store)\n", " } \n", " } else \n", " throw new IllegalArgumentException(s\"Undefined identifier $x\")\n", " }\n", " \n", " \n", " case Plus(e1, e2) => applyArith2 (e1, e2) ( _ + _ )\n", " \n", " case Minus(e1, e2) => applyArith2(e1, e2) ( _ - _ )\n", " \n", " case Mult(e1, e2) => applyArith2(e1, e2) (_ * _)\n", " \n", " case Geq(e1, e2) => applyComp(e1, e2)(_ >= _)\n", " \n", " case Eq(e1, e2) => applyComp(e1, e2)(_ == _)\n", " \n", " case IfThenElse(e1, e2, e3) => {\n", " val (v, store1) = evalExpr(e1, env, store)\n", " v match {\n", " case BoolValue(true) => evalExpr(e2, env, store1)\n", " case BoolValue(false) => evalExpr(e3, env, store1)\n", " case _ => throw new IllegalArgumentException(s\"If-then-else condition expr: ${e1} is non-boolean -- evaluates to ${v}\")\n", " }\n", " }\n", " \n", " case Let(x, e1, e2) => {\n", " val (v1, store1) = evalExpr(e1, env, store) // eval e1\n", " val env2 = env + (x -> v1) // create a new extended env\n", " evalExpr(e2, env2, store1) // eval e2 under that.\n", " }\n", " \n", " case FunDef(x, e, true) => {\n", " (CallByValueClosure(x, e, env), store) // Return a closure with the current enviroment.\n", " }\n", " \n", " case FunDef(x, e, false) => {\n", " (CallByReferenceClosure(x, e, env), store) // Return a closure with the current enviroment.\n", " }\n", " case FunCall(e1, e2) => {\n", " val (v1, store1) = evalExpr(e1, env, store)\n", " v1 match {\n", " case CallByValueClosure(x, closure_ex, closed_env) => {\n", " val (v2, store2) = evalExpr(e2, env, store1)\n", " // First extend closed_env by binding x to v2 \n", " val new_env = closed_env + ( x -> v2)\n", " // Evaluate the body of the closure under the extended environment.\n", " evalExpr(closure_ex, new_env, store2)\n", " }\n", " case CallByReferenceClosure(x, closure_ex, closed_env) => {\n", " // THIS IS THE BIG CHANGE WE MAKE\n", " val (v2, store2) = evalExprRef(e2, env, store1)\n", " val new_env = closed_env + ( x -> v2)\n", " // Evaluate the body of the closure under the extended environment.\n", " evalExpr(closure_ex, new_env, store2)\n", " }\n", " case _ => throw new IllegalArgumentException(s\"Function call error: expression $e1 does not evaluate to a closure\")\n", " }\n", " }\n", " \n", " \n", " \n", " case AssignVar(x, e) => {\n", " val (v1, store1) = evalExpr(e, env, store)\n", " val v2 = if (env contains x) \n", " env(x)\n", " else \n", " throw new IllegalArgumentException(s\"Undefined identifier $x\")\n", " v2 match {\n", " case Reference(j) => {\n", " val store3 = assignToCell(store1, j, v1)\n", " (v1, store3)\n", " }\n", " case _ => throw new IllegalArgumentException(s\"AssignVar applied to argument that is not a mutable var\")\n", " \n", " }\n", " }\n", " \n", " case LetVar(x, e1, e2) => {\n", " val (v1, store1) = evalExpr(e1, env, store)\n", " val (store2, j) = createNewCell(store1, v1)\n", " val newEnv = env + (x -> Reference(j))\n", " evalExpr(e2, newEnv, store2)\n", " }\n", " \n", " }\n", "\n", "}\n", "\n", "// evalExprRef simply defaults to evalExpr unless the expr is of the form ident(x)\n", "\n", "def evalExprRef(e: Expr, env: Map[String, Value], store: ImmutableStore): (Value, ImmutableStore) = e match {\n", " \n", " case Ident(x) => {\n", " if (env contains x) {\n", " (env(x), store)\n", " } else {\n", " throw new IllegalArgumentException(s\"Undefined identifier $x\")\n", " }\n", " }\n", " \n", " case _ => evalExpr(e, env, store)\n", "}\n", "\n", "\n", "\n", "def evalProgram(p: Program) = p match {\n", " case TopLevel(e) => { \n", " // Start with empty environment and empty store\n", " val (v1, s1) = evalExpr(e, Map(), new ImmutableStore(0, Map()))\n", " v1\n", " }\n", "}\n", " " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "result = NumValue(80.0)\n" ] }, { "data": { "text/plain": [ "\u001b[36mx\u001b[39m: \u001b[32mIdent\u001b[39m = \u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m)\n", "\u001b[36my\u001b[39m: \u001b[32mIdent\u001b[39m = \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)\n", "\u001b[36mbar\u001b[39m: \u001b[32mIdent\u001b[39m = \u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m)\n", "\u001b[36mdum\u001b[39m: \u001b[32mIdent\u001b[39m = \u001b[33mIdent\u001b[39m(\u001b[32m\"dummy\"\u001b[39m)\n", "\u001b[36mfbody\u001b[39m: \u001b[32mLet\u001b[39m = \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d1\"\u001b[39m,\n", " \u001b[33mAssignVar\u001b[39m(\u001b[32m\"x\"\u001b[39m, \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m))),\n", " \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m))\n", ")\n", "\u001b[36mfdef\u001b[39m: \u001b[32mFunDef\u001b[39m = \u001b[33mFunDef\u001b[39m(\n", " \u001b[32m\"x\"\u001b[39m,\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d1\"\u001b[39m,\n", " \u001b[33mAssignVar\u001b[39m(\u001b[32m\"x\"\u001b[39m, \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m))),\n", " \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m))\n", " ),\n", " false\n", ")\n", "\u001b[36mlvar3\u001b[39m: \u001b[32mLet\u001b[39m = \u001b[33mLet\u001b[39m(\u001b[32m\"d3\"\u001b[39m, \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m))\n", "\u001b[36mlvar2\u001b[39m: \u001b[32mLet\u001b[39m = \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d2\"\u001b[39m,\n", " \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)),\n", " \u001b[33mLet\u001b[39m(\u001b[32m\"d3\"\u001b[39m, \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m))\n", ")\n", "\u001b[36mlvar1\u001b[39m: \u001b[32mLetVar\u001b[39m = \u001b[33mLetVar\u001b[39m(\n", " \u001b[32m\"y\"\u001b[39m,\n", " \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m),\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d2\"\u001b[39m,\n", " \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)),\n", " \u001b[33mLet\u001b[39m(\u001b[32m\"d3\"\u001b[39m, \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m))\n", " )\n", ")\n", "\u001b[36mlbar\u001b[39m: \u001b[32mLet\u001b[39m = \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"bar\"\u001b[39m,\n", " \u001b[33mFunDef\u001b[39m(\n", " \u001b[32m\"x\"\u001b[39m,\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d1\"\u001b[39m,\n", " \u001b[33mAssignVar\u001b[39m(\u001b[32m\"x\"\u001b[39m, \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m))),\n", " \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m))\n", " ),\n", " false\n", " ),\n", " \u001b[33mLetVar\u001b[39m(\n", " \u001b[32m\"y\"\u001b[39m,\n", " \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m),\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d2\"\u001b[39m,\n", " \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)),\n", " \u001b[33mLet\u001b[39m(\u001b[32m\"d3\"\u001b[39m, \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m))\n", " )\n", " )\n", ")\n", "\u001b[36mprog\u001b[39m: \u001b[32mTopLevel\u001b[39m = \u001b[33mTopLevel\u001b[39m(\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"bar\"\u001b[39m,\n", " \u001b[33mFunDef\u001b[39m(\n", " \u001b[32m\"x\"\u001b[39m,\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d1\"\u001b[39m,\n", " \u001b[33mAssignVar\u001b[39m(\u001b[32m\"x\"\u001b[39m, \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m))),\n", " \u001b[33mPlus\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"x\"\u001b[39m), \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m))\n", " ),\n", " false\n", " ),\n", " \u001b[33mLetVar\u001b[39m(\n", " \u001b[32m\"y\"\u001b[39m,\n", " \u001b[33mConst\u001b[39m(\u001b[32m20.0\u001b[39m),\n", " \u001b[33mLet\u001b[39m(\n", " \u001b[32m\"d2\"\u001b[39m,\n", " \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)),\n", " \u001b[33mLet\u001b[39m(\u001b[32m\"d3\"\u001b[39m, \u001b[33mFunCall\u001b[39m(\u001b[33mIdent\u001b[39m(\u001b[32m\"bar\"\u001b[39m), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m)), \u001b[33mIdent\u001b[39m(\u001b[32m\"y\"\u001b[39m))\n", " )\n", " )\n", " )\n", ")\n", "\u001b[36mres\u001b[39m: \u001b[32mValue\u001b[39m = \u001b[33mNumValue\u001b[39m(\u001b[32m80.0\u001b[39m)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "val x = Ident(\"x\")\n", "val y = Ident(\"y\")\n", "val bar = Ident(\"bar\")\n", "val dum = Ident(\"dummy\")\n", "\n", "/* \n", " let bar = function (& x) \n", " let d1 = assignVar(x, x + x) in \n", " x + 20\n", " in\n", " let var y = 20 in \n", " let d2 = bar(y) in \n", " let d3 = bar(y) in \n", " y\n", " \n", " # Expected result for call by reference is 80\n", " \n", "*/\n", "\n", "val fbody = Let(\"d1\", AssignVar(\"x\", Plus(x,x)), Plus(x, Const(20)))\n", "val fdef = FunDef(\"x\", fbody, false)\n", "val lvar3 = Let(\"d3\", FunCall(bar, y), y)\n", "val lvar2 = Let(\"d2\", FunCall(bar, y), lvar3)\n", "val lvar1 = LetVar(\"y\", Const(20), lvar2)\n", "val lbar = Let(\"bar\", fdef, lvar1)\n", "val prog = TopLevel(lbar)\n", "\n", "val res = evalProgram(prog)\n", "println(\"result = \" + res)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[31mjava.lang.IllegalArgumentException: AssignVar applied to argument that is not a mutable var\u001b[39m\n ammonite.$sess.cmd7$Helper.evalExpr(\u001b[32mcmd7.sc\u001b[39m:\u001b[32m110\u001b[39m)\n ammonite.$sess.cmd7$Helper.evalExpr(\u001b[32mcmd7.sc\u001b[39m:\u001b[32m64\u001b[39m)\n ammonite.$sess.cmd7$Helper.evalExpr(\u001b[32mcmd7.sc\u001b[39m:\u001b[32m64\u001b[39m)\n ammonite.$sess.cmd7$Helper.evalProgram(\u001b[32mcmd7.sc\u001b[39m:\u001b[32m146\u001b[39m)\n ammonite.$sess.cmd12$Helper.(\u001b[32mcmd12.sc\u001b[39m:\u001b[32m28\u001b[39m)\n ammonite.$sess.cmd12$.(\u001b[32mcmd12.sc\u001b[39m:\u001b[32m7\u001b[39m)\n ammonite.$sess.cmd12$.(\u001b[32mcmd12.sc\u001b[39m:\u001b[32m-1\u001b[39m)" ] } ], "source": [ "val x = Ident(\"x\")\n", "val y = Ident(\"y\")\n", "val bar = Ident(\"bar\")\n", "val dum = Ident(\"dummy\")\n", "\n", "/* \n", " let bar = function (x) \n", " let d1 = assignVar(x, x + x) in \n", " x + 20\n", " in\n", " let var y = 20 in \n", " let d2 = bar(y) in \n", " let d3 = bar(y) in \n", " y\n", " \n", " # Expected result for call by value is ERROR\n", " \n", "*/\n", "\n", "val fbody = Let(\"d1\", AssignVar(\"x\", Plus(x,x)), Plus(x, Const(20)))\n", "val fdef = FunDef(\"x\", fbody, true)\n", "val lvar3 = Let(\"d3\", FunCall(bar, y), y)\n", "val lvar2 = Let(\"d2\", FunCall(bar, y), lvar3)\n", "val lvar1 = LetVar(\"y\", Const(20), lvar2)\n", "val lbar = Let(\"bar\", fdef, lvar1)\n", "val prog = TopLevel(lbar)\n", "\n", "val res = evalProgram(prog)\n", "println(\"result = \" + res)" ] } ], "metadata": { "kernelspec": { "display_name": "Scala", "language": "scala", "name": "scala" }, "language_info": { "codemirror_mode": "text/x-scala", "file_extension": ".sc", "mimetype": "text/x-scala", "name": "scala", "nbconvert_exporter": "script", "version": "2.13.14" } }, "nbformat": 4, "nbformat_minor": 4 }