notebooks/pih01-Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 소개"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수\n",
    "\n",
    "* 인자 여러 개를 받아 하나의 값을 생성하는 일종의 계산과정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수 정의\n",
    "\n",
    "아래 모양을 따름.\n",
    "\n",
    "```haskell\n",
    "함수이름 매개변수1 매개변수2 ... 매개변수n = 함수본체\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 예제: 두 배 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "double x = x + x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "사용법은 다음과 같다.\n",
    "\n",
    "```haskell\n",
    "함수이름 인자1 인자2 ... 인자n\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 계산 과정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수가 인자와 함께 호출되면 아래 계산 과정을 통해 최종 결과를 생성한다.\n",
    "\n",
    "1. 함수 본체에서 `매개변수k`가 `인자k`에 의해 대체된다.\n",
    "1. 대체 결과가 숫자이면 계산을 멈춘다.\n",
    "1. 대체 결과 또다른 함수가 호출되면 위 과정을 반복한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "예를 들어, `double 5`의 계산과정은 다음과 같다.\n",
    "\n",
    "```haskell\n",
    "double 5 = 5 + 5\n",
    "         = 10\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 계산 순서"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`quadruple 4`은 두 가지 방식으로 계산이 가능하다.\n",
    "\n",
    "* 첫째: 안쪽에 있는 `double` 먼저 적용\n",
    "\n",
    "```haskell\n",
    "quadruple 4 = double (double 4) \n",
    "            = double (4 + 4)\n",
    "            = double 8\n",
    "            = 8 + 8\n",
    "            = 16\n",
    "```\n",
    "\n",
    "* 둘째: 바깥쪽에 있는 `double` 먼저 적용\n",
    "\n",
    "```haskell\n",
    "quadruple 4 = double (double 4) \n",
    "            = double 4 + double 4\n",
    "            = (4 + 4) + double 4\n",
    "            = 8 + double 4\n",
    "            = 8 + (4 + 4)\n",
    "            = 8 + 8\n",
    "            = 16\n",
    "```\n",
    "\n",
    "**주의:** \n",
    "* 첫째 방식은 적극적 계산법, 둘째 방식은 소극적 계산법을 보여줌.\n",
    "* 하스켈은 둘째 방식 사용.\n",
    "* 더 오래 걸리는 방식으로 보임.\n",
    "* 하지만 안 그런 경우도 있음. 이후에 예를 들어 설명함."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하스켈 함수의 계산결과는 과정이 다르더라도 도출된 결과는 항상 동일하다.\n",
    "반면에 명령형 언어에서는 계산 순서에 따라 값이 달라질 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### C 언어에서의 계산 순서 예제\n",
    "\n",
    "실제 C 언어에서 (+1) 연산을 언제 하느냐에 따라 다른 결과를 보여주는 \n",
    "두 개의 기호를 사용한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 첫째: (+1) 먼저 하기\n",
    "    ```c\n",
    "    #include <stdio.h>\n",
    "\n",
    "    int main(void) {\n",
    "      int n = 1;\n",
    "      int m;\n",
    "      m = n + (++n);\n",
    "      printf(\"m = %d, n = %d\\n\", m, n);\n",
    "      return 0;\n",
    "    }\n",
    "    ```\n",
    "\n",
    "    결과: `m = 3, n = 2`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 둘째: `+1` 나중에 하기\n",
    "\n",
    "    ```c\n",
    "    #include <stdio.h>\n",
    "\n",
    "    int main(void) {\n",
    "      int n = 1;\n",
    "      int m;\n",
    "      m = n + (n++);\n",
    "      printf(\"m = %d, n = %d\\n\", m, n);\n",
    "      return 0;\n",
    "    }\n",
    "    ```\n",
    "\n",
    "    결과: `m = 2, n = 2`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:** 실제로 위 코드를 돌리면 경고가 발생한다. \n",
    "`++` 기호를 사용하면 계산과정이 매우 혼란스러워지기 때문에 \n",
    "사용 자제를 권하는 것으로 보인다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 소극적(lazy) 계산법 vs. 적극적(eager) 계산법\n",
    "\n",
    "프로그래밍 언어마다 계산 방식이 다르다.\n",
    "동일한 함수가 언어에 따라 계산이 멈추기도 하고 그렇지 않기도 하다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**하스켈의 소극적 계산 예제**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nonStoppingFtn x = nonStoppingFtn (x + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:** \n",
    "* 계산법에 상관 없이 `nonStoppingFtn` 함수를 호출하면 절대로 정지하지 않는다.\n",
    "    즉, 어떤 프로그래밍 언어로 `nonStoppingFtn`을 구현 하더라도 실행하면 절대 멈추지 않는다.\n",
    "* 하지만 다음 `stoppingFtn`과 함께 조합되어 사용된 `sometimesStoppingFtn`은 호출 될 경우\n",
    "    사용되는 언어의 컴파일러/인터프리터에 따라 정지여부가 달라진다. \n",
    "    하스켈의 경우는 특정 값을 생성하고 정지하지만, 파이썬의 경우는 그렇지 않음을 아래에서 보여준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "stoppingFtn x y = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sometimesStoppingFtn x = stoppingFtn x (nonStoppingFtn x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sometimesStoppingFtn 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sometimesStoppingFtn 2` 의 계산과정은 다음과 같다.\n",
    "\n",
    "```haskell\n",
    "sometimesStoppingFtn 2 = stoppingFtn 2 nonStoppingFtn(2)\n",
    "                       = 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**파이썬의 적극적 계산 예제**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "파이썬의 경우 `sometimesStopping` 함수는 실행을 멈추지 않는다.\n",
    "실제로 아래와 같이 정의하고 실행해 보면 바로 확인할 수 있다.\n",
    "\n",
    "```python\n",
    "def nonStoppingFtn(x):\n",
    "    return nonStoppingFtn(x + 1)\n",
    "\n",
    "def stoppingFtn(x, y):\n",
    "    return x\n",
    "\n",
    "def sometimesStoppingFtn(x):\n",
    "    return stoppingFtn(x, nonStoppingFtn(x))\n",
    "\n",
    "sometimesStoppingFtn(2)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "파이썬에서 `sometimesStoppingFtn(2)`의 계산과정은 다음과 같다.\n",
    "\n",
    "```python\n",
    "sometimesStoppingFtn(2) = stoppingFtn(2, nonStoppingFtn(2))\n",
    "                        = stoppingFtn(2, nonStoppingFtn(3))\n",
    "                        = stoppingFtn(2, nonStoppingFtn(4))\n",
    "                        = stoppingFtn(2, nonStoppingFtn(5))\n",
    "                        = ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수 호출과 인자 개수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수를 적용할 때 인자가 모자라더라도 반드시 오류가 발생하는 것은 아니다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 예제: 덧셈 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "인자를 두 개 모두 받으면 계산을 실행한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "addition x y = x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "addition 3 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "반면에 인자를 하나만 받으면 그 결과는 인자를 하나 받는 함수가 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "add3 = addition 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "add3 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수형 언어란?\n",
    "\n",
    "* 함수형 프로그래밍: 함수에 인자를 적용하여 계산을 실행하는 프로그래밍 기법\n",
    "* 함수형 언어: 함수형 프로그래밍을 지원하는 프로그래밍 언어"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 예제: 1에서 10까지 더하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 파이썬: 변수 할당 활용, 즉, `total`가 `i`에 **저장된 값**이 반복적으로 변함.\n",
    "\n",
    "```python\n",
    "total = 0;\n",
    "for i in range(1,11):\n",
    "    total = total + i\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 하스켈: 연속된 함수 호출\n",
    "\n",
    "```haskell\n",
    "sum [1..10] = sum [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "            = 1 + sum [2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "            = 1 + 2 + sum [3, 4, 5, 6, 7, 8, 9, 10]\n",
    "            = 1 + 2 + 3 + sum [4, 5, 6, 7, 8, 9, 10]\n",
    "            = ...\n",
    "            = 1 + 2 + 3 + ... + 10\n",
    "            = 55\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 하스켈 언어의 특징"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "타 언어와 비교했을 때 하스켈 언어의 특징은 다음과 같다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 간결성\n",
    "    * 간결한 문법\n",
    "    * 하스켈 프로그램이 타 언어 프로그램보다 2~10배 정도 간결하게 구현 가능하다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 강력한 유형 체계(type system)\n",
    "    * 사용되는 모든 대상의 유형(types)을 미리 확인하여 프로그램의 오류를 예방한다.\n",
    "    * 유형 확인은 유형 추론(type inference) 기술로 가능.\n",
    "    * 다형성(polymorphism) 및 함수 중복정의(overloading) 지원"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트 조건제시법(list comprehension)\n",
    "    * 기존의 리스트를 이용하여 새로운 리스트 생성\n",
    "    * 보다 간결한 코드 생성 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 재귀 함수(recursive functions)\n",
    "    * 재귀를 이용하여 반복문(loop) 처리\n",
    "        * `while`, `for` 반복문 없음\n",
    "    * 인자에 대한 패턴매칭(pattern matching)과 감시자(guard, 가드) 활용 지원"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 고계 함수(higer-order functions)\n",
    "    * 함수가 타 함수의 인자 또는 결과물로 사용될 수 있음\n",
    "    * 패턴 매칭과 함께 매우 유용한 기능 제공\n",
    "    * 도메인 특화 프로그램 작성에 유용"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 부작용(side-effects) 함수\n",
    "    * 하스켈은 순수한 함수형 프로그래밍 언어임. \n",
    "        즉, 모든 함수는 인자를 받아 결과를 생성하는 일 이외에는 아무 것도 하지 않음.\n",
    "        즉, 동일한 인자에 대해 항상 동일한 값을 생성.\n",
    "    * 모나드(monads), 적용자(applicatives)를 활용하여 키보드 입력, 스크린 출력 등을 다룰 수 있음."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 제네릭 함수\n",
    "    * 제네릭 프로그래밍: 특정 유형이 아닌 여러 유형에 대해 공통적으로 적용될 수 있는 프로그램 작성 기법\n",
    "    * 제네릭 함수: 특정 클래스에 속한 유형의 값들에 대해 일괄적으로 적용 가능한 함수\n",
    "    * 하스켈에서 타 언어에 비해 보다 일반적이며 강력한 제네릭 함수 정의 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 소극적 계산(lazy evaluation)\n",
    "    * 결과가 요구될 때만 계산 실행\n",
    "    * 특징\n",
    "        * 가능한 모든 경우에 프로그램 종료 가능\n",
    "        * 모듈 형식 프로그래밍 지원\n",
    "        * 무한 집합, 무하 스트링, 무한 리스트 등 무한 구조(infinite structure) 활용 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 방정식 논증(equational reasoning)\n",
    "    * 하스켈에서는 모든 게 함수의 계산으로 처리됨.\n",
    "    * 프로그램의 실행과정은 연속된 방정식으로 간주 가능.\n",
    "    * 이 방법을 이용하여 함수의 성질에 대한 논증 및 검증된 프로그램 구현 가능."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 하스켈의 역사"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1030년대: 람다 대수(lambda calculus)\n",
    "    * 개발자: 알론조 처치(Alonzo Church)\n",
    "    * 함수 계산 이론"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1950년대: 리스프(Lisp)\n",
    "    * 개발자: 존 맥카시(John McCarthy)\n",
    "    * 최초 함수형 언어\n",
    "    * 람다 대수 일부 활용\n",
    "    * 변수 할당 유지"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1960년대: ISWIM\n",
    "    * 개발자: 피터 랜딘(Peter Landin)\n",
    "    * 최초 순수 함수형 언어\n",
    "    * 람다 대수에 기초\n",
    "    * 변수 할당 없음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1970년대: FP\n",
    "    * 개발자: 존 백커스(John Backus)\n",
    "    * 함수형 언어\n",
    "    * 고계 함수(higher-order functions) 지원\n",
    "    * 프로그램에 대한 추론 지원"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1970년대: ML\n",
    "    * 개발자: 로빈 밀르너(Robin Milner) 중심\n",
    "    * 최초 현대 함수형 언어\n",
    "    * 유형 추론(type inference) 지원\n",
    "    * 다형 유형(polymorphic types) 지원 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1970년대 ~ 1980년대: Miranda \n",
    "    * 개발자: 데이비드 터너(David Turner)\n",
    "    * 다수의 소극적(lazy) 함수형 언어 개발"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1987년: 하스켈(Haskell) 언어 개발 시작\n",
    "    * 표준 소극적 순수 함수형 언어\n",
    "    * 국제 하스켈 위원회 주도"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 1990년대: 유형 클래스(type classes)와 모나드(monads) 개발\n",
    "    * 필립 와들러(Phillip Wadler) 중심\n",
    "    * 하스켈 언어의 핵심 기능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 2003년: 하스켈 보고서(Haskell Report)\n",
    "    * 하스켈 위원회가 하스켈 안정 버전 공개\n",
    "    * 2010년에 업데이트"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 2010년 이후: 하스켈 플랫폼\n",
    "    * 하스켈 표준 배포\n",
    "    * 라이브러리 지원\n",
    "    * 다양한 새 특성 지원\n",
    "    * 개발 툴 지원\n",
    "    * 산업체 활용\n",
    "    * 타 프로그래밍 언어에 영향\n",
    "        * 파이썬, 자바스크립트 등 많은 프로그래밍 언어가 함수형 프로그래밍 지원"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 하스켈 프로그래밍 예제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 리스트 항목 더하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 패터 매칭과 재귀로 `sum` 함수 정의하기\n",
    "\n",
    "하스켈에서 `sum` 함수를 기본으로 제공한다.\n",
    "따라서 약간 다른 이름으로 `sum` 함수를 구현한다."
   ]
  },
  {
   "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><div class=\"suggestion-name\" style=\"clear:both;\">Use foldr</div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Found:</div><div class=\"highlight-code\" id=\"haskell\">sum_ [] = 0\n",
       "sum_ (n : ns) = n + sum_ ns</div></div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Why Not:</div><div class=\"highlight-code\" id=\"haskell\">sum_ ns = foldr (+) 0 ns</div></div>"
      ],
      "text/plain": [
       "Line 1: Use foldr\n",
       "Found:\n",
       "sum_ [] = 0\n",
       "sum_ (n : ns) = n + sum_ ns\n",
       "Why not:\n",
       "sum_ ns = foldr (+) 0 ns"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum_ []= 0\n",
    "sum_ (n:ns) = n + sum_ ns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:** 위 경고문은 `foldr`을 사용하라고 추천하고 있음."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sum_` 함수는 재귀(recursion)를 이용하여 정의되었다.\n",
    "또한 임의의 리스트에 대해 `sum_` 함수는 항상 멈추게 되어 있다(왜 그럴까?).\n",
    "앞으로 재귀함수를 자주 만날 것인데, 경우에 따라 멈추지 않는 재귀함수도 다뤄야 할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum_ [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum_ [1..10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 유형(types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하스켈에 다루는 모든 대상은 유형(type)을 갖는다.\n",
    "타 프로그래밍언어에서 제공하는 자료형(data types) 보다 일반적인 개념이며,\n",
    "단순히 어떤 데이터만 유형을 갖는 것이 아니라 하스켈에서 다루는 모든 것이 유형을 갖는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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'>sum_ :: forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a</span>"
      ],
      "text/plain": [
       "sum_ :: forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type sum_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:** \n",
    "* `Num`: 숫자 집합들의 클래스. 정수, 자연수, 유리수, 실수 등.\n",
    "* `forall p. Num p => [p] -> p`의 의미: \n",
    "    임의의 유형 `p` 에 대해, `p`가 `Num` 클래스에 속하면\n",
    "    `sum_` 함수는 유형 `p`의 리스트를 인자로 받아, `p` 유형의 값을 하나 생성한다.\n",
    "* 결론적으로 다형성(polymorphism)과 클래스를 활용한다.\n",
    "    따라서 `sum_` 함수는 정수 뿐만 아니라, 자연수, 유리수, 실수 등에 대해서도 동일하게 작동한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "앞서 정의했던 덧셈 함수의 유형은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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'>addition :: forall a. Num a => a -> a -> a</span>"
      ],
      "text/plain": [
       "addition :: forall a. Num a => a -> a -> a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type addition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`add3`의 유형에 주의한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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'>add3 :: forall a. Num a => a -> a</span>"
      ],
      "text/plain": [
       "add3 :: forall a. Num a => a -> a"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type add3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수의 유형 정보을 이용하면 함수를 실행하기 전에 문제를 자동을 검출할 수 있다.\n",
    "예를 들어 문자열들의 리스트를 `sum_` 함수의 인자로 사용하면 바로 오류가 발생된다.\n",
    "문자열은 `Num` 클래스에 속하지 않기 때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "header": "MessageHeader {mhIdentifiers = [\"333d6c52-42a7-473f-85e0-1181d7cc20d2\"], mhParentHeader = Just (MessageHeader {mhIdentifiers = [\"333d6c52-42a7-473f-85e0-1181d7cc20d2\"], mhParentHeader = Nothing, mhMetadata = Metadata (fromList [(\"deletedCells\",Array []),(\"cellId\",String \"85d5dcad-5e6d-4098-912b-d53463abc0eb\")]), mhMessageId = UUID {uuidToString = \"5270e984-40a5-4ce1-8de2-cc92c72ca0b4\"}, mhSessionId = UUID {uuidToString = \"333d6c52-42a7-473f-85e0-1181d7cc20d2\"}, mhUsername = \"\", mhMsgType = ExecuteRequestMessage}), mhMetadata = Metadata (fromList []), mhMessageId = UUID {uuidToString = \"889318cd-105d-4fc1-bf74-b148c980e555\"}, mhSessionId = UUID {uuidToString = \"333d6c52-42a7-473f-85e0-1181d7cc20d2\"}, mhUsername = \"\", mhMsgType = ExecuteErrorMessage}",
     "output_type": "error",
     "traceback": [
      "<interactive>:1:1: error:\n    • No instance for (Num Char) arising from a use of ‘sum_’\n    • In the expression: sum_ ['a', 'b', 'c']\n      In an equation for ‘it’: it = sum_ ['a', 'b', 'c']"
     ]
    }
   ],
   "source": [
    "sum_ ['a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위 오류는 `Num Char`가 성립하지 않는다. 즉 문자열 유형은 `Num` 클래스에 포함되지 않음을  경고한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 리스트 정렬하기\n",
    "\n",
    "정렬함수를 단순명료하게 정의할 수 있다.\n",
    "둘째 인자는 오름차순/내림차순을 결정한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- qsort_ :: Ord a => [a] -> Bool -> [a]\n",
    "qsort_ [] _    = []\n",
    "qsort_ (x:xs) False = qsort_ ys False ++ [x] ++ qsort_ zs False\n",
    "                        where\n",
    "                            ys = [a | a <- xs, a <= x]\n",
    "                            zs = [b | b <- xs, b > x]\n",
    "qsort_ (x:xs) True = qsort_ zs True ++ [x] ++ qsort_ ys True\n",
    "                        where\n",
    "                            ys = [a | a <- xs, a <= x]\n",
    "                            zs = [b | b <- xs, b > x]                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`qsort_`의 유형은 다음과 같다.\n",
    "\n",
    "**주의:** `:type` 대신에 `:t` 명령문을 사용해도 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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'>qsort_ :: forall a. Ord a => [a] -> Bool -> [a]</span>"
      ],
      "text/plain": [
       "qsort_ :: forall a. Ord a => [a] -> Bool -> [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":t qsort_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:**\n",
    "\n",
    "* `++`: 리스트 덧셈 계산자, 즉, 두 리스트 이어붙이기\n",
    "* `qsort_`는 재귀로 정의됨."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "오름차순 정렬함수 `qsort`와 내림차순 정렬함수 `qsortReverse`를 다음과 같이 정의할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "qsort xs = qsort_ xs False\n",
    "qsortReverse xs = qsort_ xs True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "숫자들의 리스트 정렬하기 예제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,2,3,4,5]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qsort [5, 2, 4, 3, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5,4,3,2,1]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qsortReverse [5, 2, 4, 3, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`qsort_`, `qsort`, `qsortReverse` 타입은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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'>qsort_ :: forall a. Ord a => [a] -> Bool -> [a]</span>"
      ],
      "text/plain": [
       "qsort_ :: forall a. Ord a => [a] -> Bool -> [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type qsort_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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'>qsort :: forall a. Ord a => [a] -> [a]</span>"
      ],
      "text/plain": [
       "qsort :: forall a. Ord a => [a] -> [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type qsort"
   ]
  },
  {
   "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'>qsortReverse :: forall a. Ord a => [a] -> [a]</span>"
      ],
      "text/plain": [
       "qsortReverse :: forall a. Ord a => [a] -> [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type qsortReverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:**\n",
    "* `Ord`: 순서(ordering)를 지원하는 집합들의 클래스\n",
    "* 정수, 실수, 문자(`Char`), 문자열([`Char`]) 유형 등이 `Ord` 클래스에 속한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문자열들의 리스트 정렬하기 예제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"abc\",\"ade\",\"cde\"]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qsort [\"abc\", \"cde\", \"ade\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"cde\",\"ade\",\"abc\"]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qsortReverse [\"abc\", \"cde\", \"ade\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 연속적인 활동(actions) 처리하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "입출력 활동(actions)을 연속적으로 처리하는 함수 `seqn`을 아래와 같이 정의할 수 있다.\n",
    "\n",
    "**주의:** 활동(actions)은 입출력과 같이 부작용을 수반하는 함수의 호출을 의미한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "actionSeqn :: [IO a] -> IO [a]\n",
    "actionSeqn [] = return []\n",
    "actionSeqn (act:acts) = do x <- act\n",
    "                           xs <- actionSeqn acts\n",
    "                           return (x:xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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'>actionSeqn :: forall a. [IO a] -> IO [a]</span>"
      ],
      "text/plain": [
       "actionSeqn :: forall a. [IO a] -> IO [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type actionSeqn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위 함수는 입출력(input/output) 함수의 리스트를 인자로 받아 \n",
    "각 활동의 결과로 이루어진 값들의 리스트를 출력한다.\n",
    "예를 들어, 문자 세 개를 입력 받아, 화면에 출력하는 활동은 아래와 같이 구현된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\n\\na\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "actionSeqn [getChar, getChar, getChar]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"bc\\n\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "actionSeqn [getChar, getChar, getChar]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:** `actionSeqn`이 주피터 노트북에서 작동하는 방식과 일반 편집기에서 작동하는 방식이 다르다.\n",
    "이에 대해 개발환경의 다르기에 그런 것 같다는 추정만 가능하다.\n",
    "또한 repl.it 사이트에서는 입출력(IO)가 제대로 작동하지 않아 보인다.\n",
    "이유는 모름."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 일반화 시키기\n",
    "\n",
    "입출력 이외에 다른 활동을 연속적으로 처리하는 함수로 일반화 시킬 수 있다.\n",
    "실제로 `seqn`의 유형을 지정하지 않으면 하스켈의 유형 추론을 통해 자동으로 일반화된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "actionSeqn [] = return []\n",
    "actionSeqn (act:acts) = do x <- act\n",
    "                           xs <- actionSeqn acts\n",
    "                           return (x:xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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'>actionSeqn :: forall (m :: * -> *) a. Monad m => [m a] -> m [a]</span>"
      ],
      "text/plain": [
       "actionSeqn :: forall (m :: * -> *) a. Monad m => [m a] -> m [a]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type actionSeqn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위 결과는 임의의 **모나드**에 대해 `actionSeqn` 함수가 작동함을 보여준다. \n",
    "그리고 `IO`는 입출력(input/output)을 담당하는 특별한 모나드이다.\n",
    "\n",
    "모나드로 구현 가능한 활용:\n",
    "\n",
    "* 입출력\n",
    "* 저장된 값 수정하기,\n",
    "* 성공에 실패하기(fail to succeed), \n",
    "* log 파일에 추가하기 등"
   ]
  }
 ],
 "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
}