This document discusses streaming and input/output (I/O) actions in Haskell. It explains that I/O actions fetch values from the outside world and can only be handled in an impure environment using the <- operator. Various I/O functions are presented, including reading and writing files lazily using readFile and putStr, as well as getting user input from the command line with getLine.

1. Streaming, IO
Sebastian Rettig
“I/O actions are like boxes with little feet that go out and
“I/O actions are like boxes with little feet that go out and
fetch some value from the outside world for us.” ([1])
fetch some value from the outside world for us.” ([1])

2. Functional Programming
● No Variables
● Functions only, eventually stored in
Modules
– Behavior do not change, once defined
– → Function called with same parameter
calculates always the same result
● Function definitions (Match Cases)
● Recursion (Memory)

3. Haskell Features
● Pure Functional Programming Language
● Lazy Evaluation
● Pattern Matching and Guards
● List Comprehension
● Type Polymorphism

4. Functional vs. Imperative (1)
● Imperative Program:
– give the computer a series of steps to
execute
– → say the computer how to do something
to achieve the goal
● Functional Program:
– define what something is
– → don't care about the steps

5. Functional vs. Imperative (2)
● Pure function (functional):
– can not change a state (because we have
no variables → no state to change)
– can only return some result
– → call 2 times with same parameters has
always to return the same result!
– e.g.: add:: Tree a -> a -> Tree a
● returns a complete new tree, because
function can not change the state

6. Functional vs. Imperative (3)
● Imperative function:
– can change a state
→ has side-effects
– no guarantee, that function can crash the
whole program
– → take care of all possible side-effects:
● validate input
● test, test, test!

7. Nice to remember (1)
● Lambda-Functions:
– <param> <param> → <operation>
– e.g.:
● a b -> a+b
● map (x -> x+3) [2,3,4]
returns [5,6,7]

8. Nice to remember (2)
● where & let .. in:
– additional definitions
– let .. in: defines scope of usage
● let = definition
● in = scope of definition (optional)
● e.g.: add x = let a=9 in a + x
– where: has scope in whole function
● e.g.: add x = a + x
where a=9

9. Nice to remember (3)
● GHCi Commands (Interpreter):
– :t
● returns the function header (type)
● e.g.: :t tail
tail :: [a] -> [a]
– :i
● returns the function definition (interface)
● e.g.: :i tail
tail :: [a] -> [a] -- Defined in
GHC.List

10. Pure vs. Impure Functions
● haskell use pure functions
● a pure function can not change a state
● but how can we communicate with that
function?
● → we have to use impure functions
● → impure functions are for communicating
with the outside world*
(*) just a placeholder, real description in next session

11. The one and only program (1)
● let's write the first IO program:
main = putStrLn “Hello World!”
● store it in helloworld.hs
● compile instructions:
ghc --make helloworld.hs
● and execute:
./helloworld

12. The one and only program (2)
main = putStrLn “Hello World!”
● main = main entry point for IO actions
● :i main
main :: IO () -- Defined in Main
● :i putStrLn
putStrLn :: String -> IO () -- Defined
in System.IO

13. What if we want more IO
actions?
main = do
putStrLn “Say me your Name!”
name <- getLine
putStrLn $ “Hello” ++ name
● do syntax glues IO actions together
● bind operator <- binds some result to a
placeholder
● $ operator switches to right associative

14. IO Actions
● an I/O action is like a box with little feet that will go
out into the real world and do something there [1]
● the only way to open the box and get the data inside
it is to use the <- operator [1]
● IO-Functions are impure functions
– called 2 times with same parameters do not
always return the same result
● you can only handle impure data in an impure
environment

15. Bind Operator
● so what type is bind to name?
name <- getLine
– :t getLine
getLine :: IO String
– name has the type String
● ! The last action in a do-block can not be bound !
● Quiz: Is this valid?
name = “Hello” ++ getLine
● Quiz: What is test?
test <- putStrLn “Hello”

16. Include Pure Functions
● easy by using let:
main = do
putStrLn “Your First Name:”
fname <- getLine
putStrLn “Your Last Name:”
lname <- getLine
putStrLn “Your Age:”
age <- getLine
let name = fname ++ lname
daysOld = yearsToDays
putStrLn $ “You are ” ++ name ++
“ and ” ++ daysOld ++ “ Days old.”

17. Program Loop
● use return to stop:
main = do
putStrLn “Your Name:”
name <- getLine
if null name
then return ()
else do
putStrLn $ “Hello ” ++ name
main

18. File Streaming
● readFile: reads contents of a file lazy
● :t readFile
readFile :: FilePath -> IO String
● What is FilePath?
– :i FilePath
type FilePath = String -- Defined in
GHC.IO
– → FilePath is synonym for String

19. File Streaming
● e.g.:
main = do
contents <- readFile filename
putStr contents
● of course IO functions are also lazy:
main = do
contents <- readFile filename
putStr $ take 5 contents
– no matter how long the file is

20. Sources
[1] Haskell-Tutorial: Learn you a Haskell (http://learnyouahaskell.com/,
2012/03/15)
[2] The Hugs User-Manual (
http://cvs.haskell.org/Hugs/pages/hugsman/index.html, 2012/03/15)
[3] The Haskellwiki (http://www.haskell.org/haskellwiki, 2012/03/15)