Included a better API for converting to/from Eben

Data/Eben.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE ViewPatterns #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module Data.Eben where
 
@@ -58,6 +59,26 @@ decode = go
               (str, rs'') = BS.splitAt len (BS.tail rs')
           in Just (BS.toStrict str, rs'')
 
+class FromEben t where
+  fromEben :: Value -> Maybe t
+
+instance FromEben Float where
+  fromEben (Float f)   = Just f
+  fromEben (Integer i) = Just (fromIntegral i)
+  fromEben _           = Nothing
+
+instance FromEben Int where
+  fromEben (Integer i) = Just (fromIntegral i)
+  fromEben _           = Nothing
+
+instance FromEben a => FromEben [a] where
+  fromEben (List ls) = mapM fromEben ls
+  fromEben _         = Nothing
+
+instance (FromEben a, FromEben b) => FromEben (a, b) where
+  fromEben (List [x,y]) = (,) <$> fromEben x <*> fromEben y
+  fromEben _            = Nothing
+
 asDict :: Value -> Maybe (Map B.ByteString Value)
 asDict (Dict ds) = Just ds
 asDict _         = Nothing
@@ -86,6 +107,27 @@ toNum n (BS.uncons->Just(b, bs)) =
   toNum (n * 10 + toDigit b) bs
 toNum n _ = n
 
+class ToEben t where
+  toEben :: t -> Value
+
+instance ToEben a => ToEben [a] where
+  toEben = List . map toEben
+
+instance ToEben Float where
+  toEben = Float
+
+instance ToEben Int where
+  toEben = Integer . fromIntegral
+
+instance ToEben Integer where
+  toEben = Integer . fromIntegral
+
+instance (ToEben l, ToEben r) => ToEben (l, r) where
+  toEben (x, y) = List [ toEben x, toEben y ]
+
+dict :: [(B.ByteString, Value)] -> Value
+dict = Dict . M.fromList
+
 encode :: Value -> ByteString
 encode = BL.toLazyByteString . go
   where go (List vs) =