Kapitel 1: Haskell in einer Nußschale

hugs Database
ghc -o db Database.lhs

> import IO
> import System
> import List

> type State                    =  (FilePath, Dict String String)

> main                          :: IO ()
> main                          =  do hSetBuffering stdout NoBuffering
>                                     args <- getArgs
>                                     let fname = args !! 0
>                                     cnts <- readFile fname
>                                     loop (fname, read cnts)

> loop                          :: State -> IO ()
> loop state                    =  do putStr "db> "
>                                     line <- getLine
>                                     state' <- exec state (words line)
>                                     loop state'

> askFor                        :: String -> IO String
> askFor s                      =  putStr s >> getLine

> exec                          :: State -> [String] -> IO State
> exec state []                 =  return state
> exec state@(fname, dict)  (cmd : _)
>      =  case cmd of
>         "end"                 -> exitWith ExitSuccess
>         "enter"               -> do key <- askFor "key: "
>                                     val <- askFor "value: "
>                                     return (fname, add (key, val) dict)
>         "lookup"              -> do key <- askFor "key: "
>                                     putStrLn (lookupWithDefault dict 
>                                                   "not found" key)
>                                     return state
>         "save"                -> do writeFile fname (show dict)
>                                     return state
>         _                     -> do putStrLn "unknown command"
>                                     return state

Beispielsitzung:

basilisk> db asterix
db> lookup
key: alea iacta est
der Wuerfel ist gefallen
db> enter
key: acta est fabula
value: vorbei ist vorbei
db> save
db> end

Naive Implementierung von Wörterbüchern.

> type Dict a b                 =  [(a, b)]
>
> add				:: (Ord a) => (a, b) -> Dict a b -> Dict a b
> add b dict                    =  insertBy (\ (a, _) (a', _) -> compare a a') b dict
> 
> lookupWithDefault		:: (Eq a) => Dict a b -> b -> a -> b
> lookupWithDefault dict def a  =  case lookup a dict of
>                                      Nothing -> def
>                                      Just b  -> b