oneof support

[ka3a4ok]

Is there any planes to add oneof support?

[k-bx]

There are no such plans at the moment, but you are very welcome to submit a PR implementing them!

[bitc]

I might be interested in implementing this. @k-bx could you give any pointers on how to go about implementing this, for someone unfamiliar with the codebase? Which parts would need to be modified? How much knowledge of the wire protocol will I need?

Any guidance you could give would be appreciated

[k-bx]

@bitc great to know you'd be willing to give it a try!

I'll be honest with you, I'm not familiar with codebase at all, I also don't know much about protobuf protocol. I took maintainership somewhat recently just to keep package alive (update dependencies, merge with fork etc.). So I think you'll be on your own here (if you'll feel comfortable with code-base, I'd be happy to make you a co-maintainer).

But I will certainly do in-depth code-review when the feature is ready before merging it :)

[stiell]

Any progress on this? If not, I might give it a try. I'm not very familiar with protocol buffers or this package, but from reading the spec I have an idea of what I think oneof should look like in Haskell.

[wavewave]

I am also very interested in oneof implementation, too!

[wavewave]

I've started implementing oneof on oneof branch in http://github.com/wavewave/protocol-buffers. Until now, I succeeded in parsing a proto file with oneof (See this sample file ). Creating haskell module from this is not done yet, but I will continue to work on it. Stay tuned!

[stiell]

I started on this, but got a little stuck on how to represent oneofs in Reflections.hs

Here's how I think oneofs might look in Haskell. Example:

message Message {
    oneof foo {
        string name = 4;
        SubMessage sub_message = 9;
    }
}

This might (after #5 is implemented) generate something like:

data Foo = Name Utf8
         | SubMessage SomeOtherModule.SubMessage
data Message = Message { foo :: Maybe Foo }

and possibly also functions name :: Message -> Maybe Utf8 and subMessage :: Message -> Maybe SomeOtherModule.SubMessage.

[wavewave]

yes. that's the goal (using sum type in haskell to represent oneof).

The original protobuf implementation for sum types is quite ugly (the fields in oneof has a oneof_index flag to specify which oneof it belongs to, i.e. it is not defined in tree-like structure, but as ownership graphs). Since we reuse descriptor.proto from the original protobuf library, we need to keep this structure somehow (at least, until parsing), so the reinterpretation as haskell sum type is not very transparent as it seems.

I now think I figured out how to tackle this problem. It's a little aggressive change in the code base, though.

[wavewave]

I've succeeded in oneof implementation up to instance of TextMsg (textGet, textPut). Oneof is implemented as a sum type. Now I move on to final binary wire serialization!

[wavewave]

Binary (wire) encoding/decoding for oneof is implemented! Tested between haskell and C++ (code generated from protoc). I will clean the code up and make a pull request soon.