Rename decode and encode to mimic Binary package

This lead to more intuitive API.

5 files changed, 30 insertions, 29 deletions

diff --git a/bench/Main.hs b/bench/Main.hs
index 1cd2429..d60c0d7 100644
--- a/bench/Main.hs
+++ b/bench/Main.hs
@@ -21,7 +21,7 @@ import "bencode"   Data.BEncode     as A
 import             Data.AttoBencode as B
 import             Data.AttoBencode.Parser as B
 import "bencoding" Data.BEncode     as C
-
+import "bencoding" Data.BEncode.Internal as C
 
 instance NFData A.BEncode where
     rnf (A.BInt    i) = rnf i
@@ -123,21 +123,21 @@ main = do
        , bench "decode/AttoBencode" $
            nf (getRight . Atto.parseOnly bValue) torrentFile
        , bench "decode/bencoding"   $
-           nf (getRight . C.decode)              torrentFile
+           nf (getRight . C.parse)              torrentFile
 
        , let Just v = A.bRead lazyTorrentFile in
          bench "encode/bencode"     $ nf A.bPack v
        , let Right v = Atto.parseOnly bValue torrentFile in
          bench "encode/AttoBencode" $ nf B.encode v
-       , let Right v = C.decode torrentFile in
-         bench "encode/bencoding"   $ nf C.encode v
+       , let Right v = C.parse torrentFile in
+         bench "encode/bencoding"   $ nf C.build v
 
        , bench "decode+encode/bencode"     $
            nf (A.bPack  . fromJust . A.bRead) lazyTorrentFile
        , bench "decode+encode/AttoBencode" $
            nf (B.encode . getRight . Atto.parseOnly bValue) torrentFile
        , bench "decode+encode/bencoding"   $
-           nf (C.encode . getRight . C.decode) torrentFile
+           nf (C.build . getRight . C.parse) torrentFile
 
        , bench "list10000int/bencode/encode" $
            nf (A.bPack . A.BList . L.map (A.BInt . fromIntegral))
@@ -146,7 +146,7 @@ main = do
        , bench "list10000int/attobencode/encode" $
            nf B.encode [1..20000 :: Int]
        , bench "list10000int/bencoding/encode" $
-           nf C.encoded [1..20000 :: Int]
+           nf C.encode [1..20000 :: Int]
 
 
        , let d = A.bPack $ A.BList $
@@ -154,27 +154,27 @@ main = do
          in d `seq` (bench "list1000int/bencode/decode" $ nf
             (fromJust . A.bRead :: BL.ByteString -> A.BEncode) d)
 
-       , let d = BL.toStrict (C.encoded (L.replicate 10000 ()))
+       , let d = BL.toStrict (C.encode (L.replicate 10000 ()))
          in d `seq` (bench "list10000unit/bencoding/decode" $ nf
-            (C.decoded :: BS.ByteString -> Either String [()]) d)
+            (C.decode :: BS.ByteString -> Either String [()]) d)
 
-       , let d = BL.toStrict $ C.encoded $ L.replicate 10000 (0 :: Int)
+       , let d = BL.toStrict $ C.encode $ L.replicate 10000 (0 :: Int)
          in d `seq` (bench "list10000int/bencoding/decode" $ nf
-            (C.decoded :: BS.ByteString -> Either String [Int]) d)
+            (C.decode :: BS.ByteString -> Either String [Int]) d)
 
        , let d = L.replicate 10000 0
          in bench "list10000int/bencoding/encode>>decode" $
