Protobuf.Library

parseExceptT :: forall a m s. Monad m => ExceptT String m a -> ParserT s m a

Lift an ExceptT String m computation into a ParserT.

Consumes no parsing input, does not change the parser state at all. If the ExceptT computation is Left, then this will fail in the ParserT monad.

parseEither :: forall a m s. Monad m => Either String a -> ParserT s m a

Lift an Either String computation into a ParserT.

Consumes no parsing input, does not change the parser state at all. If the Either computation is Left, then this will fail in the ParserT monad.

parseMaybe :: forall a m s. Monad m => String -> Maybe a -> ParserT s m a

Lift a Maybe computation into a ParserT, with a note for the ParseError message in case of Nothing.

Consumes no parsing input, does not change the parser state at all. If the Maybe computation is Nothing, then this will fail in the ParserT monad.

newtype Bytes

Representation of a bytes Scalar Value Type field.

Constructors

• Bytes ArrayBuffer

Instances

• Show Bytes
• Eq Bytes
• Newtype Bytes _
• Default Bytes

class Default a  where

In Protobuf, zero values are “default values” and have special semantics.

Members

• default :: a
• isDefault :: a -> Boolean

Instances

• Default String
• Default Int
• Default Number
• Default (Long Signed)
• Default (Long Unsigned)
• Default Float32
• Default Boolean
• Default UInt
• Default Bytes
• (BoundedEnum a) => Default a

toDefault :: forall a. Default a => Maybe a -> a

Turns Nothing into a default value.

The Protobuf spec requires that a field being set to zero (“default”) and a missing field are equivalent states. Because of this, there is no way to tell whether a missing field from a received message is really missing or if the sender meant that the field value is zero. We can use this function to manually choose whether we want a missing field to mean that it’s missing, or to mean that it’s zero.

fromDefault :: forall a. Default a => Eq a => a -> Maybe a

Turns a default value into Nothing.

manyLength :: forall a m. MonadEffect m => MonadRec m => ParserT DataView m a -> ByteLength -> ParserT DataView m (Array a)

Call a parser repeatedly until exactly N bytes have been consumed. Will fail if too many bytes are consumed.

label :: forall a s m. Monad m => String -> ParserT s m a -> ParserT s m a

If parsing fails inside this labelled context, then prepend the String to the error String in the ParseError. Use this to establish context for parsing failure error messages.