es/30_Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Colecciones heterogéneas "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las _tuplas_ son agregados ordenados de (unos muy pocos) datos, posiblemente de distinto tipo, que en algunos casos son más convenientes que definir _records_. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "let messi = (\"Messi\",10)\n",
    "let paredes = (\"Paredes\",5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso definimos una tupla donde la primer componente es de tipo `string`, mientras que la segunda componente es de tipo `int`. \n",
    "\n",
    "Se pueden extraer la primer o segunda componente para el caso de tuplas de dos elementos\n",
    "a través de las funciones `fst` y `snd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi juega con la casaca 10\n"
     ]
    }
   ],
   "source": [
    "let nombreMessi = fst messi \n",
    "let numeroMessi = snd messi\n",
    "\n",
    "printfn \"%s juega con la casaca %A\" nombreMessi numeroMessi"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para tuplas de más elementos, cada uno de ellos puede extraerse con una variante de _pattern matching_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El producto Opera pesa 200 y cuesta 4.150000\n"
     ]
    }
   ],
   "source": [
    "let cookies = (\"Opera\", 200, 4.15)\n",
    "let choco = (\"Wonka\", 35, 12.40) \n",
    "\n",
    "let operaName, operaWeight, operaPrice = cookies \n",
    "\n",
    "printfn \"El producto %s pesa %d y cuesta %f\" operaName operaWeight operaPrice"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si uno está interesado en sólo uno de los componentes, se puede usar `_` como comodín:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El chocolate Wonka cuesta 12.400000 $\n"
     ]
    }
   ],
   "source": [
    "let _,_,chocoPrice = choco\n",
    "\n",
    "printfn \"El chocolate Wonka cuesta %f $\" chocoPrice"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los dos ejemplos anteriores el uso de los paréntesis `(` y `)` es opcional.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así como es posible hacer _pattern matching_ para controlar el flujo del código con distintas condiciones, también es posible utilizar tuplas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Opera\" is cheap\n",
      "\"Wonka\" is Expensive!\n"
     ]
    }
   ],
   "source": [
    "let isExpensive product = \n",
    "    match product with \n",
    "    | (brand,_,price) when price > 10.0 -> \n",
    "        printfn \"%A is Expensive!\" brand \n",
    "    | _ -> \n",
    "        let (brand,_,_) = product\n",
    "        printfn \"%A is cheap\" brand \n",
    "\n",
    "cookies |> isExpensive \n",
    "choco |> isExpensive "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay que recordar que las tuplas es otro tipo de dato, así que se puede mezclar con records, uniones, etc. Se pueden definir tipos de datos a partir de tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "type Point = \n",
    "    | Point of float * float\n",
    "\n",
    "let xOf p = \n",
    "    let (Point (x,_)) = p\n",
    "    x\n",
    "let yOf p = \n",
    "    let (Point (_,y)) = p\n",
    "    y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la coordenada x de p es 2.0\n",
      "la coordenada y de p es 3.0\n"
     ]
    }
   ],
   "source": [
    "let p = Point (2,3)\n",
    "\n",
    "printfn \"la coordenada x de p es %A\" (xOf p)\n",
    "printfn \"la coordenada y de p es %A\" (yOf p)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y las tuplas podrían contener otros tipos de datos, como tuplas de tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "type Segment =  Point * Point\n",
    "\n",
    "type SegmentDU = \n",
    "    | SegmentDU of Point * Point \n",
    "\n",
    "type Triangle = Point * Point * Point \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point: Point (6.0, 5.0)\n",
      "SegmentDU: SegmentDU (Point (2.0, 3.0), Point (6.0, 5.0))\n",
      "P1: Point (2.0, 3.0)\n",
      "P2: Point (6.0, 5.0)\n"
     ]
    }
   ],
   "source": [
    "let q = Point (6,5)\n",
    "let sdu = SegmentDU (p,q)\n",
    "\n",
    "let (SegmentDU (p1,p2)) = sdu \n",
    "printfn \"Point: %A\" q\n",
    "printfn \"SegmentDU: %A\" sdu\n",
    "printfn \"P1: %A\" p1\n",
    "printfn \"P2: %A\" p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "let lengthOf segment =\n",
    "    let  (p1,p2) = segment \n",
    "    let sx = xOf p1 - xOf p2 \n",
    "    let sy = yOf p1 - yOf p2 \n",
    "    sqrt (sx*sx + sy*sy)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "dotnet_interactive": {
     "language": "fsharp"
    },
    "polyglot_notebook": {
     "kernelName": "fsharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.414213562\n"
     ]
    }
   ],
   "source": [
    "let s =  (Point (1,4), Point (2,5))\n",
    "printfn \"%A\" (lengthOf s)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4,
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}