import Text.ParserCombinators.Parsec
 
run :: Show a => Parser a -> String -> IO ()
run p input =
    case (parse p "" input) of
            Left err -> do
                putStr "parse error at "
                print err
            Right x  -> print x
 
--expr = factor ('+' factor | '-' factor)*
expr :: Parser Float
expr = do
    l <- factor
    rs <- many ((do
                    char '+'
                    n <- factor
                    return $ (+) n
                    )
                <|>
                (do
                    char '-'
                    n <- factor
                    return $ flip (-) n
                ))
    return $ foldr ($) l rs
 
--factor = term ('*' term | '/' term)*
factor :: Parser Float
factor = do
    l <- term
    rs <- many ((do
                    char '*'
                    n <- term
                    return $ (*) n
                    )
                <|>
                (do
                    char '/'
                    n <- term
                    return $ flip (/) n
                ))
    return $ foldr ($) l rs
 
--term = number | '(' expr ')'
term :: Parser Float
term = do
    (do
        n <- many1 digit
        return $ read n
        )
    <|>
    (do
        char '('
        n <- expr
        char ')'
        return n
        )
 
main = do
    run expr "1+2*3/6-(12*12-8/4)"

import Control.Applicative hiding ((<|>), many)
import Text.Parsec
import Text.Parsec.String
 
run :: Show a => Parser a -> String -> IO ()
run p input =
    case (parse p "" input) of
            Left err -> do
                putStr "parse error at "
                print err
            Right x  -> print x
 
expr :: Parser Float
expr = foldr ($) <$> factor <*> many (add <|> sub)
    where add = ((+) <$> (char '+' *> factor))
          sub = (flip (-) <$> (char '-' *> factor))
 
factor :: Parser Float
factor = foldr ($) <$> term <*> many (mul <|> div)
    where mul = ((*) <$> (char '*' *> factor))  
          div =  (flip (/) <$> (char '/' *> factor))
 
term :: Parser Float
term = number <|> paren
    where number = (read <$> many1 digit )
          paren =  (char '(' *> expr <* char ')')
 
main = do
    run expr "1+2*3/6-(12*12-8/4)"

import qualified Data.ByteString.Lazy as L
import Data.Binary
import Data.Binary.Get
import Data.Word
 
data BitmapFileHeader = BitmapFileHeader {
    bfType      ::  Word16,
    bfSize      ::  Word32,
    bfOffBits   ::  Word32
} deriving (Show, Eq)
 
data BitmapInfoHeader = BitmapInfoHeader {
    biSize      ::  Word32,
    biWidth     ::  Word32,
    biHeight    ::  Word32,
    biBitCount  ::  Word16
} deriving (Show, Eq)
 
readBmpFileHeader :: Get BitmapFileHeader
readBmpFileHeader = do
    t <- getWord16le
    s <- getWord32le
    getWord32le
    ob <- getWord32le
    return BitmapFileHeader {bfType = t, bfSize = s, bfOffBits = ob}
 
readBmpInfoHeader :: Get BitmapInfoHeader
readBmpInfoHeader = do
    s <- getWord32le
    w <- getWord32le
    h <- getWord32le
    getWord16le
    bc <- getWord16le
    getBytes 24
    return BitmapInfoHeader {biSize = s, biWidth = w, biHeight = h, biBitCount = bc}
 
readBmpHeader :: Get (BitmapFileHeader, BitmapInfoHeader)
readBmpHeader = do
    f <- readBmpFileHeader
    i <- readBmpInfoHeader
 
    return (f, i)
 
main = do
    contents <- L.readFile "test.bmp"
    print $ runGet readBmpHeader contents

module Main where
 
import Database.SQLite
 
printResult ::  Either String [[Row String]] -> IO ()
printResult result = 
    case result of
        Left error      ->  putStrLn error
        Right result    ->  print result
 
main = do
    h <- openConnection "test.db"
    result <- execStatement h "select * from urls;"
    printResult result
    closeConnection h

data Value
  = Double Double
  | Int    Int64
  | Text   String
  | Blob   ByteString
  | Null

result <- execParamStatement h "select * from urls where id = :col_id;" [(":col_id", Int 1)]