import Prelude hiding ( getLine, print, putStr, putStrLn )

--data () = ()
--data (a,b) = (a,b)
--data (a,b,c) = (a,b,c)

{-
main :: ()
main = let str = getLine
       in putLine str

main = let x = putStr "Hi"
       in x ; x

-}

-- pow b n === b^n
pow :: Int -> Int -> Int
pow b n = foldr (*) 1 (map (const b) [1 .. n])

{-
main = let b = getInt
           n = getInt
       in print (pow b n)  --> lese erst n, dann das b
-}

--putStr :: String -> IO ()
--putChar :: Char -> IO ()

main1 :: IO ()
main1 = putStr "Hi" >> putStr "Hi"

main2 :: IO ()
main2 = let x = putStr "Hi"
        in x >> x

main3 :: IO ()
main3 = let actions = repeat (putStr "Hi")
        in actions!!42 >> actions!!99


fac :: Integer -> Integer
fac n = foldr (*) 1 [1 .. n]

main4 = putStr (show (fac 42)) >> putChar '\n'

main5 = print (fac 42)

print :: Show a => a -> IO ()
--print x = putStr (show x) >> putChar '\n'
--print x = putStrLn (show x)
print = putStrLn . show

putStr :: String -> IO ()
putStr []     = return ()  -- the empty I/O action
putStr (c:cs) = putChar c >> putStr cs

putStrLn :: String -> IO ()
putStrLn s = putStr s >> putChar '\n'

getLine0 :: IO String
getLine0 =
  getChar >>= \c -> if c == '\n' then return ""
                                 else getLine0 >>= \cs -> return (c:cs)

-- The same with the do notation:
getLine :: IO String
getLine =
  do c <- getChar
     if c == '\n' then return ""
                  else do cs <- getLine
                          return (c:cs)

-- Definition of factorial with output of intermediate results/steps
facTrace :: Integer -> IO Integer
facTrace n | n == 0    = return 1
           | otherwise = do f <- facTrace (n - 1)
                            print (n-1, f)
                            return (n*f)

-- Read number and show its factorial:
mainFac :: IO ()
mainFac = do
  putStr "n: "
  str <- getLine
  facn <- facTrace (read str)
  putStrLn ("Factorial: " ++ show facn)

--------------------------------------------------------------------------
-- File management:

{-
type FilePath = String

readFile :: FilePath -> IO String -- contents of a file
writeFile :: FilePath -> String -> IO ()
-}

-- Copy a given file into a new one:
copyFile :: FilePath -> FilePath -> IO ()
copyFile fin fout = readFile fin >>= writeFile fout

-- Return the length of a file:
fileLength :: FilePath -> IO Int
--fileLength fname = readFile fname >>= \contents -> return (length contents)
fileLength fname = readFile fname >>= return . length

-- Return the number of lines of a file:
numOfLines :: FilePath -> IO Int
numOfLines fname = readFile fname >>= return . length . lines

-- Return the number of blank lines of a file:
numOfBlankLines :: FilePath -> IO Int
numOfBlankLines fname =
  readFile fname >>= return . length . filter (all (==' ')) . lines


-- Prefix each line with an increasing number:
enumerateLines :: String -> String
enumerateLines = concat . map (++"\n")
                        . map (uncurry (++))
                        . zip (map (\n -> show n ++ ": ") [1..])
                        . lines