get-programming-with-f-sharp/21-modeling-relationships-in-f-sharp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get Programming with F# by [Isaac Abraham](https://github.com/isaacabraham)\n",
    "\n",
    "## “Modeling relationships in F#”\n",
    "\n",
    "When Isaac Abraham uses the word _relationships_, he is referring to OOP/C# things like:\n",
    "\n",
    "- _hierarchical_, inheritance relationships\n",
    "- _lateral_, (interface-based) composition relationships\n",
    "- database-entity, (mostly) one-to-many relationships ([Entity Framework](https://docs.microsoft.com/en-us/ef/) models)\n",
    "\n",
    "I have only my ignorance to blame when the author introduces F# _discriminated unions_ [📖 [docs](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions)] as the equivalent/replacement of _hierarchical_, OOP inheritance relationships! Without this introduction, I am sure I would continue to fail to see the Microsoft documentation entry, “[Using Discriminated Unions Instead of Object Hierarchies](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions#using-discriminated-unions-instead-of-object-hierarchies)” and its `Shape` code sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "#!fsharp\n",
    "\n",
    "type Shape =\n",
    "| Circle of float\n",
    "| EquilateralTriangle of double\n",
    "| Square of double\n",
    "| Rectangle of double * double"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `Shape` can be thought of (in a C# way) as a “base class” that can _polymorphose_ into one of four ‘things’:\n",
    "\n",
    "1. `Circle`\n",
    "2. `EquilateralTriangle`\n",
    "3. `Square`\n",
    "4. `Rectangle`\n",
    "\n",
    "The `of` keyword, listed in this [big-ass table from Microsoft](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/keyword-reference#f-keyword-table), allows us to define fields on these four ‘things’—and the `of` syntax we are seeing above is the _anonymous field_ variety:\n",
    "\n",
    ">Unnamed fields are referred to as anonymous fields.\n",
    ">\n",
    ">—[Microsoft](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions)\n",
    "\n",
    "From a C# (or even a Typescript) perspective, discriminated unions is the line in the sand where you decide whether you like F# or not. It _feels_ like you will not really be using F# when you avoid using discriminated unions! I find the terse, expressive power here extremely attractive (but I can also see how hard-core OOP rock stars would walk away from this, determined to _not_ understand what is happening here).\n",
    "\n",
    "What is happening here, for example, is this anonymous-field `of` syntax allows us to ‘delay’ (at design-time) _naming_ our fields until they are used in a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of circle that has radius 15.000000: 706.858347\n",
      "Area of square that has side 10.000000: 100.000000\n",
      "Area of rectangle that has height 5.000000 and width 10.000000 is 50.000000\n"
     ]
    }
   ],
   "source": [
    "#!fsharp\n",
    "\n",
    "let pi = 3.141592654\n",
    "\n",
    "let area myShape =\n",
    "    match myShape with\n",
    "    | Circle radius -> pi * radius * radius // unwrapping the tuple with the name `radius` from `Circle`\n",
    "    | EquilateralTriangle s -> (sqrt 3.0) / 4.0 * s * s\n",
    "    | Square s -> s * s\n",
    "    | Rectangle (h, w) -> h * w // unwrapping the tuple with the names `h` and `w` from `Rectangle`\n",
    "\n",
    "let radius = 15.0\n",
    "let myCircle = Circle(radius)\n",
    "printfn \"Area of circle that has radius %f: %f\" radius (area myCircle)\n",
    "\n",
    "let squareSide = 10.0\n",
    "let mySquare = Square(squareSide)\n",
    "printfn \"Area of square that has side %f: %f\" squareSide (area mySquare)\n",
    "\n",
    "let height, width = 5.0, 10.0\n",
    "let myRectangle = Rectangle(height, width)\n",
    "printfn \"Area of rectangle that has height %f and width %f is %f\" height width (area myRectangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "source": [
    "The `area` function is, according to Microsoft documentation at the time of this writing, _unwrapping_ (exposing and naming) anonymous fields from `Shape` in its `match` expression. These names do not exist until they are needed! This is awesome! This is the F# answer to the Typescript answer to the question, Can we define types better in JavaScript?\n",
    "\n",
    "\n",
    "The following question sounds like someone is [micro-dosing](https://www.forbes.com/sites/amandasiebert/2020/11/13/microdosing-psychedelics-is-trendy-but-does-it-work-heres-what-science-says/?sh=117fdfe6cf7c) a bit too much:\n",
    "\n",
    "_Did you ever want to define class hierarchies with regular expressions?_\n",
    "\n",
    "Most hard-core C# developers (many of them have considered themselves my “manager”) would scoff at such a question but be too dismissive to really think about the difference between F# `match` expressions and regular expressions. They would fall back into stating our `Shape` types as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class Shape\n",
    "{\n",
    "    protected virtual double GetArea()\n",
    "    {\n",
    "        throw new NotImplementedException();\n",
    "    }\n",
    "}\n",
    "\n",
    "public class Circle : Shape\n",
    "{\n",
    "    public Circle(double radius) => _radius = radius;\n",
    "\n",
    "    protected override double GetArea() => Math.PI * _radius * _radius;\n",
    "\n",
    "    double _radius;\n",
    "}\n",
    "\n",
    "public class EquilateralTriangle : Shape\n",
    "{\n",
    "    public EquilateralTriangle(double side) => _side = side;\n",
    "\n",
    "    protected override double GetArea() => Math.Sqrt(3.0)/4.0 * _side * _side;\n",
    "\n",
    "    double _side;\n",
    "}\n",
    "\n",
    "public class Square : Shape\n",
    "{\n",
    "    public Square(double side) => _side = side;\n",
    "\n",
    "    protected override double GetArea() => _side * _side;\n",
    "\n",
    "    double _side;\n",
    "}\n",
    "\n",
    "public class Rectangle : Shape\n",
    "{\n",
    "    public Rectangle(double height, double width){\n",
    "        _height = height;\n",
    "        _width = width;\n",
    "    }\n",
    "\n",
    "    protected override double GetArea() => _height * _width;\n",
    "\n",
    "    double _height;\n",
    "    double _width;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## the Microsoft docs might call them “anonymous fields” but these are _not_ members of F# records\n",
    "\n",
    "When we look at `Shape` in F#, we must remind ourselves that it has _no fields_ to share with the members of the discriminated union. And we must also remember that Discriminated unions in F# can be compositions of what we might call _named tuples_ in C# [📖 [docs](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-tuples#tuple-field-names)]. These named tuples are closer to the `struct` than to the `class` and we must remember that the `struct` does _not_ support inheritance [📖 [docs](https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/inheritance)].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "#!fsharp\n",
    "\n",
    "type MyTuples =\n",
    "    | One of a: string * b: string * c: string\n",
    "    | Two of a: string * b: string * c: string * d: string\n",
    "    | Three of a: string * b: string * c: string * e: string * f: int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Would it not be possible to share `a: string * b: string * c: string` among the cases of the DU?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Two (\"1\", \"2\", \"3\", \"4\")\n",
      "Two (One (\"1\", \"2\", \"3\"), \"4\")\n"
     ]
    }
   ],
   "source": [
    "#!fsharp\n",
    "\n",
    "type MyOne = One of a: string * b: string * c: string // the single-case DU\n",
    "\n",
    "type MySharingTuples =\n",
    "    | One of MyOne\n",
    "    | Two of MyOne * d: string\n",
    "    | Three of MyOne * e: string * f: int\n",
    "\n",
    "let myTwo = MyTuples.Two (a = \"1\", b = \"2\", c = \"3\", d = \"4\")\n",
    "\n",
    "let mySharingTwo = MySharingTuples.Two (MyOne.One (a = \"1\", b = \"2\", c = \"3\"), d = \"4\")\n",
    "\n",
    "myTwo |> printfn \"%A\"\n",
    "mySharingTwo |> printfn \"%A\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From a type theory perspective, `myTwo` and `mySharingTwo` are not equal and the compiler will not even allow us to prove that. But from a set theory perspective, `Two (\"1\", \"2\", \"3\", \"4\")` and `Two (One (\"1\", \"2\", \"3\"), \"4\")` look like:\n",
    "\n",
    "```plaintext\n",
    "(\"1\", \"2\", \"3\", \"4\") = ((\"1\", \"2\", \"3\"), \"4\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## discriminated unions and anonymous records\n",
    "\n",
    "On page 252 of the book, Isaac Abraham shows how record fields can be shared with a discriminated union by including the DU as a member of the record. Frankly, this was not the class hierarchy I was looking for! What is closer (and beyond the scope of the author’s intent for this lesson) is the use of _anonymous records_ in a DU [📖 [docs](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/anonymous-records#embedding-anonymous-records-within-other-types)].\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [],
   "source": [
    "#!fsharp\n",
    "\n",
    "type FullName = { FirstName: string; LastName: string }\n",
    "\n",
    "// Note that using a named record for Manager and Executive would require mutually recursive definitions.\n",
    "type Employee =\n",
    "    | Engineer of FullName\n",
    "    | Manager of {| Name: FullName; Reports: Employee list |}\n",
    "    | Executive of {| Name: FullName; Reports: Employee list; Assistant: Employee |}\n",
    "\n",
    "let getFirstName e =\n",
    "    match e with\n",
    "    | Engineer fullName -> fullName.FirstName\n",
    "    | Manager m -> m.Name.FirstName\n",
    "    | Executive ex -> ex.Name.FirstName"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `getFirstName`, we can see that we are sharing the `FullName` record among all of the `Employee` types. But, again, we sharing it as a property `Name` instead of _extending_ the anonymous records.\n",
    "\n",
    "According to [a StackOverflow answer](https://stackoverflow.com/a/67456001/22944):\n",
    "\n",
    ">…F# record types are not inheritable or [combinable] in other ways… Some languages like Typescript have _intersection types_ [📖 [docs](https://www.typescriptlang.org/docs/handbook/2/objects.html#intersection-types)] where you can define a type as having the fields of a set of other types…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## other names for discriminated unions\n",
    "\n",
    "Isaac Abraham clarifies:\n",
    "\n",
    ">The standard functional programming answer to modeling _is-a_ relationships is by using a _discriminated union_ (DU). There are other names for it, such as _sum types_, _case classes_ in Scala, or _algebraic data types_ for people who want to sound smart.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## polymorphism is _not_ confined to OOP\n",
    "\n",
    "I admit freely that I was one of those C# developers (without a degree in computer science) who just assumed that [polymorphism](https://en.wikipedia.org/wiki/Polymorphism_(computer_science)) is only possible in object-oriented programming (OOP). And, when I use the word _was_, I am talking about the day _before_ I started writing these notes!\n",
    "\n",
    "According to Wikipedia, the type of polymorphism related to DUs is polytypism, leading to the subject of [_generic programming_](https://en.wikipedia.org/wiki/Generic_programming#Functional_languages).\n",
    "\n",
    "The type of polymorphism C# developers are used to is subtype polymorphism or inclusion polymorphism—which means the word _subtyping_ is not just c-like programmer slang: it is a reference to knowledge of computer science!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## discriminated unions can make a developer use F# exclusively for Web projects\n",
    "\n",
    "The [Elmish module](https://elmish.github.io/elmish/) sits on top of the [Fable](https://fable.io/) F#-to-Javascript compiler. Elmish and Fable are part of the [SAFE stack initiative](https://www.compositional-it.com/news-blog/introducing-the-safe-stack/), developed and promoted by Isaac Abraham himself.\n",
    "\n",
    "The core concept of Elmish is the _message_, “an event representing a change (delta) in the state of your application.” This means an Elmish-based web application will have no interactivity without this message which is represented by—you guessed it—a discriminated union.\n",
    "\n",
    "Because discriminated unions are so relatively terse and compact with respect to OOP-based languages, whipping up _formal_ types for every single interaction in your application becomes easy, making the application easier to maintain because _all developer intent_ is _denoted_ instead of _connoted_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## is it _all_ about pattern matching and discriminated unions?\n",
    "\n",
    "There are 22 lessons left in Isaac Abraham’s book. As of now (lesson 21), I assume that being a “good” F# programmer means you enjoy thinking about and studying:\n",
    "\n",
    "1. pattern matching\n",
    "2. discriminated unions\n",
    "\n",
    "There are tons of other F# features but I currently assume that these two are the basics.\n",
    "\n",
    "Lesson 21 goes on to explore a few DU patterns:\n",
    "\n",
    "- nested DUs\n",
    "- shared fields\n",
    "- how F# enums look like DUs (see [lesson 8](https://github.com/BryanWilhite/jupyter-central/blob/master/get-programming-with-f-sharp/08-capstone-01.ipynb))\n",
    "\n",
    "The Microsoft documentation adds [_recursive discriminated unions_](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions#using-discriminated-unions-for-tree-data-structures) and warns:\n",
    "\n",
    ">You cannot use a recursive type definition with a multicase `struct` Discriminated Union.\n",
    "\n",
    "…which implies there is such a thing as a `struct` _discriminated union_ [📖 [docs](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions#struct-discriminated-unions)], likely needed to interoperate with other .NET languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## the role of discriminated unions in F# design patterns\n",
    "\n",
    "Because discriminated unions express inheritance it should follow that any OOP design patterns using inheritance should translate quite well to F#. I am certainly not the first to realize this! In 2013, Tao Liu wrote _F# for C# Developers_ [[Microsoft Press](https://www.microsoftpressstore.com/store/f-for-c-sharp-developers-9780735670211)]—and a chapter from the book, \n",
    "“[F# and Design Patterns for C# Developers](https://www.microsoftpressstore.com/articles/article.aspx?p=2224057),” addresses this topic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "@[BryanWilhite](https://twitter.com/BryanWilhite)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table><tbody><tr><td><img src=\"data:image/png;base64, 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\" width=\"125em\"></img></td><td style=\"line-height:.8em\"><p style=\"font-size:1.5em\"><b>.NET Interactive</b></p><p>&#169; 2020 Microsoft Corporation</p><p><b>Version: </b>1.0.255902+b0afbdc47dec91e62b0c5cb587a0f2c24242eca8</p><p><b>Build date: </b>2021-11-09T18:27:50.0000000Z</p><p><a href=\"https://github.com/dotnet/interactive\">https://github.com/dotnet/interactive</a></p></td></tr></tbody></table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!about"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".cs",
   "mimetype": "text/x-csharp",
   "name": "C#",
   "pygments_lexer": "csharp",
   "version": "9.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}