-            nf  (getRight . C.decoded . BL.toStrict . C.encoded
+            nf  (getRight . C.decode . BL.toStrict . C.encode
                  :: [Int] ->  [Int] )
                 d
 
        , let d = replicate' 10000 0
          in bench "list10000int/bencoding/encode>>decode/generic" $
-            nf (getRight . C.decoded . BL.toStrict . C.encoded
+            nf (getRight . C.decode . BL.toStrict . C.encode
                 :: List Int -> List Int)
                d
 
-       , let Right be = C.decode torrentFile
+       , let Right be = C.parse torrentFile
              id'   x  = let t = either error id (fromBEncode x)
                         in toBEncode (t :: Torrent)
 
diff --git a/bencoding.cabal b/bencoding.cabal
index bbbf001..916771e 100644
--- a/bencoding.cabal
+++ b/bencoding.cabal
@@ -40,13 +40,16 @@ library
   hs-source-dirs:      src
   exposed-modules:     Data.BEncode
                      , Data.BEncode.BDict
-
+                     , Data.BEncode.Internal
+                     , Data.BEncode.Types
   build-depends:       base       == 4.*
                      , ghc-prim
                      , deepseq    == 1.3.*
-                     , containers >= 0.4
-                     , bytestring >= 0.10.0.2
+                     , mtl
+
                      , attoparsec >= 0.10
+                     , bytestring >= 0.10.0.2
+                     , containers >= 0.4
                      , text       >= 0.11
                      , pretty
   ghc-options:         -Wall -fno-warn-unused-do-bind
diff --git a/src/Data/BEncode.hs b/src/Data/BEncode.hs
index 1969595..8dc7c89 100644
--- a/src/Data/BEncode.hs
+++ b/src/Data/BEncode.hs
@@ -73,8 +73,6 @@ module Data.BEncode
          -- * Serialization
        , encode
        , decode
-       , encoded
-       , decoded
 
          -- ** Dictionaries
          -- *** Building
@@ -700,9 +698,9 @@ isDict _         = False
 --------------------------------------------------------------------}
 
 -- | The same as 'decode' but returns any bencodable value.
-decoded :: BEncode a => ByteString -> Result a
-decoded = decode >=> fromBEncode
+decode :: BEncode a => ByteString -> Result a
+decode = parse >=> fromBEncode
 
 -- | The same as 'encode' but takes any bencodable value.
-encoded :: BEncode a => a -> Lazy.ByteString
-encoded = encode . toBEncode
+encode :: BEncode a => a -> Lazy.ByteString
+encode = build . toBEncode
diff --git a/src/Data/BEncode/Internal.hs b/src/Data/BEncode/Internal.hs
index 30cfbe7..3552bc9 100644
--- a/src/Data/BEncode/Internal.hs
+++ b/src/Data/BEncode/Internal.hs
@@ -9,8 +9,8 @@
 --   don't need to import this module.
 --
 module Data.BEncode.Internal
-       ( decode
-       , encode
+       ( parse
+       , build
        , ppBEncode
        ) where
 
@@ -59,8 +59,8 @@ builder = go
 
 -- | Convert bencoded value to raw bytestring according to the
 -- specification.
-encode :: BValue -> Lazy.ByteString
-encode = B.toLazyByteString . builder
+build :: BValue -> Lazy.ByteString
+build = B.toLazyByteString . builder
 
 {--------------------------------------------------------------------
 -- Deserialization
@@ -113,8 +113,8 @@ parser = valueP
 
 -- | Try to convert raw bytestring to bencoded value according to
 -- specification.
-decode :: ByteString -> Either String BValue
-decode = P.parseOnly parser
+parse :: ByteString -> Either String BValue
+parse = P.parseOnly parser
 
 {--------------------------------------------------------------------
   Pretty Printing
diff --git a/tests/properties.hs b/tests/properties.hs
index 586e94d..3d08eed 100644
--- a/tests/properties.hs
+++ b/tests/properties.hs
@@ -54,7 +54,7 @@ instance Arbitrary FileInfo where
 data T a = T
 
 prop_bencodable :: Eq a => BEncode a => T a -> a -> Bool
-prop_bencodable _ x = decoded (L.toStrict (encoded x)) == Right x
+prop_bencodable _ x = decode (L.toStrict (encode x)) == Right x
 
 -- All tests are (encode >>> decode = id)
 main :: IO ()