en/02_Functions.ipynb

{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{},"source":["## So what is a function anyway?\n","\n","\n","\n","Since we're about to learn functional programming, we need to agree on what a _function_ is in this context. Let's start with a set of entities, for example, the cars parked on a given block of a street. Each car can be identified by its license plate, and then build a table with two columns: the first with the license plate and the second with the color corresponding to each car:\n","\n","| Lic. Plate | Color |\n","| :----------: |:-------------:|\n","| ABC 124 | black |\n","| DEF 350 | red |\n","| QRZ 441 | black |\n","| JPG 255 | white |\n","\n","That's a function we can call `carColor`, which associates each car on the block with its color. The table is a representation of that function. A function from entity set A to entity set B is then a relation that associates elements between sets A and B, with the property that each and every element of A has a unique corresponding element of B.\n","\n","There are two things to keep in mind. \n","\n","First, a function is defined _from_ one set _to_ another set, in our example, from the set of license plates to the set of colors. To get the color of a particular car, go to the function representation table, find the license plate in the license plate column, and get the color from the second column. With this in mind, we can identify the set _from_ as the _input_ of the function, while the set _to_ as the _output_.\n","\n","Second, all elements of the input must be related to some element of the output set. In our example, each car in the block is assigned a color in the table. This means that there can be no empty cells in the second column of our table.\n","\n","> ❓ Can you think of more examples of functions in the real world?\n","\n","In mathematics, functions are ubiquitous. Suppose $x$ is a real number and define the function\n","\n","$$\n","f(x) = x + 1,\n","$$\n","\n","that is, the function that returns the value $x$ plus one. The input set (called the _domain_ of the function in mathematics) is the set of all real values, $\\mathbb{R}$, while the output set (the _codomain_ in mathematics) is also $\\mathbb {R}$ , because adding one to any real number is also another real number. Using the _arrow_ notation, the full definition of the function would be\n","\n","$$\n","f: \\mathbb{R} \\rightarrow \\mathbb{R} \\; ; \\; x \\mapsto a x + 1,\n","$$\n","\n","which can be read as follows: $f$ is a function from $\\mathbb{R}$ to $\\mathbb{R}$ such that $f$ of $x$ is $x + 1$\".\n","\n","> 🔔 A slight detour around the codomain. The codomain is the set of entities to which the function can possibly assign output values. For example, in the case of the color of cars, the codomain is simply the set of all possible colors. In many cases, that information is too general and it is convenient to define the _range_ of the function, which is the set of real values ​​of the outputs to which the function assigns the inputs. The range in the car example is the set {black, red, white}.\n","\n","### Multiple inputs and outputs\n","\n","Let's take the example of a vending machine. In a vending machine, products are organized into shelves, with each shelf named by a letter. On each shelf, the products are lined up and identified by a number. Then, in A1 you have a bag of chips, in A2 a chocolate, in B1 a soft drink, and so on. The machine also has a keyboard with letters and numbers for you to choose the product. To buy something, you need to give the machine money (coins, bills, credit card, etc.), select the product by clicking on the letter and number on the keyboard. The machine returns the product and some cashback, if any.\n","The inputs of our `vendingMachine` function are the money, letter, and number you selected, and the outputs are the product and\n","the refund (if any).\n","\n","> The vending machine example will be used thorougly in the course, to take a glimpse on _domain modeling_.\n","\n","A mathematical example could be a translation function, where given a point with coordinates $x$ and $y$ in the plane, it returns a point with coordinates $x+1$ and $y+1$:\n","\n","$$\n","g: \\mathbb{R} \\times \\mathbb{R} \\rightarrow \\mathbb{R} \\times \\mathbb{R} \\; ; \\; (x,y) \\mapsto (x + 1, y+1)\n","$$\n","\n","or more succinctly\n","\n","$$\n","g(x,y) = (x+1,y+1)\n","$$\n","\n","### Partial application\n","\n","When we feed a function with multiple input elements, we can get the appropriate outputs. But having many entries opens up a new possibility: what happens when one decides not to complete all the entries? Let's find out. Suppose we enter a money bill in the vending machine. It is clear that we will not get any products, because the machine still needs two more inputs: the letter of the shelf and the number of the product we want. _After_ we complete these two entries, we'll get our product (and refund, if applicable). Thus, putting money into the vending machine alone leads to a state where two inputs are needed and two outputs will be returned. But, this is _another function_!!!. Let's call it `vendingMachineAfterInsertBill` which receives the shelf letter and number of the product we want and returns the product (and change, if any).\n","\n","Returning to the mathematical example, let's feed the function only the value $x = 3$,\n","\n","$$\n","g(3,y) = (4,y+1)\n","$$\n","\n","Again, the result of feeding the function a value is another function:\n","\n","$$\n","h: \\mathbb{R} \\rightarrow \\mathbb{R} \\times \\mathbb{R} \\; ; \\; y \\mapsto (4, y+1)\n","$$\n","\n","o\n","\n","$$\n","h(y) = (4,y+1)\n","$$\n","\n","This property of functions is called partial application. Every time you do not complete all the inputs of a function, you get another function.\n","\n","### Composition\n","\n","Finally, we see here how to work with several functions at once. Suppose we have a function `getFirstName` which, given a person's full name, returns the name (implementation details do not matter at this point, not even the language). For example, when applied to 'David Gilmour', it returns 'David', or when applied to 'Annie Lennox', it of course returns 'Annie'.\n","We also have a `getInitial` function which, for a given name, returns the initial. In the above cases, 'D' stands for 'David' and 'A' stands for 'Annie'.\n","\n","Now we want to build a function that gives us the first initial, given the full name, for example 'Paul McCartney'. We feed 'Paul McCartney' as input to the 'getFirstName' function, which gives us the output 'Paul'. Now, 'Paul' is the input of the 'getInitial' function and returns 'P' as its final output.\n","This _pipeline_ where the output of one function is the input of another is called _composition_. Note that it is absolutely necessary that the output of the first called function (`getFirstName`) and the input of the second (`getInitial`) be of the same entity type, in our case both are names.\n","\n",">[See this page for a graphic explanation of the composition](https://mathinsight.org/function_machine_composition).\n","\n","Now let's look at a mathematical example. We defined earlier the function $f(x)$ that adds one to $x$, for example\n","\n","$$\n","f(0) = 0 + 1 = 1\n","$$\n","\n","What happens if we apply the function $f$ again? means to compute\n","\n","$$\n","f(f(0)) = f(0) + 1 = 0 + 1 + 1 = 2\n","$$\n","\n","In general,\n","\n","$$\n","f(f(x)) = f(x) + 1 = x + 1 + 1 = x + 2\n","$$\n","\n","If we look carefully at the last expression, composing the function is like passing the function as the input itself ($f(f(x))$). This means that if we are going to have a programming language that implements function composition, functions should somehow be able to be passed as input to other functions.\n","\n","> ❗️ The fact that we use the same function to compose with itself is not relevant to this discussion, one can compose as many different functions as one wants, as long as the inputs and outputs are compatible at each composition step.\n","\n","> 🔔 However, composing that particular function with itself is interesting. Images that have only the zero and this function. You can create all the natural numbers {1, 2, ...} simply by composing this function with itself over and over again. For example, $4 = f(f(f(f(0))))$, and so on. Therefore, given the number 0, $f(x) = x + 1$ and the composition of the function, all natural numbers can be obtained. It seems that something is happening here. More on this, hopefully, in a future episode.\n"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["## Functions in F\\#\n","\n","The F\\# language implements functions in such a way that they satisfy the properties mentioned above. To define a function, the language also uses the `let` keyword:\n"]},{"cell_type":"code","execution_count":null,"metadata":{"dotnet_interactive":{"language":"fsharp"}},"outputs":[],"source":["let next x =\n","    x + 1 "]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["We define the function called `next` that receives an argument `x`. Notice that there are no other symbols or parentheses in the function definition. The function body must be indented and there is no trailing `return` keyword. The function simply returns the last expression found in its body. Clean, right?\n","Using the function is also easy:"]},{"cell_type":"code","execution_count":null,"metadata":{"dotnet_interactive":{"language":"fsharp"}},"outputs":[],"source":["let one = next 0 \n","let two = next (next 0)\n","\n","printfn \"one: %A\" one \n","printfn \"two: %A\" two "]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["Note that it is not necessary to use parentheses around the argument when using a function. However, you should use them when you pass a more complex expression as an argument to the function, such as in the function `two`.\n","\n","There is another way to write the calculation of `two`, using the _pipe_ `|>` operator:"]},{"cell_type":"code","execution_count":null,"metadata":{"dotnet_interactive":{"language":"fsharp"}},"outputs":[],"source":["let anotherTwo =\n","    0 \n","    |> next\n","    |> next \n","    \n","printfn \"anotherTwo: %A\" anotherTwo"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["This operator takes care of the plumbing by calling functions one after another. In the example above, the first `|>` receives `0` as input, passes it to the next function, the second `|>` receives the output of the first `next` function and feeds it as input to the second ` next`."]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["Another example. Suppose we are given the functions `getInitial` and `getFirstName` discussed before defined as:\n","\n","```fsharp\n","let getInitial name = \n","    .... //Implementation not important right now\n","```\n","\n","and \n","\n","```fsharp\n","let getFirstName fullName = \n","    .... //Implementation not important right now\n","```\n","\n","and we define the value\n","\n","```fsharp\n","let paul = \"Paul McCartney\"\n","```\n","\n","So,\n","\n","```fsharp\n","paul\n","|> getFirstName\n","|> getInitial \n","```\n","Here, the value of the string `paul` is passed into the `getFirstName` function as the input of the first pipe `|>`, and returns 'Paul' as the output. Then the string 'Paul' is passed as input to the 'getInitial' function which gives us the 'P'."]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["Composition is so important in functional languages ​​that it has its own symbol, which in F\\# is `>>` :"]},{"cell_type":"code","execution_count":null,"metadata":{"dotnet_interactive":{"language":"fsharp"}},"outputs":[],"source":["let add2 = next >> next \n","let two' = add2 0 \n","printfn \"%A\" two'"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["Yes, you can use the `'` symbol in any identifier! (as long as it is not the first character). Also note that we define a _function_ `add2` using the composition operator (no argument needed). This is equivalent to:"]},{"cell_type":"code","execution_count":null,"metadata":{"dotnet_interactive":{"language":"fsharp"}},"outputs":[],"source":["let add2' x = \n","    x\n","    |> next\n","    |> next "]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["Remember that there is no return at the end of the function, only the last expression of the function is the return value."]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["Let us return to the example of the names, to clarify the order in which the functions are composed:\n","\n","```fsharp\n","let getInitialFromFirstName fullName =\n","    getInitial (getFirstName fullName)\n","        \n","```\n","\n","```fsharp\n","let getInitialFromFirstName' fullName =\n","    fullName\n","        |> getFirstName \n","        |> getInitial \n","```\n","and \n","\n","```fsharp\n","let getInitialFromFirstName'' =\n","        getFirstName >> getInitial \n","```\n","\n","\n","\n","they are equivalent."]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["> ❓ Think of routines, procedures or functions that you may have written in your preferred language. Do they behave like F\\# functions? What are the main differences you see?"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["> 🏋🏽 We have a function `mult2` that given a number `x` doubles that number. Without coding, can you determine what the following composite functions return when applied to 3? :\n","\n","```fsharp\n","let f = mult2 >> next \n","let g = next >> mult2 \n","```\n","\n","Code the `mult2` function and see the result for yourself."]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["A few final remarks for now on functions. First, note that the language uses the same `let` keyword to bind values ​​and simple functions to a name or identifier. This emphasizes the fact that in F# functions are 'just' values ​​and can be treated in the same way as, for example, a simple binding of an expression to an identifier.\n","Second, the properties of functions discussed above are a perfect match for immutability. In fact, functions take immutable input and return an immutable value."]}],"metadata":{"kernelspec":{"display_name":".NET (C#)","language":"C#","name":".net-csharp"},"language_info":{"name":"polyglot-notebook"},"polyglot_notebook":{"kernelInfo":{"defaultKernelName":"csharp","items":[{"aliases":["C#","c#"],"languageName":"C#","name":"csharp"},{"aliases":["F#","f#"],"languageName":"F#","name":"fsharp"},{"aliases":[],"languageName":"HTML","name":"html"},{"aliases":[],"languageName":"Mermaid","name":"mermaid"},{"aliases":["powershell"],"languageName":"PowerShell","name":"pwsh"},{"aliases":[],"name":"value"},{"aliases":["frontend"],"name":"vscode"}]}}},"nbformat":4,"nbformat_minor":2}