Defining Message Types

Define messages using Haskell record types. You can use any MessageField types in your records, and the correct serializer and deserializer will be generated for you.

Make sure to derive a Generic instance for your type, and then derive instances for Message and Named using the default (empty) instances:

instance Message Foo
instance Named Foo

Encoding Messages

Now we can encode a value of type Foo using toLazyByteString.

For example:

>>> Proto3.Suite.toLazyByteString (Foo 42 (Proto3.Suite.PackedVec (pure 123)))
"\b*\DC2\SOH{"

We can also decode messages using fromByteString:

>>> Proto3.Suite.fromByteString "\b*\DC2\SOH{" :: Either Proto3.Wire.Decode.ParseError Foo
Right (Foo {fooX = 42, fooY = PackedVec {packedvec = [123]}})

Nested Messages

Messages can contain other messages, by using the Nested constructor, and lists of nested messages using the 'NestedVec constructor'.

Enumerations

Enumerated types can be used by deriving the Bounded, Enum, ProtoEnum, Finite, and Named classes. Each of these instances are implied by a Generic instance, so can be derived as follows:

data Shape
  = Circle
  | Square
  | Triangle
  deriving (Bounded, Eq, Enum, Finite, Generic, Named, Ord, ProtoEnum)

Generating a .proto file

We can generate a .proto file for the Foo and Bar data types by using the toProtoFileDef function. We have to provide a package name, and explicitly list the message and enumeration types as a DotProto value.

>>> putStrLn protoFile
syntax = "proto3";
package examplePackageName;
enum Shape {
  Circle = 0;
  Square = 1;
  Triangle = 2;
}
message Foo {
  uint32 fooX = 1;
  repeated int32 fooY = 2 [packed = true];
}
message Bar {
  Shape barShape = 1;
  Foo barFoo = 2;
  repeated Foo foos = 3;
}