Package maintainers and Hackage trustees are allowed to edit certain bits
of package metadata after a release, without uploading a new tarball.
Note that the tarball itself is never changed, just the metadata that is
stored separately. For more information about metadata revisions, please
refer to the
Hackage Metadata Revisions FAQ.
| No. |
Time |
User |
SHA256 |
| -r3 (protobuf-simple-0.1.0.0-r3) |
2016-05-05T16:13:18Z |
mrijkeboer |
1fd6eeebfda379ae40b7b67df65f896b7f0b8964157fd3d33bbc816b667e1bbc
|
|
Changed description
from
__Protobuf-simple__
An Haskell implementation of Google's Protocol Buffers version 2 with an
emphasis on simplicity. The implementation consists of a library for
encoding and decoding of data and the `protoc` executable for generating
Haskell types from proto files. In fact, the types that are used in the
tests are generated with the following command:
> $ protoc data/Types.proto
In the example below, the `CustomType` is a Haskell type that was generated
with the `protoc` executable. The `encCustomType` function encodes a
CustomType into a ByteString. The `decCustomType` function decodes a
ByteString into either a CustomType or an error.
> module Codec where
>
> import Data.ByteString.Lazy (ByteString)
> import Data.ProtoBuf (decode, encode)
> import Types.CustomType (CustomType(..))
>
> encCustomType :: CustomType -> ByteString
> encCustomType = encode
>
> decCustomType :: ByteString -> Either String CustomType
> decCustomType = decode
The library exposes two modules, "Data.ProtoBuf", which is used for
encoding and decoding and "Data.ProtoBufInt", which is an internal module
that is used by the generated types.
__Supported Data Types__
The following Protocol Buffer types, with their Haskell counterparts, are
supported:
* bool: Bool
* bytes: ByteString (lazy)
* double: Double
* enum: Sum-type
* fixed32: Word32
* fixed64: Word64
* float: Float
* int32: Int32
* int64: Int64
* message: Product-type or newtype
* sfixed32: Int32
* sfixed64: Int64
* sint32: Int32
* sint64: Int64
* string: Text (lazy)
* uint32: Word32
* uint64: Word64
__Compatibility__
Besides testing that decoding inverses encoding, the compatibility with
other implementations is tested by decoding binary files that were created
with protobuf-net (C#).
__Other implementations__
There are currently multiple Protocol Buffers implementations available.
This library was created for the following reasons. Firstly, I wanted to
use Data.Text for the string type instead of Data.ByteString as the
protocol-buffers library does. Secondly, I wanted to use newtypes for
messages with only one field. Finally, I wanted to use simpler data types
than the protobuf library does.
For example, the protobuf library uses the following (example from the
manual):
@
data Foo = Foo
\ \ { field1 :: Required 1 (Value Int64)
\ \ , field2 :: Optional 2 (Value Text)
\ \ , field3 :: Repeated 3 (Value Bool)
\ \ } deriving (Generic, Show)
@
Whereas protobuf-simple would use the following:
@
data Foo = Foo
\ \ { field1 :: Int64
\ \ , field2 :: Maybe Text
\ \ , field3 :: Seq Bool
\ \ } deriving (Show, Eq, Ord)
@
__Not Implemented__
The following Protocol Buffers features are currently not implemented:
* Importing definitions
* Groups
* Declaring extensions in messages
* Declaring nested extensions in messages
* Oneof feature
* Associative maps
* Defining services
* Custom options
to
= Protobuf-simple
An Haskell implementation of Google's Protocol Buffers version 2 with an
emphasis on simplicity. The implementation consists of a library for
encoding and decoding of data and the `protoc` executable for generating
Haskell types from proto files. In fact, the types that are used in the
tests are generated with the following command:
> $ protoc data/Types.proto
In the example below, the `CustomType` is a Haskell type that was generated
with the `protoc` executable. The `encCustomType` function encodes a
CustomType into a ByteString. The `decCustomType` function decodes a
ByteString into either a CustomType or an error.
> module Codec where
>
> import Data.ByteString.Lazy (ByteString)
> import Data.ProtoBuf (decode, encode)
> import Types.CustomType (CustomType(..))
>
> encCustomType :: CustomType -> ByteString
> encCustomType = encode
>
> decCustomType :: ByteString -> Either String CustomType
> decCustomType = decode
The library exposes two modules, "Data.ProtoBuf", which is used for
encoding and decoding and "Data.ProtoBufInt", which is an internal module
that is used by the generated types.
== Supported Data Types
The following Protocol Buffer types, with their Haskell counterparts, are
supported:
* bool: Bool
* bytes: ByteString (lazy)
* double: Double
* enum: Sum-type
* fixed32: Word32
* fixed64: Word64
* float: Float
* int32: Int32
* int64: Int64
* message: Product-type or newtype
* sfixed32: Int32
* sfixed64: Int64
* sint32: Int32
* sint64: Int64
* string: Text (lazy)
* uint32: Word32
* uint64: Word64
== Compatibility
Besides testing that decoding inverses encoding, the compatibility with
other implementations is tested by decoding binary files that were created
with protobuf-net (C#).
== Other implementations
There are currently multiple Protocol Buffers implementations available.
This library was created for the following reasons. Firstly, I wanted to
use Data.Text for the string type instead of Data.ByteString as the
protocol-buffers library does. Secondly, I wanted to use newtypes for
messages with only one field. Finally, I wanted to use simpler data types
than the protobuf library does.
For example, the protobuf library uses the following (example from the
manual):
@
data Foo = Foo
\ \ { field1 :: Required 1 (Value Int64)
\ \ , field2 :: Optional 2 (Value Text)
\ \ , field3 :: Repeated 3 (Value Bool)
\ \ } deriving (Generic, Show)
@
Whereas protobuf-simple would use the following:
@
data Foo = Foo
\ \ { field1 :: Int64
\ \ , field2 :: Maybe Text
\ \ , field3 :: Seq Bool
\ \ } deriving (Show, Eq, Ord)
@
== Not Implemented
The following Protocol Buffers features are currently not implemented:
* Importing definitions
* Groups
* Declaring extensions in messages
* Declaring nested extensions in messages
* Oneof feature
* Associative maps
* Defining services
* Custom options
|
| -r2 (protobuf-simple-0.1.0.0-r2) |
2016-05-05T16:11:07Z |
mrijkeboer |
44e86e0a7117829d212725e06a99c63fb39819530a11702c95a8552cc59d99fa
|
|
Changed description
from
= Protobuf-simple
An Haskell implementation of Google's Protocol Buffers version 2 with an
emphasis on simplicity. The implementation consists of a library for
encoding and decoding of data and the `protoc` executable for generating
Haskell types from proto files. In fact, the types that are used in the
tests are generated with the following command:
> $ protoc data/Types.proto
In the example below, the `CustomType` is a Haskell type that was generated
with the `protoc` executable. The `encCustomType` function encodes a
CustomType into a ByteString. The `decCustomType` function decodes a
ByteString into either a CustomType or an error.
> module Codec where
>
> import Data.ByteString.Lazy (ByteString)
> import Data.ProtoBuf (decode, encode)
> import Types.CustomType (CustomType(..))
>
> encCustomType :: CustomType -> ByteString
> encCustomType = encode
>
> decCustomType :: ByteString -> Either String CustomType
> decCustomType = decode
The library exposes two modules, "Data.ProtoBuf", which is used for
encoding and decoding and "Data.ProtoBufInt", which is an internal module
that is used by the generated types.
== Supported Data Types
The following Protocol Buffer types, with their Haskell counterparts, are
supported:
* bool: Bool
* bytes: ByteString (lazy)
* double: Double
* enum: Sum-type
* fixed32: Word32
* fixed64: Word64
* float: Float
* int32: Int32
* int64: Int64
* message: Product-type or newtype
* sfixed32: Int32
* sfixed64: Int64
* sint32: Int32
* sint64: Int64
* string: Text (lazy)
* uint32: Word32
* uint64: Word64
== Compatibility
Besides testing that decoding inverses encoding, the compatibility with
other implementations is tested by decoding binary files that were created
with protobuf-net (C#).
== Other implementations
There are currently multiple Protocol Buffers implementations available.
This library was created for the following reasons. Firstly, I wanted to
use Data.Text for the string type instead of Data.ByteString as the
protocol-buffers library does. Secondly, I wanted to use newtypes for
messages with only one field. Finally, I wanted to use simpler data types
than the protobuf library does.
For example, the protobuf library uses the following (example from the
manual):
@
data Foo = Foo
\ \ { field1 :: Required 1 (Value Int64)
\ \ , field2 :: Optional 2 (Value Text)
\ \ , field3 :: Repeated 3 (Value Bool)
\ \ } deriving (Generic, Show)
@
Whereas protobuf-simple would use the following:
@
data Foo = Foo
\ \ { field1 :: Int64
\ \ , field2 :: Maybe Text
\ \ , field3 :: Seq Bool
\ \ } deriving (Show, Eq, Ord)
@
== Not Implemented
The following Protocol Buffers features are currently not implemented:
* Importing definitions
* Groups
* Declaring extensions in messages
* Declaring nested extensions in messages
* Oneof feature
* Associative maps
* Defining services
* Custom options
to
__Protobuf-simple__
An Haskell implementation of Google's Protocol Buffers version 2 with an
emphasis on simplicity. The implementation consists of a library for
encoding and decoding of data and the `protoc` executable for generating
Haskell types from proto files. In fact, the types that are used in the
tests are generated with the following command:
> $ protoc data/Types.proto
In the example below, the `CustomType` is a Haskell type that was generated
with the `protoc` executable. The `encCustomType` function encodes a
CustomType into a ByteString. The `decCustomType` function decodes a
ByteString into either a CustomType or an error.
> module Codec where
>
> import Data.ByteString.Lazy (ByteString)
> import Data.ProtoBuf (decode, encode)
> import Types.CustomType (CustomType(..))
>
> encCustomType :: CustomType -> ByteString
> encCustomType = encode
>
> decCustomType :: ByteString -> Either String CustomType
> decCustomType = decode
The library exposes two modules, "Data.ProtoBuf", which is used for
encoding and decoding and "Data.ProtoBufInt", which is an internal module
that is used by the generated types.
__Supported Data Types__
The following Protocol Buffer types, with their Haskell counterparts, are
supported:
* bool: Bool
* bytes: ByteString (lazy)
* double: Double
* enum: Sum-type
* fixed32: Word32
* fixed64: Word64
* float: Float
* int32: Int32
* int64: Int64
* message: Product-type or newtype
* sfixed32: Int32
* sfixed64: Int64
* sint32: Int32
* sint64: Int64
* string: Text (lazy)
* uint32: Word32
* uint64: Word64
__Compatibility__
Besides testing that decoding inverses encoding, the compatibility with
other implementations is tested by decoding binary files that were created
with protobuf-net (C#).
__Other implementations__
There are currently multiple Protocol Buffers implementations available.
This library was created for the following reasons. Firstly, I wanted to
use Data.Text for the string type instead of Data.ByteString as the
protocol-buffers library does. Secondly, I wanted to use newtypes for
messages with only one field. Finally, I wanted to use simpler data types
than the protobuf library does.
For example, the protobuf library uses the following (example from the
manual):
@
data Foo = Foo
\ \ { field1 :: Required 1 (Value Int64)
\ \ , field2 :: Optional 2 (Value Text)
\ \ , field3 :: Repeated 3 (Value Bool)
\ \ } deriving (Generic, Show)
@
Whereas protobuf-simple would use the following:
@
data Foo = Foo
\ \ { field1 :: Int64
\ \ , field2 :: Maybe Text
\ \ , field3 :: Seq Bool
\ \ } deriving (Show, Eq, Ord)
@
__Not Implemented__
The following Protocol Buffers features are currently not implemented:
* Importing definitions
* Groups
* Declaring extensions in messages
* Declaring nested extensions in messages
* Oneof feature
* Associative maps
* Defining services
* Custom options
|
| -r1 (protobuf-simple-0.1.0.0-r1) |
2016-05-05T16:05:31Z |
mrijkeboer |
f2887b953c9e249fa77f5d285b770d28e77ead5d914934e600e87ba67e395433
|
|
Changed description
from
= Protobuf-simple
An Haskell implementation of Google's Protocol Buffers version 2 with an
emphasis on simplicity. The implementation consists of a library for
encoding and decoding of data and the `protoc` executable for generating
Haskell types from proto files. In fact, the types that are used in the
tests are generated with the following command:
> $ protoc data/Types.proto
In the example below, the `CustomType` is a Haskell type that was generated
with the `protoc` executable. The `encCustomType` function encodes a
CustomType into a ByteString. The `decCustomType` function decodes a
ByteString into either a CustomType or an error.
> module Codec where
>
> import Data.ByteString.Lazy (ByteString)
> import Data.ProtoBuf (decode, encode)
> import Types.CustomType (CustomType(..))
>
> encCustomType :: CustomType -> ByteString
> encCustomType = encode
>
> decCustomType :: ByteString -> Either String CustomType
> decCustomType = decode
The library exposes two modules, "Data.ProtoBuf", which is used for
encoding and decoding and "Data.ProtoBufInt", which is an internal module
that is used by the generated types.
== Supported Data Types
The following Protocol Buffer types, with their Haskell counterparts, are
supported:
* bool: Bool
* bytes: ByteString (lazy)
* double: Double
* enum: Sum-type
* fixed32: Word32
* fixed64: Word64
* float: Float
* int32: Int32
* int64: Int64
* message: Product-type or newtype
* sfixed32: Int32
* sfixed64: Int64
* sint32: Int32
* sint64: Int64
* string: Text (lazy)
* uint32: Word32
* uint64: Word64
== Compatibility
Besides testing that decoding inverses encoding, the compatibility with
other implementations is tested by decoding binary files that were created
with protobuf-net (C#).
== Other implementations
There are currently multiple Protocol Buffers implementations available.
This library was created for the following reasons. Firstly, I wanted to
use Data.Text for the string type instead of Data.ByteString as the
protocol-buffers library does. Secondly, I wanted to use newtypes for
messages with only one field. Finally, I wanted to use simpler data types
than the protobuf library does.
For example, the protobuf library uses the following (example from the
manual):
@
data Foo = Foo
\ \ { field1 :: Required 1 (Value Int64)
\ \ , field2 :: Optional 2 (Value Text)
\ \ , field3 :: Repeated 3 (Value Bool)
\ \ } deriving (Generic, Show)
@
Whereas protobuf-simple would use the following:
@
data Foo = Foo
\ \ { field1 :: Int64
\ \ , field2 :: Maybe Text
\ \ , field3 :: Seq Bool
\ \ } deriving (Show, Eq, Ord)
@
== Not Implemented
The following Protocol Buffers features are currently not implemented:
* Importing definitions
* Groups
* Declaring extensions in messages
* Declaring nested extensions in messages
* Oneof feature
* Associative maps
* Defining services
* Custom options
to
= Protobuf-simple
An Haskell implementation of Google's Protocol Buffers version 2 with an
emphasis on simplicity. The implementation consists of a library for
encoding and decoding of data and the `protoc` executable for generating
Haskell types from proto files. In fact, the types that are used in the
tests are generated with the following command:
> $ protoc data/Types.proto
In the example below, the `CustomType` is a Haskell type that was generated
with the `protoc` executable. The `encCustomType` function encodes a
CustomType into a ByteString. The `decCustomType` function decodes a
ByteString into either a CustomType or an error.
> module Codec where
>
> import Data.ByteString.Lazy (ByteString)
> import Data.ProtoBuf (decode, encode)
> import Types.CustomType (CustomType(..))
>
> encCustomType :: CustomType -> ByteString
> encCustomType = encode
>
> decCustomType :: ByteString -> Either String CustomType
> decCustomType = decode
The library exposes two modules, "Data.ProtoBuf", which is used for
encoding and decoding and "Data.ProtoBufInt", which is an internal module
that is used by the generated types.
== Supported Data Types
The following Protocol Buffer types, with their Haskell counterparts, are
supported:
* bool: Bool
* bytes: ByteString (lazy)
* double: Double
* enum: Sum-type
* fixed32: Word32
* fixed64: Word64
* float: Float
* int32: Int32
* int64: Int64
* message: Product-type or newtype
* sfixed32: Int32
* sfixed64: Int64
* sint32: Int32
* sint64: Int64
* string: Text (lazy)
* uint32: Word32
* uint64: Word64
== Compatibility
Besides testing that decoding inverses encoding, the compatibility with
other implementations is tested by decoding binary files that were created
with protobuf-net (C#).
== Other implementations
There are currently multiple Protocol Buffers implementations available.
This library was created for the following reasons. Firstly, I wanted to
use Data.Text for the string type instead of Data.ByteString as the
protocol-buffers library does. Secondly, I wanted to use newtypes for
messages with only one field. Finally, I wanted to use simpler data types
than the protobuf library does.
For example, the protobuf library uses the following (example from the
manual):
@
data Foo = Foo
\ \ { field1 :: Required 1 (Value Int64)
\ \ , field2 :: Optional 2 (Value Text)
\ \ , field3 :: Repeated 3 (Value Bool)
\ \ } deriving (Generic, Show)
@
Whereas protobuf-simple would use the following:
@
data Foo = Foo
\ \ { field1 :: Int64
\ \ , field2 :: Maybe Text
\ \ , field3 :: Seq Bool
\ \ } deriving (Show, Eq, Ord)
@
== Not Implemented
The following Protocol Buffers features are currently not implemented:
* Importing definitions
* Groups
* Declaring extensions in messages
* Declaring nested extensions in messages
* Oneof feature
* Associative maps
* Defining services
* Custom options
|
| -r0 (protobuf-simple-0.1.0.0-r0) |
2016-05-05T15:56:55Z |
mrijkeboer |
cf985df88ecfced3450cb5dc0b744d59abe1f6a62ea0bd3b83cbfd85b1e306df
|
|
|