BEncode is straightforward ADT for b-encoded values. Please note that since dictionaries are sorted, in most cases we can compare BEncoded values without serialization and vice versa. Lists is not required to be sorted through.

Convert to easily readable JSON-like document. Typically used for debugging purposes.

This class is used to define new datatypes that could be easily serialized using bencode format.

By default BEncodable have a generic implementation; suppose the following datatype:

 data List a = Cons { _head  :: a
                    , __tail :: (List a) }
             | Nil
               deriving Generic

If we don't need to obey any particular specification or standard, the default instance could be derived automatically from the Generic instance:

 instance BEncodable a => BEncodable (List a)

Example of derived toBEncode result:

 > toBEncode (Cons 123 $ Cons 1 Nil)
 BDict (fromList [("head",BInteger 123),("tail",BList [])])

Note that '_' prefixes are omitted.

Result used in decoding operations.

Convert bencoded value to raw bytestring according to the specification.

Try to convert raw bytestring to bencoded value according to specification.

The same as encode but takes any bencodable value.

The same as decode but returns any bencodable value.

Assoc used to easily build dictionaries with required and optional keys. Suppose we have we following datatype we want to serialize:

 data FileInfo = FileInfo
   { fileLength :: Integer
   , fileMD5sum :: Maybe ByteString
   , filePath   :: [ByteString]
   , fileTags   :: Maybe [Text]
   } deriving (Show, Read, Eq)

We need to make instance BEncodable FileInfo, though we don't want to check the both maybes manually. The more declarative and convenient way to define the toBEncode method is to use dictionary builders:

 instance BEncodable FileInfo where
   toBEncode FileInfo {..} = fromAssocs
     [ "length" -->  fileLength
     , "md5sum" -->? fileMD5sum
     , "path"   -->  filePath
     , "tags"   -->? fileTags
     ]
     ...

Make required key value pair.

Like (-->) but if the value is not present then the key do not appear in resulting bencoded dictionary.

Build BEncode dictionary using key -> value description.

A faster version of fromAssocs. Should be used only when keys in builder list are sorted by ascending.

Typically used to throw an decoding error in fromBEncode; when BEncode value to match expected value.

Dictionary extractor are similar to dictionary builders, but play the opposite role: they are used to define fromBEncode method in declarative style. Using the same FileInfo datatype fromBEncode looks like:

 instance BEncodable FileInfo where
   ...
   fromBEncode (BDict d) =
     FileInfo <$> d >--  "length"
              <*> d >--? "md5sum"
              <*> d >--  "path"
              <*> d >--? "tags"
   fromBEncode _ = decodingError "FileInfo"

The reqKey is used to extract required key — if lookup is failed then whole destructuring fail.

Used to extract optional key — if lookup is failed returns Nothing.

Infix version of the reqKey.

Infix version of the optKey.

Test if bencoded value is an integer.

Test if bencoded value is a string, both raw and utf8 encoded.

Test if bencoded value is a list.

Test if bencoded value is a dictionary.

BEncode format encoder according to specification.

BEncode format parser according to specification.