notebooks/pih05-DefiningNewTypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 새 유형 정의하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "기본 유형과 이미 선언된 유형을 이용하여 새 유형을 정의할 수 있다.\n",
    "새롭게 정의될 수 있는 유형들을 다음과 같으며 적절한 도구를 사용하여 해당 유형을 새롭게 정의한다. \n",
    "\n",
    "* 리스트 유형   \n",
    "* 튜플 유형\n",
    "* 함수 유형\n",
    "* 다형 유형\n",
    "* 사용자 정의 유형\n",
    "\n",
    "**주의:** 사용자 정의 유형에 대해서는 이후에 다룰 예정임."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 유형 구분"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하스켈에서 사용할 수 있는 유형을 일반적으로 두 부류로 나눈다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 내장 유형과 사용자 정의 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 내장 유형built-in types: 하스켈에서 기본적으로 제공하는 유형\n",
    "    * 정수 유형: `Int`와 `Integer`\n",
    "    * 실수 유형: `Float`와 `Double`\n",
    "    * 진리값 유형: `Bool`\n",
    "    * 문자 유형: `Char`\n",
    "    * 문자열 유형: `String`\n",
    "    * 리스트 유형: `[Char]`, `[(Integer, Float)]`\n",
    "    * 튜플 유형: `([Int], Double)`, `(Double, String, Int)`, ...\n",
    "    * 함수 유형: `Integer -> Bool`\n",
    "    * 다형 유형: `[a]`, `(a, b)`, ...\n",
    "2. 사용자 정의 유형: 사용자가 규칙에 맞게 정의할 수 있는 유형\n",
    "    * `data` 키워드로 정의된 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하지만 여기서는 기본 유형과 새롭게 정의될 수 있는 유형으로 구분한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 기본 유형과 정의된 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 기본 유형: 말 그대로 기본으로 주어진 유형\n",
    "    * 정수 유형: `Int`와 `Integer`\n",
    "    * 실수 유형: `Float`와 `Double`\n",
    "    * 진리값 유형: `Bool`\n",
    "    * 문자 유형: `Char`\n",
    "    * 문자열 유형: `String`\n",
    "2. 정의된 유형: 사용자가 규칙에 맞게 정의할 수 있는 유형\n",
    "    * 리스트 유형: `[Char]`, `[(Integer, Float)]`\n",
    "    * 튜플 유형: `([Int], Double)`, `(Double, String, Int)`, ...\n",
    "    * 함수 유형: `Integer -> Bool`\n",
    "    * 다형 유형: `[a]`, `(a, b)`, `a -> b`, ...\n",
    "    * 사용자 정의 유형: `data` 키워드로 정의된 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 주의사항"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "엄밀히 따지면 다음 세 가지 유형 생성 방식만 있으면 기본 유형과, 리스트, 튜플 유형을 모두 정의할 수 있다. \n",
    "하지만 이에 대한 자세한 설명은 이 강의의 범위를 벗어난다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 함수 유형: `Integer -> Bool`\n",
    "* 다형 유형: `[a]`, `(a, b)`, `a -> b`, ...\n",
    "* 사용자 정의 유형: `data` 키워드로 정의된 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 리스트 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "리스트는 동일한 유형의 값을 갖는 유한개의 값들을 하나로 묶어 들고 다니는 값이며, \n",
    "아래 형태를 갖는다. \n",
    "\n",
    "```haskell\n",
    "[t1, t2, ..., tn]\n",
    "```\n",
    "\n",
    "단, `n`은 임의의 자연수이고, `t1`, `t2`, ..., `tn` 모두 동일한 유형을 가져야 한다. \n",
    "\n",
    "`T`가 임의의 유형이고, `t1`, ..., `tn` 모두 `T` 유형을 갖는다면\n",
    "다음이 성립한다. \n",
    "\n",
    "```haskell\n",
    "[t1, t2, ..., tn] :: [T]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "예를 들어 다음이 성립한다. \n",
    "\n",
    "```haskell\n",
    "['a', 'b', 'c'] :: [Char]\n",
    "[] :: [Char]\n",
    "[] :: [[Char]]\n",
    "[\"abc\", \"bc\", \"adegh\", \"zyxabc\"] :: [String]\n",
    "[1..10] :: [Integer]\n",
    "[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]] :: [[Integer]]\n",
    "[[[1, 2], [3, 4]], [[5, 6], [7, 8], [9, 10]]] :: [[[Integer]]]\n",
    "```\n",
    "\n",
    "리스트에 포함된 항목은 모두 동일한 유형을 가지며, 유형에 대한 제한은 없다. \n",
    "즉, 임의의 유형에 대한 리스트를 생성할 수 있다. \n",
    "\n",
    "길이가 0인 리스트, 즉 어떤 항목도 포함하지 않는 리스트를 **빈 리스트**라 부르며\n",
    "`[]`로 표기한다. \n",
    "`\"\"`와 `\" \"`의 경우처럼 `[]`와 `[[]]`가 다름에 주의한다. \n",
    "또한 빈 리스트의 유형은 명확하지 않을 수 있다.\n",
    "따라서 아래와 같이 어떤 유형의 빈 리스트인지 지정하기도 한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>([] :: [Float]) :: [Float]</span>"
      ],
      "text/plain": [
       "([] :: [Float]) :: [Float]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t ([] :: [Float])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "빈 리스트를 비교할 때 자료형이 동일하면 `True` 를 계산한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "([] :: [Int]) == ([] :: [Int])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하지만 자료형이 다르면 오류가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "<interactive>:1:19: error:\n    • Couldn't match type ‘Integer’ with ‘Int’\n      Expected type: [Int]\n        Actual type: [Integer]\n    • In the second argument of ‘(==)’, namely ‘([] :: [Integer])’\n      In the expression: ([] :: [Int]) == ([] :: [Integer])\n      In an equation for ‘it’: it = ([] :: [Int]) == ([] :: [Integer])"
     ]
    }
   ],
   "source": [
    "([] :: [Int]) == ([] :: [Integer])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 주의사항\n",
    "\n",
    "* 문자열 유형 `String`은 문자들의 리스트 유형인 `[Char]`를 달리 부르는 표현이다.\n",
    "따라서 빈문자열은 문자들의 빈 리스트에 해당한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><div class=\"suggestion-name\" style=\"clear:both;\">Use String</div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Found:</div><div class=\"highlight-code\" id=\"haskell\">[Char]</div></div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Why Not:</div><div class=\"highlight-code\" id=\"haskell\">String</div></div>"
      ],
      "text/plain": [
       "Line 1: Use String\n",
       "Found:\n",
       "[Char]\n",
       "Why not:\n",
       "String"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "([] :: [Char]) == \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "['h','e', 'l', 'l', 'o'] == \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트의 길이에는 제한이 없다. 따라서 무한 리스트도 정의되어 활요될 수 있다. \n",
    "    예를 들어, `[0..]`는 모든 자연수를 담고 있는 정수들의 리스트이다. \n",
    "    이것이 가능한 이유는 앞서 설명한 소극적 계산법과 관련되어 있으며, 자세한 내용은 나중에 다룰 것이다.\n",
    "    \n",
    "    여기서는 `[0..]`이 정말로 모든 자연수들의 리스트임을 보여주는 예제만 몇 개 보여준다. \n",
    "    아래 예제들은 리스트 관련 함수들 중에서 유한 시간내에 계산을 마치는 함수만 보여준다. \n",
    "    `length` 함수의 경우처럼 계산이 멈추지 않을 수도 있음에 주의해야 한다. \n",
    "    즉, 아래와 같이 실행하면 ghci가 멈추지 않으며, 강제로 종료시켜야 한다. \n",
    "    \n",
    "    ```haskell\n",
    "    length [0..]\n",
    "    ```\n",
    "    \n",
    "    하지만 아래 예제들처럼 유한 시간내에 계산이 끝나는 경우 모든 `[0..]`를 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>[0..] :: forall a. (Num a, Enum a) => [a]</span>"
      ],
      "text/plain": [
       "[0..] :: forall a. (Num a, Enum a) => [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t [0..]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head [0..]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[0..] !! 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "take 15 [0..]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 위 설명에서 사용된 `[0..]` 보았듯이 리스트 자체와 리스트의 유형은 리스트의 길이에 대한 정보를 전혀 갖고 있지 않다.\n",
    "    예를 들어, `[True, False]`와 `[False, False, True]`의 경우처럼 길이가 다른 두 리스트의 유형은 \n",
    "    `[Bool]`로 동일하다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 튜플 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "튜플은 유한개의 값들을 하나로 묶어 들고 다니는 값이며, \n",
    "아래 형태를 갖는다. \n",
    "\n",
    "```haskell\n",
    "(t1, t2, ..., tn)\n",
    "```\n",
    "\n",
    "단, `n`은 0이거나 2보다 큰 임의의 자연수이다. \n",
    "\n",
    "`T1`, `T2`, ..., `Tn`이 임의의 유형이고, `ti`가 유형 `Ti`를 갖는다면\n",
    "다음이 성립한다. \n",
    "\n",
    "```haskell\n",
    "(t1, t2, ..., tn) :: (T1, T2, ..., Tn)\n",
    "```\n",
    "\n",
    "길이가 0인 튜플을 **빈 튜플**empty tuple이라 부르며 `()`로 표기한다. \n",
    "\n",
    "**주의:** 길이가 1인 튜플은 허용되지 않는다. \n",
    "소괄호가 연산자 우선순위와 함수의 인자를 구분하는 데에 사용되기에 잘못하면 혼란을 야기할 수 있기 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "예를 들어 다음이 성립한다. \n",
    "\n",
    "```haskell\n",
    "('a', 'b') :: (Char, Char)\n",
    "('a', \"abc\", True) :: (Char, String, Bool)\n",
    "(('a', 'b'), True) :: ((Char, Char), Bool)\n",
    "(('a', 'b'), (\"abc\", True), False):: ((Char, Char), ([Char], Bool), Bool)\n",
    "```\n",
    "\n",
    "튜플에 포함된 항목들 각각 서로 다른 임의의 유형을 가지며, 유형에 대한 제한은 전혀 없다.\n",
    "즉, 임의의 조합으로 튜플을 생성할 수 있다. \n",
    "또한 길이에 따라 튜플의 유형도 함께 달라진다. \n",
    "\n",
    "빈 튜플을 제외한 나머지 튜플들의 길이는 2 이상이며,\n",
    "튜플의 길이는 튜플의 유형을 보면 바로 알 수 있다. \n",
    "즉, 튜플의 유형이 길이 정보를 함께 갖고 있으며, 모든 튜플의 길이는 유한하다. \n",
    "\n",
    "빈 튜플은 `unit`(유닛)이라 불리는 유형을 갖는 유일한 값이다.\n",
    "`unit` 유형은 빈 튜플과 동일한 방식인 `()`로 표기된다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>() :: ()</span>"
      ],
      "text/plain": [
       "() :: ()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "특정 유형의 값들과 특정 유형의 값을 서로 연결시켜주는 기능을 함수라 부른다. \n",
    "유형 `T1`의 값과 유형 `T2`의 값을 연결시켜주는 함수들의 유형을 `T1 -> T2`로 표기한다. \n",
    "\n",
    "만약 `f :: T1 -> T2`이면, \n",
    "`f`를 `T1` 유형의 값 `t`에 **적용**하여 생성된 `T2` 유형의 값을 `f t`로 표기한다.\n",
    "\n",
    "**주의:** \"함수를 호출한다\" 표현 대신에 \"함수를 적용한다\"를 사용한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 유형 적용 규칙"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수호출을 이론적으로 뒷받침하는 유형 적용 규칙은 다음과 같다. \n",
    "\n",
    "```haskell\n",
    " f :: T1 -> T2     t :: T1 \n",
    "--------------------------- (App)\n",
    "         f t :: T2\n",
    "```\n",
    "\n",
    "즉, 규칙 `(App)`가 묘사하는 함수 적용 방법은 다음과 같다.\n",
    "\n",
    "* `f` 함수의 유형은 `T1 -> T2`이다.\n",
    "* `t` 의 유형은 `T1`이다.\n",
    "* 그러면 `f t`의 유형은 `T2`이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 주의사항\n",
    "\n",
    "* 소개된 `(App)` 규칙은 하스켈에서 사용하는 **사실상 유일한** 유형 적용 규칙이다. \n",
    "* 나중에 배우는 **다형 유형**polymorphic type과 **클래스**class를 다룰 수 있으려면\n",
    "    `(App)` 규칙을 일반화해야 하지만 작동 방식은 기본적으로 동일하다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 유형의 우결합성"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "앞서 설명한 함수 유형 `T1 -> T2`는 충분히 일반화된 형태이다.\n",
    "하스켈에서 사용될 수 있는 어떤 함수의 유형도 위 형태로 표기된다. \n",
    "\n",
    "**주의:** 다형 유형이나 클래스가 사용되는 함수라면 유형이 좀 더 일반화되기는 하지만 \n",
    "형태는 기본적으로 동일하다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "예를 들어, 정수 두 개의 합을 계산하는 함수 `add`의 유형은 `Integer -> Integer -> Integer`이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "add :: Integer -> Integer -> Integer\n",
    "add x y = x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하지만 다음이 성립한다. \n",
    "\n",
    "```haskell\n",
    "Integer -> Integer -> Integer = Integer -> (Integer -> Integer)\n",
    "```\n",
    "\n",
    "즉, 함수 유형 생성자 역할을 하는 `->` 기호가 **우결합성**right associativity을 갖는다.\n",
    "\n",
    "따라서 `T1 = Integer`과 `T2 = Integer -> Integer`라 하면 다음이 성립한다.\n",
    "\n",
    "```haskell\n",
    "T1 -> T2 = Integer -> Integer -> Integer\n",
    "```\n",
    "\n",
    "우결합성의 일반적인 형태는 다음과 같다. \n",
    "\n",
    "```haskell\n",
    "T1 -> T2 -> T3 = T1 -> (T2 -> T3)\n",
    "T1 -> T2 -> T3 -> T4 = T1 -> (T2 -> (T3 -> T4))\n",
    "T1 -> T2 -> T3 -> T4 -> T5 = T1 -> (T2 -> (T3 -> (T4 -> T5)))\n",
    "...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 예제\n",
    "\n",
    "세 개의 숫자를 다음과 같이 계산하는 함수가 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "addExp :: Integer -> Integer -> Integer -> Integer\n",
    "addExp x y z = (x + y)^z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "즉, 첫 두 개 인자값을 더한 후에 셋째 인자를 이용한 거듭제곱(exponentiation)를 실행한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "-- (2 + 3)^2\n",
    "addExp 2 3 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 주의사항\n",
    "\n",
    "함수 유형을 정의할 때 결합성을 지정하기 위해 소괄호를 사용할 수 있다.\n",
    "경우에 따라 전혀 다른 역할의 유형을 선언할 수 있음에 주의해야 한다. \n",
    "\n",
    "예를 들어, `(Integer -> Integer) -> Integer` 유형의 다음 함수는 \n",
    "`Intege -> Integer` 유형의 함수 하나와 함께 적용되는 함수이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "app0 :: (Integer -> Integer) -> Integer\n",
    "app0 f = f 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`app0` 함수는 `Integer -> Integer` 유형의 함수 `f`를 인자와 함께 적용하면\n",
    "`f 0`를 계산한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 다형 유형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "리스트 자체는 길이에 대한 정보를 포함하지 않는다. \n",
    "리스트의 길이를 재는 도구가 따로 있으며 `length`라고 불린다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "length ['a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "length [1..10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "length [\"hello\", \"world!\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`length` 함수는 임의의 리스트의 길이를 계산한다.\n",
    "하지만 리스트는 항목들의 유형에 따라 다른 유형을 갖는다.\n",
    "예를 들어,\n",
    "\n",
    "```haskell\n",
    "length ['a', 'b', 'c']\n",
    "```\n",
    "\n",
    "와 \n",
    "\n",
    "```haskell\n",
    "length [1..10]\n",
    "```\n",
    "\n",
    "에서 사용되는 `length` 함수 인자의 유형이 다르다.\n",
    "`length`는 이것을 어떻게 처리할까?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`length` 함수는 **임의의 유형의 값들로 구성된 리스트**를 인자의 유형으로 사용해야 한다.\n",
    "따라서 '임의의 유형의 값들로 구성된 리스트'들의 유형이 필요하며,\n",
    "하스켈에서 제공하는 그런 유형은 \n",
    "\n",
    "```haskell\n",
    "[a] \n",
    "```\n",
    "\n",
    "이다. \n",
    "\n",
    "비슷한 방식으로 생각하면 `length` 함수의 유형이 아래와 같은 형태를 가져야 한다. \n",
    "\n",
    "```haskell\n",
    "[a] -> Int\n",
    "```\n",
    "\n",
    "여기서 `a`는 임의의 유형을 가리키는 **유형 변수**type variable이다.\n",
    "즉, 유형 변수는 임의의 유형을 가리키는 변수이다. \n",
    "`[a]` 또는 `[a] -> Int`처럼 유형 변수가 사용된 유형을 **다형 유형**이라 부른다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "임의의 유형을 대상으로 한다는 것을 표현하기 위해 아래와 같이\n",
    "`length` 함수의 유형을 표기한다.\n",
    "\n",
    "```haskell\n",
    "length :: forall a. [a] -> Int\n",
    "```\n",
    "\n",
    "위 정의의 의미는 다음과 같다.\n",
    "\n",
    "* 임의의 유형 `a`에 대해, `t`가 `a` 유형의 원소들로 이루어진 리스트이면, `length t`는 정수를 계산한다. \n",
    "\n",
    "따라서, `length`는 임의의 리스트에 대해 정수를 하나 계산하는데 그 정수가 리스트의 길이이다.\n",
    "\n",
    "**주의:** `length` 함수의 실제 유형은 좀 더 복잡하다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>length :: forall (t :: * -> *) a. Foldable t => t a -> Int</span>"
      ],
      "text/plain": [
       "length :: forall (t :: * -> *) a. Foldable t => t a -> Int"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하지만 여기서는 일단 `length :: [a] -> a` 정도만 기억하고 넘어가도 된다.\n",
    "`length` 함수의 진짜 유형을 이해하려면 먼저 클래스를 이해해야 하며, 이후에 다룰 것이다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 변수의 종류\n",
    "\n",
    "엄밀히 따지면 하스켈 프로그래밍언어에서 사용되는 변수는 세 종류이다. \n",
    "\n",
    "* 함수 변수: 함수를 정의할 때 사용되는 변수.\n",
    "* 람다항 변수: 표현식을 정의할 때 사용되는 변수. 표현식을 **람다항**이라고 부르기도 함.\n",
    "* 유형 변수: 유형을 정의할 때 사용되는 변수.\n",
    "\n",
    "위 구분은 하스켈 언어의 이론적 토대인 유형 이론(type theory)에서 사용되는 구분에 따른다. \n",
    "하지만 여기서는 유형 변수는 다형 유형을 선언할 때 사용된다는 정도로만 기억하면 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "다형 유형을 사용하는 몇 개의 함수들을 살펴본다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `head` 함수의 유형\n",
    "\n",
    "빈 리스트가 아닌 리스트의 첫재 항목을 계산하는 함수 `head` 함수도 임의의 유형의 리스트에 대해 작동한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head ['a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head [1..10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`head` 함수 역시 다형 유형을 사용하며 실제 유형은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>head :: forall a. [a] -> a</span>"
      ],
      "text/plain": [
       "head :: forall a. [a] -> a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t head"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "즉, 임의의 유형 `a`에 대해, `t`가 `a` 유형의 원소들로 이루어진 리스트이면, \n",
    "`head t`는 유형 `a`의 값을 계산하며, 그 값은 리스트의 첫째 항목이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:**\n",
    "`head`는 빈 리스트인 경우에는 오류가 발생한다. \n",
    "하지만 **빈 리스트가 아닌 경우에만 작동한다**를 하스켈 자체에서 표현할 수는 없으며, \n",
    "프로그램 작성자가 부분함수를 정의할 때 적절한 오류처리에 대해 항상 신경써야 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `take` 함수의 유형\n",
    "\n",
    "리스트에서 지정된 개수 만큼의 항목을 뽑아서 새로운 리스트를 계산한다. \n",
    "뽑는 기준은 0번 인덱스, 즉 맨 왼쪽에 위치한 값들을 선택한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"ab\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "take 2 ['a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,2,3]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "take 3 [1..10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "따라서 `take` 함수 역시 임의의 리스트를 대상으로 하며, 실제 유형은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>take :: forall a. Int -> [a] -> [a]</span>"
      ],
      "text/plain": [
       "take :: forall a. Int -> [a] -> [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `fst`와 `snd` 함수의 유형\n",
    "\n",
    "길이가 2인 튜플, 즉, 순서쌍의 첫째와 둘째 원소를 뽑아내는 함수가 각각 `fst`와 `snd` 라 불린다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fst ('a', 'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fst (2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snd ('a', 'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "snd (2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`fst`와 `snd` 역시 임의의 순서쌍에 대해 작동하므로 다형 유형을 지원한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>fst :: forall a b. (a, b) -> a</span>"
      ],
      "text/plain": [
       "fst :: forall a b. (a, b) -> a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t fst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>snd :: forall a b. (a, b) -> b</span>"
      ],
      "text/plain": [
       "snd :: forall a b. (a, b) -> b"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t snd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `zip` 함수의 유형\n",
    "\n",
    "임의의 두 리스트에 포함된 항목들을 차례대로 순서쌍으로 묶어서 새로운 리스트를 생성하는 함수를 `zip`이라 한다.\n",
    "일명 **지퍼 함수**라 불린다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1,'A'),(2,'B'),(3,'C')]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "zip [1, 2, 3] ['A', 'B', 'C']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "두 리스트의 길이가 다르면 짧은 길이에 맞추어 계산한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1,'A'),(2,'B'),(3,'C')]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "zip [1, 2, 3] ['A', 'B', 'C', 'D']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`zip` 함수 또한 임의의 리스트를 다룰 수 있어야 하므로 다형 유형의 함수이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>zip :: forall a b. [a] -> [b] -> [(a, b)]</span>"
      ],
      "text/plain": [
       "zip :: forall a b. [a] -> [b] -> [(a, b)]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 다형 함수\n",
    "\n",
    "다형유형을 갖는 함수를 다형 함수라 부른다. \n",
    "`head`, `take`, `fst`, `snd`, `zip` 등 모두 다형 함수이다. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Haskell",
   "language": "haskell",
   "name": "haskell"
  },
  "language_info": {
   "codemirror_mode": "ihaskell",
   "file_extension": ".hs",
   "name": "haskell",
   "pygments_lexer": "Haskell",
   "version": "8.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}