diff --git a/msgpack.cabal b/msgpack.cabal
--- a/msgpack.cabal
+++ b/msgpack.cabal
@@ -1,5 +1,5 @@
 Name:                msgpack
-Version:             0.2.0
+Version:             0.2.2
 License:             BSD3
 License-File:        LICENSE
 Author:              Hideyuki Tanaka
diff --git a/src/Data/MessagePack/Base.hsc b/src/Data/MessagePack/Base.hsc
--- a/src/Data/MessagePack/Base.hsc
+++ b/src/Data/MessagePack/Base.hsc
@@ -297,7 +297,7 @@
 -- | Pack a single byte stream. It calls 'packRAW' and 'packRAWBody'.
 packRAW' :: Packer -> ByteString -> IO Int
 packRAW' pc bs = do
-  packRAW pc (BS.length bs)
+  _ <- packRAW pc (BS.length bs)
   packRAWBody pc bs
 
 type Unpacker = ForeignPtr ()
@@ -475,7 +475,7 @@
     (#const MSGPACK_OBJECT_MAP) ->
       peekObjectMap ptr
     _ ->
-      fail "peekObject: unknown object type"
+      fail $ "peekObject: unknown object type (" ++ show typ ++ ")"
 
 peekObjectBool :: Ptr a -> IO Object
 peekObjectBool ptr = do
@@ -506,20 +506,22 @@
 
 peekObjectArray :: Ptr a -> IO Object
 peekObjectArray ptr = do
-  size <- (#peek msgpack_object, via.array.size) ptr
-  p    <- (#peek msgpack_object, via.array.ptr) ptr
-  objs <- mapM (\i -> peekObject $ p `plusPtr`
+  csize <- (#peek msgpack_object, via.array.size) ptr
+  let size = fromIntegral (csize :: Word32)
+  p     <- (#peek msgpack_object, via.array.ptr) ptr
+  objs  <- mapM (\i -> peekObject $ p `plusPtr`
                       ((#size msgpack_object) * i))
-          [0..size-1]
+           [0..size-1]
   return $ ObjectArray objs
 
 peekObjectMap :: Ptr a -> IO Object
 peekObjectMap ptr = do
-  size <- (#peek msgpack_object, via.map.size) ptr
-  p    <- (#peek msgpack_object, via.map.ptr) ptr
-  dat  <- mapM (\i -> peekObjectKV $ p `plusPtr`
+  csize <- (#peek msgpack_object, via.map.size) ptr
+  let size = fromIntegral (csize :: Word32)
+  p     <- (#peek msgpack_object, via.map.ptr) ptr
+  dat   <- mapM (\i -> peekObjectKV $ p `plusPtr`
                       ((#size msgpack_object_kv) * i))
-          [0..size-1]
+           [0..size-1]
   return $ ObjectMap dat
 
 peekObjectKV :: Ptr a -> IO (Object, Object)
@@ -541,11 +543,11 @@
 packObject pc (ObjectRAW bs) = packRAW' pc bs >> return ()
 
 packObject pc (ObjectArray ls) = do
-  packArray pc (length ls)
+  _ <- packArray pc (length ls)
   mapM_ (packObject pc) ls
 
 packObject pc (ObjectMap ls) = do
-  packMap pc (length ls)
+  _ <- packMap pc (length ls)
   mapM_ (\(a, b) -> packObject pc a >> packObject pc b) ls
 
 data UnpackReturn =
@@ -560,6 +562,7 @@
   allocaBytes (#size msgpack_object) $ \ptr ->
   BS.useAsCStringLen dat $ \(str, len) ->
   alloca $ \poff -> do
+    poke poff 0
     ret <- msgpack_unpack str (fromIntegral len) poff z ptr
     case ret of
       (#const MSGPACK_UNPACK_SUCCESS) -> do
diff --git a/src/Data/MessagePack/Class.hs b/src/Data/MessagePack/Class.hs
--- a/src/Data/MessagePack/Class.hs
+++ b/src/Data/MessagePack/Class.hs
@@ -27,7 +27,6 @@
 import Control.Monad.Error
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as C8
-import Data.Either
 
 import Data.MessagePack.Base
 
@@ -45,6 +44,11 @@
 
 fromObjectError :: String
 fromObjectError = "fromObject: cannot cast"
+
+instance OBJECT () where
+  toObject = const ObjectNil
+  fromObject ObjectNil = Right ()
+  fromObject _ = Left fromObjectError
 
 instance OBJECT Int where
   toObject = ObjectInteger
diff --git a/src/Data/MessagePack/Feed.hs b/src/Data/MessagePack/Feed.hs
--- a/src/Data/MessagePack/Feed.hs
+++ b/src/Data/MessagePack/Feed.hs
@@ -21,7 +21,6 @@
   feederFromString,
   ) where
 
-import Control.Monad
 import Data.ByteString (ByteString)
 import qualified Data.ByteString as BS
 import Data.IORef
@@ -33,12 +32,16 @@
 -- | Feeder from Handle
 feederFromHandle :: Handle -> IO Feeder
 feederFromHandle h = return $ do
-  bs <- BS.hGet h bufSize
+  bs <- BS.hGetNonBlocking h bufSize
   if BS.length bs > 0
-    then return $ Just bs
+    then do return $ Just bs
     else do
-    hClose h
-    return Nothing
+    c <- BS.hGet h 1
+    if BS.length c > 0
+      then do return $ Just c
+      else do
+      hClose h
+      return Nothing
   where
     bufSize = 4096
 
diff --git a/src/Data/MessagePack/Monad.hs b/src/Data/MessagePack/Monad.hs
--- a/src/Data/MessagePack/Monad.hs
+++ b/src/Data/MessagePack/Monad.hs
@@ -79,10 +79,10 @@
 packToString m = do
   sb <- liftIO $ newSimpleBuffer
   pc <- liftIO $ newPacker sb
-  runPackerT m pc
+  _ <- runPackerT m pc
   liftIO $ simpleBufferData sb
 
--- | Execcute given serializer and write byte sequence to Handle.
+-- | Execute given serializer and write byte sequence to Handle.
 packToHandle :: MonadIO m => Handle -> PackerT m r -> m ()
 packToHandle h m = do
   sb <- packToString m
@@ -115,18 +115,21 @@
 
 instance MonadIO m => MonadUnpacker (UnpackerT m) where
   get = UnpackerT $ \up feed -> liftIO $ do
-    resp <- unpackerExecute up
-    guard $ resp>=0
-    when (resp==0) $ do
-      Just bs <- feed
-      unpackerFeed up bs
-      resp2 <- unpackerExecute up
-      guard $ resp2==1
+    executeOne up feed
     obj <- unpackerData up
     freeZone =<< unpackerReleaseZone up
     unpackerReset up
     let Right r = fromObject obj
     return r
+    
+    where
+      executeOne up feed = do
+        resp <- unpackerExecute up
+        guard $ resp>=0
+        when (resp==0) $ do
+          Just bs <- feed
+          unpackerFeed up bs
+          executeOne up feed
 
 -- | Execute deserializer using given feeder.
 unpackFrom :: MonadIO m => Feeder -> UnpackerT m r -> m r
diff --git a/src/Data/MessagePack/Stream.hs b/src/Data/MessagePack/Stream.hs
--- a/src/Data/MessagePack/Stream.hs
+++ b/src/Data/MessagePack/Stream.hs
@@ -19,9 +19,7 @@
   unpackObjectsFromString,
   ) where
 
-import Control.Monad
 import Data.ByteString (ByteString)
-import qualified Data.ByteString as BS
 import System.IO
 import System.IO.Unsafe