Chap01c.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "74klxS7M8AeeLeT1D0RrtZ",
     "type": "MD"
    }
   },
   "source": [
    "# 01. Getting Started with Kotlin (Part C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "iJ04LdOUXwXwzAU0XO3Wcp",
     "type": "MD"
    }
   },
   "source": [
    "## Flow controls\n",
    "조건문, 반복문, 함수 등의 **흐름 제어**(flow controls)와 관련된 대해 간단히 살펴본다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "tF4vy936KxC9ewWIrUjyqL",
     "type": "MD"
    }
   },
   "source": [
    "## `if` and `else` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "ZWID0JOT2EGZTS7YRbM4Hm",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v is positive\n"
     ]
    }
   ],
   "source": [
    "val v = 3 // 다른 수로 바꾸어 가며 실험해 보라\n",
    "\n",
    "if (v > 0) {\n",
    "    println(\"v is positive\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "SG5GuYTmVvYPPnOQb2ScCo",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v is positive\n"
     ]
    }
   ],
   "source": [
    "val v = 3 // 다른 수로 바꾸어 가며 실험해 보라\n",
    "\n",
    "if (v > 0) {\n",
    "    println(\"v is positive\")\n",
    "} else {\n",
    "    println(\"v is not positive\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "CaCfHHVDcVz57YzgD4sOv7",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v is positive\n"
     ]
    }
   ],
   "source": [
    "val v = 3 // 다른 수로 바꾸어 가며 실험해 보라\n",
    "\n",
    "if (v > 0) {\n",
    "    println(\"v is positive\")\n",
    "} else if (v < 0) {\n",
    "    println(\"v is negative\")\n",
    "} else {\n",
    "    println(\"v is zero\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "QZYiPAiUCC6Z5rSy6Yu1ib",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v is positive\n"
     ]
    }
   ],
   "source": [
    "val v = 3 // 다른 수로 바꾸어 가며 실험해 보라\n",
    "// 연쇄적인 조건문을 when문으로 바꾸면 깔끔\n",
    "when { // 지난 번에 봤던 when문과 달리 when 키워드 바로 다음에 괄호가 없음\n",
    "    v > 0 -> println(\"v is positive\")\n",
    "    v < 0 -> println(\"v is negative\")\n",
    "    else  -> println(\"v is zero\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "HmqR4d215hTtUHFtDYnUh7",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// 논리 연산자 &&, ||, ! 라던가 비교 연산자 ==, !=, <=, >= 등을 활용하는 조건문에 대해서는 스스로 책을 보며 학습"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "AsxQpPXtDfQYiZc15T9zBF",
     "type": "MD"
    }
   },
   "source": [
    "## `if` as an expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "NVDlXzTgASuP9tyUKYi8Ya",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "val a = 3\n",
    "val b = 2\n",
    "\n",
    "val max = if (a > b) a else b\n",
    "\n",
    "println(max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "1NzZmAgpeOhJVVdZHbF1BM",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Line_19.jupyter.kts (4:11 - 13) 'if' must have both main and 'else' branches if used as an expression"
     ]
    },
    {
     "ename": "Syntax Error",
     "evalue": "Syntax Error: 'if' must have both main and 'else' branches if used as an expression",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------",
      "Traceback (most recent call last)",
      "Syntax Error: 'if' must have both main and 'else' branches if used as an expression"
     ]
    }
   ],
   "source": [
    "val a = 3\n",
    "val b = 2\n",
    "\n",
    "val max = if (a > b) a // else b // 식으로 활용되는 경우 else 부분을 빼먹으면 오류\n",
    "\n",
    "println(max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "ZnQHPDUqo6X3HVbwprxZON",
     "type": "MD"
    }
   },
   "source": [
    "## `when` expression\n",
    "지금까지 예제 코드에서 이미 등장했지만 다시 한번 정리해 보자\n",
    "\n",
    "`if`와 마찬가지로 `when`도 문장(statement)을 구성할 수도 있고 식(experssion)을 구성할 수도 있다.\n",
    "\n",
    "여기서는 식(expression)의 경우로만 예시 코드를 작성해 보았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "O18kg6F4YoZr6YS8sFlGXE",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TUE\n"
     ]
    }
   ],
   "source": [
    "// 원래 이런 건 enum을 써야 하지만 아직 enum을 설명하지 않았으므로 ...\n",
    "\n",
    "val day = 2 // 다른 정수값으로 바꿔가며 실행해 보라\n",
    "\n",
    "val dayStr = when (day) {\n",
    "    1 -> \"MON\"\n",
    "    2 -> \"TUE\"\n",
    "    3 -> \"WED\"\n",
    "    4 -> \"THR\"\n",
    "    5 -> \"FRI\"\n",
    "    6 -> \"SAT\"\n",
    "    7 -> \"SUN\"\n",
    "    else -> \"\" // invalid day value\n",
    "}\n",
    "\n",
    "println(dayStr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "Y5OMvzR7dV4zCC4nwARNEo",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weekday\n"
     ]
    }
   ],
   "source": [
    "val dayStr = \"MON\" // 다른 값으로 바꿔가며 실행해 보라\n",
    "\n",
    "val dayType = when (dayStr) {\n",
    "    \"MON\", \"TUE\", \"WED\", \"THR\", \"FRI\" -> \"weekday\" // 여러 가지 경우를 한번에 처리\n",
    "    \"SAT\", \"SUN\"                      -> \"weekend\" // 여러 가지 경우를 한번에 처리\n",
    "    else -> \"\" // invalid day value\n",
    "}\n",
    "\n",
    "println(dayType)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "9AU2AsqQM2jsxUp6JFFMqf",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weekday\n"
     ]
    }
   ],
   "source": [
    "val day = 2 // 다른 정수값으로 바꿔가며 실행해 보라\n",
    "\n",
    "val dayType = when (day) {\n",
    "    in 1..5 -> \"weekday\" // 여러 가지 경우를 범위(range)로 한번에 처리\n",
    "    6, 7    -> \"weekend\"\n",
    "    else -> \"\" // invalid day value\n",
    "}\n",
    "\n",
    "println(dayType)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "SWDiIBq98bA9NKl84EOqaJ",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class kotlin.ranges.IntRange\n",
      "1\n",
      "5\n",
      "1\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "var range = 1..5\n",
    "\n",
    "println( range::class )\n",
    "println( range.first )\n",
    "println( range.last )\n",
    "println( range.step )\n",
    "println( range.toList() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "o7iy92FinmNRzu3YmD87Oc",
     "type": "MD"
    }
   },
   "source": [
    "## `while` loop, `do` `while` loop\n",
    "`while` 반목문과 `do` `while` 반목문은 스스로 학습"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "btt0vMS7vMaMWEH0AMoAh0",
     "type": "MD"
    }
   },
   "source": [
    "## `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "wR1abFs9YbZehPMJAQ9LZT",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 1\n",
      "i = 2\n",
      "i = 3\n",
      "i = 4\n",
      "i = 5\n"
     ]
    }
   ],
   "source": [
    "var range = 1..5\n",
    "\n",
    "for (i in range) {\n",
    "    println(\"i = $i\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "kTujVBfQJNF5BzZpZt1vc3",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v = 1\n",
      "v = 3\n",
      "v = 5\n",
      "v = 9\n"
     ]
    }
   ],
   "source": [
    "var list = listOf(1,3,5,9)\n",
    "\n",
    "for (v in list) {\n",
    "    println(\"v = $v\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "th3oox8PU2mPwaNsO45Mk1",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i, j = 1, 1\n",
      "i, j = 1, 2\n",
      "i, j = 1, 3\n",
      "i, j = 2, 1\n",
      "i, j = 2, 2\n",
      "i, j = 2, 3\n"
     ]
    }
   ],
   "source": [
    "for (i in 1..2) {\n",
    "    for (j in 1..3) {\n",
    "        println(\"i, j = $i, $j\")\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "v4HGIYwzBT0RUzXD0T3v4e",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "j = 1\n",
      "j = 2\n"
     ]
    }
   ],
   "source": [
    "for (j in 1..4) {\n",
    "    println(\"j = $j\")\n",
    "    if (2 == j) break // 반복문을 빠져나감\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "3Nm85GPPAA1iWwGwbhJJr7",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i, j = 1, 1\n",
      "i, j = 2, 1\n",
      "i, j = 2, 2\n",
      "i, j = 3, 1\n",
      "i, j = 3, 2\n",
      "i, j = 3, 3\n",
      "i, j = 4, 1\n",
      "i, j = 4, 2\n",
      "i, j = 4, 3\n",
      "i, j = 4, 4\n"
     ]
    }
   ],
   "source": [
    "for (i in 1..4) {\n",
    "    for (j in 1..4) {\n",
    "        println(\"i, j = $i, $j\")\n",
    "        if (i == j) break // 반복문을 한겹만 빠져나감\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "d5BVOQtIRLt3wSPMvAKHGv",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i, j = 1, 1\n",
      "i, j = 1, 2\n",
      "i, j = 1, 3\n",
      "i, j = 1, 4\n",
      "i, j = 2, 1\n",
      "i, j = 2, 2\n",
      "i, j = 3, 1\n",
      "i, j = 3, 2\n",
      "i, j = 3, 3\n",
      "i, j = 3, 4\n",
      "i, j = 4, 1\n",
      "i, j = 4, 2\n",
      "i, j = 4, 3\n",
      "i, j = 4, 4\n"
     ]
    }
   ],
   "source": [
    "for (i in 1..4) {\n",
    "    for (j in 1..4) {\n",
    "        println(\"i, j = $i, $j\")\n",
    "        if (i==2 && j==2) break // 반복문을 한겹만 빠져나감\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "aQ4WKrYstESDkZpTzUtU2x",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i, j = 1, 1\n",
      "i, j = 1, 2\n",
      "i, j = 1, 3\n",
      "i, j = 1, 4\n",
      "i, j = 2, 1\n",
      "i, j = 2, 2\n"
     ]
    }
   ],
   "source": [
    "outer@ for (i in 1..4) {\n",
    "    inner@ for (j in 1..4) {\n",
    "        println(\"i, j = $i, $j\")\n",
    "        if (i==2 && j==2) break@outer // 꼬리표 붙인 반복문 바깥으로 빠져나감\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "AoI0Lt3sj0Ivpdpf6oNxCx",
     "type": "MD"
    }
   },
   "source": [
    "## What is a function?\n",
    "프로그래밍에서 함수를 어떻게 활용하는지는 1학년 때 이미 해봐서 알고 있어야 하므로 자세한 설명은 생략"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "xC2wCFPOyI2qXgbb3XK20o",
     "type": "MD"
    }
   },
   "source": [
    "## Functions no return type\n",
    "\n",
    "책에서는 *리턴 타입이 없는* 함수라고 이야기하고 있는데 ...\n",
    "\n",
    "정확히 말하지만 **리턴 타입을 생략할 수 있는** 함수라고 이야기해야 맞다.\n",
    "\n",
    "Kotlin에서 리턴 타입이 `Unit`인 경우 함수를 작성할 때 리턴 타입 생략 가능\n",
    "\n",
    "참고로, Java에서 `void` 타입이 Kotlin에서 `Unit` 타입에 해당한다.\n",
    "\n",
    "이런 함수들은 결과값 계산이 목적이 아닌 함수 호출의 부수적인 효과에 해당하는 함수 몸체의 명령문들을 실행시키는 것이 오히려 주 목적이 된다.\n",
    "\n",
    "이렇듯 주객이 전도된 `Unit`이 리턴 타입인 함수를 **프로시저**(procedure)라고 부르기도 한다.\n",
    "\n",
    "C나 Java에서 `void`라는 이름의 타입은 정말로 개념없는 이름이다.\n",
    "보통 수학에서 void라고 하면 공집합에 해당하는데, 리턴 타입 즉 공역(codomain)이 공집합은 함수는 존재하지 않는다.\n",
    "리턴 타입이 유일무이하게 하나이면 *항상 똑같은 값을 리턴할 것이 뻔하므로* **리턴값이 무엇인지 신경쓸 필요가 없는** 함수가 된다.\n",
    "그래서 딱 하나의 원소로 이루어진 크기가 1인 집합을 나타내는 `Unit`이라는 이름이 이러한 용도로 쓰기에는 개념있는 타입 이름인 것이다.\n",
    "다행히도 Kotlin은 개념있는 선택을 했다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "1IYFppbvXUZuf7p6gMaB2L",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun sayHello1(): Unit {\n",
    "    println(\"Hello1 from Kotlin\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "nrId2dpU8Yn54Quuj5OF9j",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun sayHello2() {\n",
    "    println(\"Hello2 from Kotlin\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "DQGmgs2TwHHlnVesCR0HWk",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello1 from Kotlin\n",
      "Hello2 from Kotlin\n"
     ]
    }
   ],
   "source": [
    "sayHello1()\n",
    "sayHello2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "oRWWYdjox9WX69qqWGcsRR",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun hello1From(name: String): Unit {\n",
    "    println(\"Hello1 from $name\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "piwk3wWc0mdN0laoHkg8ui",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun hello2From(name: String) {\n",
    "    println(\"Hello2 from $name\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "9DWqrJQSp2rVUz8rDBxJhf",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello1 from Jupyter\n",
      "Hello2 from Jupyter\n"
     ]
    }
   ],
   "source": [
    "hello1From(\"Jupyter\")\n",
    "hello2From(\"Jupyter\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "Ha2G2xZF3X7AcY7XVLsA3s",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun msgFrom(msg: String, name: String) {\n",
    "    println(\"$msg from $name\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "aIksrTenOh3egL8nSZHi0y",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from OOP\n"
     ]
    }
   ],
   "source": [
    "msgFrom(\"Hello\", \"OOP\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "cwLIgUuHVlSfn97vOcwEou",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from OOP\n",
      "===============\n",
      "kotlin.Unit\n"
     ]
    }
   ],
   "source": [
    "val result = msgFrom(\"Hello\", \"OOP\")\n",
    "println(\"===============\")\n",
    "println(result) // 과연 ret의 값은?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "A8WKcswa5tRV5EMzJklcPb",
     "type": "MD"
    }
   },
   "source": [
    "## Functions with return types\n",
    "`Unit` 이외의 다른 리턴 타입은 기본적으로 함수를 작성할 때 표기해 주어야 하며, 해당하는 리턴 타입의 값을 `return` 문으로 리턴해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "lbS1q1Iod7g0EwqIiM78K5",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun helloStr(name: String): String {\n",
    "    return \"Hello from $name\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "FQAJOtHTjxaX9NFy7KSv0o",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello from JetBrains"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helloStr(\"JetBrains\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "qUa0hy3FWxwSQgwst2iLzz",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============\n",
      "Hello from JetBrains\n"
     ]
    }
   ],
   "source": [
    "val result = helloStr(\"JetBrains\") // 여기에서는 아무것도 출력되지 않는다\n",
    "println(\"===============\")\n",
    "println(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "x3wFxFsYv46UAY2MSEyj3y",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun add(x: Int, y: Int): Int {\n",
    "    return x + y\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "qkwHZJ1U3qPuExGOtvNsBk",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "add(3, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "WeKPNqaBSguB1gOnNf69OE",
     "type": "MD"
    }
   },
   "source": [
    "\n",
    "## Function as an expression\n",
    "여기도 설명이 조금 개념을 오해하게 표현된 면이 있다.\n",
    "\n",
    "함수가 식(expression)처럼 활용될 수 있다고 설명하는 경우는 고차함수 등을 정의하거나 활용하는 함수형 프로그래밍 관련 개념을 설명할 때 주로 쓰는 표현\n",
    "\n",
    "여기서도 좀더 정확히 표현하자면 함수 몸체(즉, 중괄호 열고부터 닫고기까지 내용)을 하나의 식으로 표현할 수 있다고 설명해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "6ho2SOA0zhXvGtTPXLNv9e",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// return문 만으로 이루어진 함수는 중괄로 감싸는 대신 = 을 쓰고 리턴되는 식을 작성해서 간소화 가능\n",
    "fun addExWithRetTy(x: Int, y: Int): Int = x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "zzvMSrTKe7nPsBtObRsy3i",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "addExWithRetTy(3,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "xwqktii6bc2rgQNp5JPh8o",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// 대부분의 경우 리턴되는 식의 타입 유추가 가능하므로 함수 리턴 타입 표기도 대부분의 경우 생략 가능\n",
    "fun addEx(x: Int, y: Int) = x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "z170dXfEGOj4OaSQ9EIDnt",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "addEx(3,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "DxfHXKlgbFX4JHcIKBlPQo",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Line_108.jupyter.kts (1:11 - 12) A type annotation is required on a value parameter\n",
      "Line_108.jupyter.kts (1:14 - 15) A type annotation is required on a value parameter"
     ]
    },
    {
     "ename": "Syntax Error",
     "evalue": "Syntax Error: A type annotation is required on a value parameter",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------",
      "Traceback (most recent call last)",
      "Syntax Error: A type annotation is required on a value parameter"
     ]
    }
   ],
   "source": [
    "fun addEx(x, y) = x + y // 함수 파라메터 타입은 일반적으로 생략 불가능 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "cZJreuefbdBTCUNiCyXR5n",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// if else 식이나 when 식으로 함수를 작성하는 사례는 책을 보고 스스로 학습 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "kyVo9alwE6oGKs39BGLxjy",
     "type": "MD"
    }
   },
   "source": [
    "## Functions with default arguments\n",
    "함수 파라메터에 기본값을 설정할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "iTRg8pO75Cyps6dsFl5esU",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun helloStr(name: String = \"Kotlin\") = \"Hello from $name\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "5SOr7nHswk1qlRjtmSg9ln",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello from Jupyter"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helloStr(\"Jupyter\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "xrIhjgtR6GifhUg4rutriH",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello from Kotlin"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helloStr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "oWHJpdSvcYEFc6hWexOp6Z",
     "type": "MD"
    }
   },
   "source": [
    "## Calling functions with named parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "aRpJPLt1mmEDW3GbSJJ6mi",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "fun msgStr(msg: String = \"hello\", name: String = \"Kotlin\") = \"$msg from $name\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "0Vj7BviF5qCDdSdh9qSmNv",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello from Kotlin"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "msgStr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "HzUCGesumSE3K6Ely8olsI",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bye from Kotlin"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "msgStr(\"bye\") // 첫째 인자는 \"bye\"로 둘째 인자는 기본값으로 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "JCkx9pL5BcWDTWViJ2DtxU",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello from Jupyter"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "msgStr(name = \"Jupyter\") // msg는 기본값으로 name은 \"Jupyter\"로 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "hndZd70hb3FaC9qMNPYKNO",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bye from Jupyter"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "msgStr(msg = \"bye\", name = \"Jupyter\") // 두 개 이상의 파라메터 이름을 활용해 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "dcO61Pu6fP2l2AjdB4z7W2",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bye from Jupyter"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "msgStr(name = \"Jupyter\", msg = \"bye\") // 파라메터 이름을 활용해 호출하면 순서를 바꿔서 작성해도 동작"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "LMJVxCZrFs4vhueKN0F740",
     "type": "CODE"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Line_140.jupyter.kts (1:26 - 31) Mixing named and positioned arguments is not allowed"
     ]
    },
    {
     "ename": "Syntax Error",
     "evalue": "Syntax Error: Mixing named and positioned arguments is not allowed",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------",
      "Traceback (most recent call last)",
      "Syntax Error: Mixing named and positioned arguments is not allowed"
     ]
    }
   ],
   "source": [
    "msgStr(name = \"Jupyter\", \"bye\") // 파라메터 이름을 활용했다 안했다 일관성 없는 호출은 허용하지 않음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "ihhFZ8CiQLmeXVpMJoKeD6",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// vararg에 대해서는 스스로 학습"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "w8XD6SNKfgN4aleZfknwpN",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": [
    "// 패키지 관련 내용은 이번 학기 수업에서는 다루지 않고 생략"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "datalore": {
     "hide_input_from_viewers": true,
     "hide_output_from_viewers": true,
     "node_id": "9k7NlrFM60a3EtMMAWhEF1",
     "type": "CODE"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "datalore": {
   "base_environment": "default",
   "computation_mode": "JUPYTER",
   "package_manager": "pip",
   "packages": [],
   "report_row_ids": [],
   "version": 3
  },
  "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.8.20-Beta"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}