Haskell IO

data IO a = ... -- abstract  
  
-- Aus Tastatur lesen  
getChar :: IO Char  
getLine :: IO String  
  
-- Auf Bildschirm ausgeben  
putChar :: Char -> IO ()  
putStr :: String -> IO ()  
putStrLn :: String -> IO ()  
  
-- Umwandlung Wert in Aktion  
return :: a -> IO a  

Haskell bind Operator

(>>=) :: IO a -> (a -> IO b) -> IO b  
  
getLine >>= putStrLn  

Für zwei Aktionen c und d führt c >>= d zuerst Aktion c aus das Ergebnis wird an d übergeben.

(>>) :: IO a -> IO b -> IO b  
  
getLine >>= putStr >> putStr " ++stop++\n"  

bind für nachgelagerte Funktionen, die kein Ergebnis übernehme

Link to original

Aktionen werden verwendet wie Funktionen, z.B. Rekursion

echoLn :: IO ()   
echoLn = getLine >>= putStrLn   
 
echoLnR :: IO ()   
echoLnR = echoLn >> echoLnR  

Kombination mit reinen Funktionen:

ohceLn :: IO ()   
ohceLn = getLine >>= putStrLn . reverse  

Haskell do - Notation

Vereinfachende Schreibweise für Aktionen
Fast wie imperative Programmierung (syntactic sugar):

echoLnR = getLine >>=   
		  putStrLn >>   
          echoLnR  
  
-- ZU   
  
echoLnR = do s <- getLine   
		     putStrLn s   
		     echoLnR  

Beispiel

  
-- Aktion, die drei Zeichen einliest, das mittlere Zeichen ignoriert und das erste und dritte als Paar zurückgibt:  
act :: IO (Char, Char)   
act = do x <- getChar   
         getChar   
         y <- getChar   
         return (x,y)  
  
  
echo3 :: Int -> IO ()  
echo3 cnt = do  
  putStr (show cnt ++ ": ")  
  s <- getLine   
  if s /= "" then do   
	  putStrLn $ show cnt ++ ": " ++ s   
	  echo3 (cnt + 1)   
  else return ()  

Link to original

Kontrollstrukturen

Haskell sequence

sequence :: [IO a] -> IO [a]  
  
> sequence [getLine, getLine]   
> hallo   
> du   
["hallo","du"]  
  
  
> sequence $ map print [1,2,3]   
> 1   
> 2   
> 3   
[(),(),()]  
  
sequence_ :: [IO a] -> IO ()  
> sequence_ $ map print [1,2,3]   
> 1   
> 2   
> 3  

Haskell mapM

Link to original