functies-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functies (1)\n",
    "\n",
    "**Onderwerpen:** *functie-definitie; functie-aanroep; rekenen met functies; typering van functies; Currying; anonieme functies.*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functie-aanroep\n",
    "\n",
    "Een functie-aanroep heeft de vorm: `fname par1 par2 ...`: de naam van de functie gevolgd door de parameter-expressies.\n",
    "In tegenstelling tot veel andere programmeertalen worden hierbij geen haakjes en komma's gebruikt.\n",
    "Soms zijn haakjes nodig omdat functie-aanroep sterker bindt dan optellen of vermenigvuldigen, of omdat een expressie van rechts naar links uitgerekend moet worden.\n",
    "\n",
    "Enkele voorbeelden van functie-aanroepen:\n",
    "\n",
    "```elm\n",
    "double 3\n",
    "max 3 4\n",
    "succ (double 4)\n",
    "max (double 4) (succ 9)\n",
    "List.map f [1,2,3]\n",
    "```\n",
    "\n",
    "Zonder haakjes zou `succ double 4` verwerkt worden als `(succ double) 4` (wat een foutmelding geeft)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functie-definitie\n",
    "\n",
    "Voordat je een functie kunt gebruiken moet deze gedefinieerd zijn.\n",
    "Je kunt een voorgedefinieerde functie gebruiken uit een geïmporteerde module (*package*),\n",
    "of een zelf-gedefinieerde functie.\n",
    "\n",
    "Een functie-definitie heeft de vorm: `fname pname1 pname2 pname3 ... = ...expr in pname1, ...`\n",
    "De namen van de parameters kun je vrij kiezen, deze hebben alleen betekenis in de definitie,\n",
    "niet bij de aanroep.\n",
    "\n",
    "Enkele voorbeelden van functie-definities:\n",
    "\n",
    "```elm\n",
    "double x = x + x\n",
    "\n",
    "max x y = if x >= y then x else y\n",
    "\n",
    "succ x = x + 1\n",
    "```\n",
    "\n",
    "De betekenis van zo'n definitie is dat je een functie-aanroep kunt vervangen door het rechterlid van de definitie (de \"body\"), waarbij je de parameternamen vervangt door de parameter-waarden in de aanroep.\n",
    "\n",
    "Merk op dat in de definitie, net als bij de aanroep, geen haakjes gebruikt worden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Rekenen met functies\n",
    "\n",
    "In het voorbeeld hieronder werken we een functie-aanroep met de hand uit,\n",
    "waarbij we steeds een aanroep vervangen door het bijbehorende rechterlid van de definitie.\n",
    "Bij elke stap beschrijven we welke regel we gebruiken.\n",
    "\n",
    "```\n",
    "    double (double 3)\n",
    "=                 { def. double x = x + x }\n",
    "    double (3 + 3)\n",
    "=                 { rekenen }\n",
    "    double 6\n",
    "=                 { def. double }\n",
    "    6 + 6\n",
    "=                 { rekenen }\n",
    "    12\n",
    "```\n",
    "\n",
    "Dit voorbeeld is nog erg eenvoudig, maar het gaat om de systematische aanpak.\n",
    "Het gebruik hiervan bij de lastige functies die we later tegenkomen helpt om de principes onder de knie te krijgen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Nog een voorbeeld, nu met een `if`-expressie. De `if`-regel is:\n",
    "```\n",
    "   if True then x else y   => x\n",
    "   if False then x else y  => y\n",
    "```\n",
    "\n",
    "We gebruiken hieronder de functie: `max x y = if x >= y then x else y`.\n",
    "\n",
    "```\n",
    "    max 3 (double 2)\n",
    "=              { def. double }\n",
    "    max 3 (2 + 2)\n",
    "=              { rekenen }\n",
    "    max 3 4\n",
    "=              { def. max }\n",
    "    if 3 >= 4 then 3 else 4\n",
    "=              { rekenen }\n",
    "    if False then 3 else 4\n",
    "=              { if-regel }\n",
    "    4\n",
    "```    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Typering van functies\n",
    "\n",
    "Elm gebruikt *statische typering*: het type van elke waarde ligt vast in de programmatekst, en kan door de Elm-compiler gecontroleerd worden voordat het programma uitgevoerd wordt.\n",
    "\n",
    "Om de compiler en de lezer te helpen bij deze controle, en om betere foutmeldingen te krijgen, is het verstandig om bij de functie-definitie ook de types van de parameters en van het resultaat te vermelden. Deze typering geef je dan in een regel vóór de eigenlijk functie-definitie. Enkele voorbeelden:\n",
    "\n",
    "```\n",
    "double: Int -> Int\n",
    "double x = x + x\n",
    "\n",
    "max: Int -> Int -> Int\n",
    "max x y = if x >= y then x else y\n",
    "\n",
    "```\n",
    "\n",
    "Hierin is `double` een functie die gegeven een `Int`-waarde (een geheel getal) een `Int`-waarde oplevert.\n",
    "`max` heeft twee `Int`-parameters, en levert een `Int` op.\n",
    "\n",
    "Merk op dat de notatie voor meerdere parameters suggereert dat er sprake is van meerdere functies. Hoe dat zit leggen we hieronder uit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Currying \n",
    "\n",
    "```\n",
    "max: Int -> (Int -> Int)\n",
    "max x y = if x >= y then x else y\n",
    "```\n",
    "\n",
    "Het type van `max` is: `Int -> Int -> Int`. De `->` is rechts-associatief, dit moet je dus lezen als: `Int -> (Int -> Int)`.\n",
    "Met andere woorden: `max` is een functie met één parameter die een functie met één parameter als resultaat heeft.\n",
    "\n",
    "Dit blijkt ook inderdaad zo te zijn: als je `max` met één parameter aanroept, is het resultaat een functie. (Probeer dit zelf uit in `elm repl`.)\n",
    "\n",
    "```\n",
    "max3 = max 3        -- function : Int -> Int\n",
    "```\n",
    "\n",
    "De functie `max3` die we zo als resultaat gekregen hebben kunnen de de volgende parameter aanbieden, waarmee we het uiteindelijke (`Int`) resultaat krijgen.\n",
    "\n",
    "> `max3` is een voorbeeld van *partiële evaluatie*: dit is de functie `max3 y = if 3 >=y then 3 else y`.\n",
    "\n",
    "```\n",
    "max3 12      -- > 12\n",
    "```\n",
    "\n",
    "Met andere woorden: de aanroep `max 3 12` moeten we lezen als `(max 3) 12`, waarbij `(max 3)` een functie oplevert die de `12` verwerkt - tot het resultaat `12`. Op deze manier kunnen we alle functies met meerdere parameters schrijven als functies van 1 parameter. Deze aanpak heet wel *Currying*, naar de logicus *Haskell Curry*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anonieme functies\n",
    "\n",
    "* voor eenmalige functies kun je de lambda-notatie voor anonieme functies gebruiken\n",
    "* vorm: `\\x -> ...expr met x`\n",
    "* `\\` staat voor lambda ($\\lambda$)\n",
    "\n",
    "```\n",
    "sqr x = x * x\n",
    "\n",
    "-- is gelijk aan:\n",
    "\n",
    "sqr = \\x -> x * x\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Voorbeeld: bulletlist\n",
    "\n",
    "We hebben eerder het onderstaande programma gezien, als voorbeeld van het benutten van functies in de context van HTML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import Html exposing (div, ul, li, text)\n",
    "import Html.Attributes exposing (style)\n",
    "import List exposing (map)\n",
    "\n",
    "bulletlist attrs lst =\n",
    "  ul attrs (map (\\elt -> li [] [text elt]) lst)\n",
    "\n",
    "main =\n",
    "  div []\n",
    "  [ bulletlist [] [\"aap\", \"noot\", \"mies\"]\n",
    "  , bulletlist [style \"color\" \"blue\"] [\"wim\", \"zus\", \"jet\"]  \n",
    "  ]\n",
    "  \n",
    "-- compile-code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Op basis van de bovenstaande uitleg over functies is de functie `bulletlist` al wat beter te begrijpen: \n",
    "\n",
    "```elm\n",
    "bulletlist attrs lst =\n",
    "  ul attrs (map (\\elt -> li [] [text elt]) lst)\n",
    "```\n",
    "\n",
    "* dit is de definitie van een functie met twee parameters, `attrs` en `lst`.\n",
    "* `ul attrs (...)` is de aanroep van de functie `ul` met twee parameters\n",
    "* `map (...) lst` is de aanroep van een functie met twee parameters,\n",
    "* waarvan de eerste parameter een *anonieme functie* is:\n",
    "* `\\elt -> li [] [text elt]`\n",
    "* hierin is `li [] [...]` weer de aanroep van een functie met 2 parameters.\n",
    "* de functies `ul` en `li` zijn Elm-functies die overeenkomen met de HTML-tags `<ul>` en `<li>`\n",
    "\n",
    "In het volgende hoofdstuk behandelen we de functie `map f lst`: het resultaat is een lijst waarin `f` toegepast is op elm element van de oorspronkelijke lijst.\n",
    "\n",
    "```\n",
    "  map double [1,3,5] == [double 1, double 3, double 5] == [2, 6, 10]\n",
    "```\n",
    "\n",
    "Ga na dat je met het gebruik van `map` in het HTML-voorbeeld een lijst-element (`li`) maakt voor elk element van de lijst `lst`.\n",
    "\n",
    "We hebben bij deze functie `bulletlist` nog geen typering gegeven. Ga zelf na hoe deze eruit zou kunnen zien.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Elm",
   "language": "elm",
   "name": "elm"
  },
  "language_info": {
   "codemirror_mode": "elm",
   "file_extension": ".elm",
   "mimetype": "text/x-elm",
   "name": "elm"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}