4IO_operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input-Output Operations\n",
    "\n",
    "*Some snippets in this notebook are taken from BLG458E Functional Programming course slides which can be accessed through the following link: https://www.slideshare.net/uyar/tag/blg458e*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IO a**: IO actions/programs of type a  \n",
    "some primitive IO programs are already defined in Haskell  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading an input  \n",
    "**getLine** function is used to read a line from std input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One-Element Type ()\n",
    "If IO operation doesn't produce a result, we use IO () which returns ().  \n",
    "This is like the **void** return type in C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Main Module\n",
    "When compiling a Haskell program, GHC creates an executable that runs the main function: **main :: IO t**  \n",
    "The type **t** is generally ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Printing a string\n",
    "To print a string, we use the built-in function **putStr :: String -> IO ()** which takes in a string and returns the IO object that prints the string.  \n",
    "To put a new line at the end automatically, use **putStrLn**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "helloWorld :: IO ()\n",
    "helloWorld = putStr \"Hello, World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello, World!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helloWorld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello :: String -> IO ()\n",
    "hello name = putStr (\"Hello, \" ++ name ++ \"!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello, Mustafa!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hello \"Mustafa\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "putStrLn \"Hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Conversion\n",
    "From a type to string, use **show**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"14\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\"1.23\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show 14\n",
    "show 1.23"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From string to another type, use **read**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "read \"42\" :: Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "read \"4\" :: Float\n",
    "read \"3.14\" :: Float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Action Sequences\n",
    "IO operations consist of actions performed in a sequence  \n",
    "In order to create an action sequence, use **do**  \n",
    "do operation is like an imperative block where we define the steps one by one.\n",
    "\n",
    "**Example**\n",
    "putStrLn in prelude is defined as below.  \n",
    "```haskell \n",
    "putStrLn :: String -> IO ()\n",
    "putStrLn str = do putStr str\n",
    "                  putStr \"\\n\"```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "putStr3Times :: String -> IO ()\n",
    "putStr3Times str = do putStrLn str\n",
    "                      putStrLn str\n",
    "                      putStrLn str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "lol\n",
       "lol\n",
       "lol"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "putStr3Times \"lol\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading an input (without capturing the values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "read2Lines :: IO()\n",
    "read2Lines = do getLine\n",
    "                getLine\n",
    "                putStrLn \"2 lines read\"\n",
    "                \n",
    "-- I know, this function makes no sense. But you got the point!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading an input with capturing the values\n",
    "Value is captured using \"<-\"  \n",
    "*Note: the values that are read can only be used in the do block*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "helloSomebody :: IO()\n",
    "helloSomebody = do name <- getLine\n",
    "                   putStrLn (\"Hello, \" ++ name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- function that reads a line and prints it in reverse order\n",
    "reverseInput :: IO ()\n",
    "reverseInput = do str <- getLine\n",
    "                  putStrLn (reverse str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also make *local* definition using **let** that can only be used within the scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- function that reads 2 lines and prints them in reverse order\n",
    "reverse2Lines :: IO ()\n",
    "reverse2Lines = do line1 <- getLine  -- beware! it's NOT line1 = getLine!\n",
    "                   line2 <- getLine\n",
    "                   let reverse1 = reverse line1\n",
    "                   let reverse2 = reverse line2\n",
    "                   putStrLn (reverse1 ++ \"\\n\" ++ reverse2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Returning the Input Read from StdIn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "getInteger :: IO Integer\n",
    "getInteger = do line <- getLine  -- get the line\n",
    "                return (read line :: Integer)   -- convert it to an integer\n",
    "                \n",
    "-- this returns the integer read from standart input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops and Recursion\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- function that prints what it reads recursively\n",
    "copyInfinitely :: IO ()\n",
    "copyInfinitely = do line <- getLine\n",
    "                    putStrLn line\n",
    "                    copyInfinitely"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "--  function that prints what it reads recursively N times\n",
    "copyNtimes :: Integer -> IO ()\n",
    "copyNtimes n\n",
    "  | n == 0    = return ()\n",
    "  | otherwise = do line <- getLine\n",
    "                   putStrLn line\n",
    "                   copyNtimes (n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- function that prints what it reads until the input is empty string\n",
    "copyUntilEmpty :: IO ()\n",
    "copyUntilEmpty = do line <- getLine\n",
    "                    if line == \"\"\n",
    "                    then return ()\n",
    "                    else do putStr line\n",
    "                            copyUntilEmpty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rock - Paper - Scissors \n",
    "In this section, a simple version of rock-paper-scissors game is implemented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- define move types\n",
    "data Move = Rock | Paper | Scissors\n",
    "            deriving Show\n",
    "            \n",
    "-- define a type for a match \n",
    "-- with 2 lists, 1st: moves of player1, 2nd: moves of player2\n",
    "type Match = ([Move], [Move])\n",
    "\n",
    "-- define outcome function\n",
    "-- 1: A wins, -1: B wins, 0: Tie\n",
    "outcome :: Move -> Move -> Integer\n",
    "outcome moveA moveB = case (moveA, moveB) of\n",
    "    (Paper, Rock)     ->  1\n",
    "    (Scissors, Rock)  -> -1\n",
    "    (Rock, Paper)     -> -1\n",
    "    (Scissors, Paper) ->  1\n",
    "    (Rock, Scissors)  ->  1\n",
    "    (Paper, Scissors) -> -1\n",
    "    _                 ->  0\n",
    "\n",
    "-- define showRound function (toString for a round)\n",
    "showRound :: Move -> Move -> String\n",
    "showRound moveA moveB = \"A: \" ++ (show moveA) ++ \"B: \" ++ (show moveB)\n",
    "\n",
    "-- define a strategy\n",
    "-- here are some examples\n",
    "\n",
    "-- always play Rock\n",
    "rock :: [Move] -> Move\n",
    "rock     _ = Rock\n",
    "\n",
    "-- cycle through options\n",
    "cycled :: [Move] -> Move\n",
    "cycled moves = case (length moves) `mod` 3 of \n",
    "  0  -> Paper\n",
    "  1  -> Scissors\n",
    "  2  -> Rock\n",
    "\n",
    "-- play what opponent played last\n",
    "echo :: [Move] -> Move\n",
    "echo []   = Rock\n",
    "echo ms   = head ms\n",
    "\n",
    "-- interactive game\n",
    "-- A: human    B: computer (playing echo)\n",
    "\n",
    "-- convert a char into a move\n",
    "convertToMove :: Char -> Move\n",
    "convertToMove c\n",
    "  | c `elem` \"rR\"  = Rock  -- elem checks if c is in the list\n",
    "  | c `elem` \"sS\"  = Scissors\n",
    "  | c `elem` \"pP\"  = Paper\n",
    "  | otherwise      = error \"Invalid move\"\n",
    "  \n",
    "-- create the interactive game\n",
    "playRound :: Match -> IO ()\n",
    "playRound match@(movesA, movesB) = do\n",
    "    ch <- getChar  -- get the move from user\n",
    "    putStrLn \"\"    -- put a new line\n",
    "    if ch == '.'   -- if input is '.', show the result of the match\n",
    "       then putStrLn (showResult match)\n",
    "       else do let moveA = convertToMove ch\n",
    "               let moveB = echo movesA\n",
    "               putStrLn (showRound movesA movesB)\n",
    "               playRound (moveA : movesA, moveB : movesB)\n",
    "               \n",
    "playInteractive :: IO ()\n",
    "playInteractive = playRound ([], [])\n",
    "\n",
    "\n",
    "-- how about an automated version of the game?\n",
    "generateMatch :: Integer -> Match\n",
    "generateMatch 0 = ([], [])\n",
    "generateMatch n = step generateMatch (n-1)\n",
    "  where \n",
    "    step :: Match -> Match\n",
    "    step (movesA, movesB) = (cycled movesB : movesA, echo movesA : movesB)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}