16FunctionalProg.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "tb1xXlJvWsRt3itp9gEIao",
     "type": "MD"
    }
   },
   "source": [
    "# 코틀린 교재(코틀린으로 배우는 함수형 프로그래밍)\n",
    "\n",
    "예전에 코딩을 지금처람 일반인들이 많이 하기 전\n",
    "\n",
    "- 함수형 프로그래밍 (특별하지 않은 방식, 수학에서 문제를 해결하는 방식대로)\n",
    "  - {1,2,3,4,...} 자연수를 차례로 나열\n",
    "  - 제곱을 하는 함수 f(x)=x^2 각각에 적용 \n",
    "  - {1,4,9,16,25,...} 이런 새로운 수열\n",
    "  - n번째까지 합을 구하고 싶다면 1+2+3+...+n^2 = ....\n",
    "- 명령형 프로그래밍 (메모리를 아끼기 위해 특화된 방식)\n",
    "  - x1=1, x2=2, x3=3, .... 메모리 많이들어\n",
    "  - 그러니까 x한개만 쓰자\n",
    "  - 즉, 시간에 따라서 x값을 변화시키자\n",
    "    - 처음에는 x = 1, v = 0\n",
    "    - 다음 단계에서는 x = 2, v = 1 = 0 + 1\n",
    "    - 다음 단계에서는 x = 3, v = 5 = 1 + 2^2\n",
    "    - 다음 단계에서는  ....\n",
    "    - x가 n인 것을 마지막 단계로 끝\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "ErC37Eu7dXBzKTGcV3KcC9",
     "type": "MD"
    }
   },
   "source": [
    "## 함수형 프로그래밍의 특징\n",
    "- 불변 속성(변수)을 기본으로 (반복문보다는 재귀함수로 표현하는 경향)\n",
    "- **고차함수** 활용 (함수가 일반적인 값이다)\n",
    "\n",
    "고차함수란 다른 함수를 인자로 넘겨받거나 함수를 리턴값으로 돌려주는 함수를 말함\n",
    "\n",
    "함수가 일반적인 값이라는 것은 함수를 표현하는 식(expression)이 있는 것이 당연\n",
    "   - 정수를 표현하는 수식이 있는 것처럼 (5, 2+3, 1+3+1, ...)\n",
    "   - 함수를 표현하는 식을 람다식이라 부름"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "i6meGdU3Pxld9mQBzJbD6n",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun add(x: Int, y: Int): Int {\n",
    "    return x + y\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "jHZg4pFKAsH4rgdG5OeElJ",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun add(x: Int, y: Int) = x + y // return만 하는 순수함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "4sECZjOwWx8zgPUuf1STtx",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "val f1: (Int,Int) -> Int = ::add // 함수를 참조하는 변수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "FUrOUajUahxwozU3khxHAY",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "val f2: (Int,Int) -> Int = { x, y -> x + y }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "whi9oYRtAhfaKOAVBWAH1c",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "e0fLms04GYtRt94tQMJSDT",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ x: Int, y: Int -> x + y }(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "SueuUnf8Syx8OogKAXCAMW",
     "type": "MD"
    }
   },
   "source": [
    "## 코틀린의 고차함수(higher-order function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "SR0QHOGnz1CHw8FWWWDaq3",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun apply2(x:Int, y:Int, f:(Int,Int)->Int) = f(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "YdWjsVSFFwnOnxTfV8ccPm",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply2(3, 2, ::add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "orRlwevNfRoZdG5dt1FR3s",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply2(3, 2, f2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "otcIZQtdoaL1Yf0cPuAL2C",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply2(3, 2, { x,y -> x+y })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "SCNLb82grKkGs6G76pEIqD",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply2(3, 2) { x,y -> x+y }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "uN4lDwwIShgRH6hrSrIdHs",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val list = listOf(1,2,3,4,5)\n",
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "HPTdtFOWwDlWLEN4feVT96",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list.map( { x -> x * x } )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "CRLhvPRg6DqLfVkdxLJkWW",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list.map { x -> x * x }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "eNiDuBkaYDPwt6w1Q097YE",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list.map { it * it }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3"
     ]
    }
   ],
   "source": [
    "print(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(kotlin.Int, kotlin.Int) -> kotlin.Int"
     ]
    }
   ],
   "source": [
    "print( { x:Int, y:Int -> x+y } )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fun Line_1.add(kotlin.Int, kotlin.Int): kotlin.Int"
     ]
    }
   ],
   "source": [
    "print( ::add )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "7MEfPhqgFtAKGhYufbjfp9",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// f를 n번 반복해서 적용하는 함수를 리턴값으로 돌려주는 고차함수\n",
    "// 0번 적용했을 때는 원래 입력값 그대로 리턴 (즉, 0번 적용은 항등함수)\n",
    "// n=3이면 g(x) = f(f(f(x))인 f3함수를 계산해 내는\n",
    "fun applyMany(n: Int, f: (Int)->Int): (Int)->Int {\n",
    "    fun g(x: Int): Int {\n",
    "        var v = x\n",
    "        for (i in 1..n) v = f(v)\n",
    "        return v\n",
    "    }\n",
    "    return ::g\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "y7mMRo2jlUF6GpE7oxlmzb",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// applyMany(5, { x -> x + 1 }) // 이걸 print하려고 하는데 jupyter가 뭔가 헤멘다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "applyMany(5, { x -> x + 1 })(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "1PN5yMqHKxdBfYS7yd0pnp",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// f를 n번 반복해서 적용하는 함수를 리턴값으로 돌려주는 고차함수\n",
    "// 0번 적용했을 때는 원래 입력값 그대로 리턴 (즉, 0번 적용은 항등함수)\n",
    "fun applyMany(n: Int, f: (Int)->Int): (Int)->Int {\n",
    "    // fun으로 정의한 함수가 return v로 끝난다면\n",
    "    // fun과 함수 이름을 제거하고 { ... -> ... } 마지막에 return 도 제거해 주면\n",
    "    // 형식상 람다식으로 구성\n",
    "    return { x: Int ->\n",
    "        var v = x\n",
    "        for (i in 1..n) v = f(v)\n",
    "        v\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun applyMany(n: Int, f: (Int)->Int) = { x: Int ->\n",
    "    var v = x\n",
    "    for (i in 1..n) v = f(v)\n",
    "    v\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(kotlin.Int) -> kotlin.Int"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "applyMany(5, { x -> x + 1 })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "applyMany(5, { x -> x + 1 })(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "wtxrn9fEyJSRt00ryILwYr",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "applyMany(0, { x -> x + 1 })(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "mP0Eyvy18IbQrz8IUb1Oqw",
     "type": "CODE"
    }
   },
   "source": [
    "$\\{ f^0, f^1, f^2, f^3, f^4,\\ldots\\}$ 이런 함수열에서 $f^i$가 필요하면 인덱스 $i$위치의 값을 찾아오면 됨 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ x:Int -> x }(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun f(x: Int) = x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "// 함수열\n",
    "// 입력이 g라는 함수라면 리턴값은 g를 한 결과에 f를 해주는 함수 (f와 g의 합성함수)\n",
    "// { g -> { x -> f(g(x)) } }\n",
    "val fseq = generateSequence({ x:Int -> x }, { g -> { x -> f(g(x)) } })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun applyMany(n: Int, f: (Int)->Int) =\n",
    "    generateSequence({ x:Int -> x }, { g -> { x -> f(g(x)) } }).take(n+1).last()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "320"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "applyMany(5, { x -> x * 2} )(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "kotlin.sequences.TakeSequence@676cf48"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fseq.take(6) // 앞에서부터 6개까지 컷"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "( fseq.take(6).last() )(10) // f를 5번 적용한 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": false,
     "hide_output_from_viewers": false,
     "node_id": "Q8gML2kCMx55liJa0U98AU",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// 정수 수열\n",
    "// generateSequence(x,f) = {x,f(x),f(f(x)),f(f(f(x))), ... }\n",
    "val iseq = generateSequence(0, { it + 1 }) // 무한을 지금 당장 계산하면 끝나지 않으니까 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "kotlin.sequences.TakeSequence@32a68f4f"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iseq.take(10) // 앞에서부터 10개까지 컷"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iseq.take(10).toList()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iseq.take(10).last()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 코틀린의 코루틴(coroutine)과 시퀀스\n",
    "함수는 딱 한번 리턴하고 현재 함수의 진행 상황은 깨끗이 잊어버림\n",
    "\n",
    "코루틴은 여러번 리턴하면서 리턴했던 곳에서 기다리고 있다가 재시작한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "// sequence는 코루틴을 받아서 코틀린 시퀀스를 만들어내주는 (고차)함수\n",
    "val evens = sequence { // 괄호 안의 내용이 코루틴\n",
    "    yield(0)\n",
    "    println(\"0까지 내보내고 다시 돌아왔다\")\n",
    "    yield(2)\n",
    "    println(\"2까지 내보내고 다시 돌아왔다\")\n",
    "    yield(4)\n",
    "    println(\"4까지 내보내고 다시 돌아왔다\")\n",
    "    yield(6)\n",
    "    println(\"6까지 내보내고 다시 돌아왔다\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0까지 내보내고 다시 돌아왔다\n",
      "2까지 내보내고 다시 돌아왔다\n",
      "4까지 내보내고 다시 돌아왔다\n",
      "6까지 내보내고 다시 돌아왔다\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evens.toList()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0까지 내보내고 다시 돌아왔다\n",
      "2까지 내보내고 다시 돌아왔다\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 2, 4]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evens.take(3).toList()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "datalore": {
   "base_environment": "default",
   "computation_mode": "JUPYTER",
   "package_manager": "pip",
   "packages": [],
   "version": 1
  },
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.6.20-dev-6372"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}