h&w      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ Safe-Inferred&()/0145789:;<=>?binrepThe size in bytes of the type can be known, preferably on the cheap e.g. reading a length field.Aim to make this O(1). Except for where you can't like lists lol.Importantly goes hand in hand with BinaryCodec! Maybe we should make it a function there lol!This is useful for padding types generically, without having to track the read/write cursor. Yes, that feature *is* common and cheap for parsers (and to lesser extent, serializers), but you should really only be padding types that have a "static-ish" (= cheaply calculated) size. At least, I think so? I'm not quite sure.Some instances ignore the argument. It would be possible to pull those out into a statically-known bytelength typeclass, but it wouldn't improve clarity or performance, just get rid of a couple Rs. Safe-Inferred&()/0145789:;<=>?_ binrepTypes that can be coded between binary and a Haskell type given some runtime information.We can't prove something related to a value and pass that proof along without dependent types, meaning we can't split validation from encoding like in , so encoding can fail. However, by allowing an arbitrary environment, we can define many more convenient instances.For example, you can't write a  instance for Word16 because it doesn't specify its endianness. But you can define 'BinaryCodecWith Endianness Word16'! This was, you can decide how much of the binary schema you want to place directly in the types, and how much to configure dynamically.;This class defaults to the free implementation provided by <, which ignores the environment and wraps serializing with S.binrep,Encode to binary with the given environment.binrep,Decode to binary with the given environment.binrepTypes that can be coded precisely between binary and a Haskell type.'This class looks identical to cereal's T1, but we take a different approach to instances.T defines an internal binary codec for common Haskell types. It makes implicit decisions, such as big-endian for all integer types, and coding lists with a (big-endian) Word64 length prefix. It only works with other data serialized with the same library.This typeclass defines composable binary codec combinators. If you want to write a codec for a Word64, it needs to specify its endianness in the type. If you want to write a codec for a list with a Word8 length prefix, it must come with a proof that it's not oversized.The idea is to use this typeclass along with various annotated newtypes to allow defining a Haskell type's binary representation directly in the types. In cases where you're doing intermediate serialization and not much else, it may be convenient. You will need to do a bunch of (free at runtime) wrapping though. binrep&Run the encoder for a supporting type. binrep"Run the decoder a supporting type. binrepRun the encoder for a supporting type using the given environment. binrepRun the decoder for a supporting type using the given environment. binrepSerialize each element in order. No length indicator, so parse until either error or EOF. Usually not what you want, but sometimes used at the "top" of binary formats.binrep%Encode to binary. Same as cereal's U.binrep%Decode from binary. Same as cereal's V.     Safe-Inferred&()/0145789:;<=>? binrep(Machine integer size in number of bytes.binrepMachine integer signbinrepsignedbinrepunsignedbinrep Byte order.binrep5big endian, MSB first. e.g. most network protocolsbinrep;little endian, MSB last. e.g. most processor architecturesbinrepWrapper type grouping machine integers (sign, size) along with an explicit endianness.*binrep:Endianness doesn't apply for single-byte machine integers.9binrep:Lots of deriving boilerplate due to the type family usage. Safe-Inferred&()/0145789:;<=>?`:: Safe-Inferred'!()/0145789:;<=>?E=binrepTODO-We also use this as a predicate, because the B: constructor looks identical to what we would want for a LengthPrefixed predicate.@binrepTODOFbinrepTotal shite parsing efficiency. But, to be fair, that's why we don't serialize arbitrary-length C strings!IbinrepTODO explain why safeJbinrep TODO why safeLbinrep TODO why safe ;<=?>@BAC @BA=?>C<; Safe-Inferred'!()/0145789:;<=>?+Obinreppredicate is inherently enforced due to checking length to calculate how many succeeding nulls to parseNote that the consumer probably doesn't care about the content of the padding, just that the data is chunked correctly. I figure we care about correctness here, so it'd be nice to know about the padding well-formedness (i.e. that it's all nulls).MNMN Safe-Inferred'()/0145789:;<=>?WXYZ[\]^      !""#$%&'()*+,-./0123456789:;<=>?@ABCDDEFGHIJKLMNOPQRSTOURVWXVYZ[\][\^[\_`abcdefgbinrep-0.1.0-inplaceBinrep.ByteLen Binrep.CodecBinrep.Types.Ints Binrep.UtilBinrep.Types.StringsBinrep.Predicates.NullPadTo Paths_binrepByteLenblen $fByteLen[]BinaryCodecWith toBinWith fromBinWith BinaryCodectoBinfromBin binEncode binDecode binEncodeWith binDecodeWith$fBinaryCodec[]IRepISizeI1I2I4I8ISignSU EndiannessBELEIgetI$fBinaryCodecI$fBinaryCodecI0$fBinaryCodecI1$fBinaryCodecI2$fBinaryCodecI3$fBinaryCodecI4$fBinaryCodecI5$fBinaryCodecI6$fBinaryCodecI7$fBinaryCodecI8$fBinaryCodecI9$fBinaryCodecI10$fBinaryCodecI11$fBinaryCodecI12 $fByteLenI $fByteLenI0 $fByteLenI1 $fByteLenI2 $fGenericI $fFromJSONI $fToJSONI $fIntegralI$fEnumI$fRealI$fNumI $fBoundedI$fOrdI$fEqI$fShowItshowLenPfx WellSizedStrgetStrStrRepCPascalfromBinCString!$fBinaryCodecWithStrRepByteString$fBinaryCodecWith_rStr$fBinaryCodecStr $fByteLenStr $fByteLenStr0$fBinaryCodecWithRefine$fBinaryCodecWithRefine0$fPredicateStrf$fByteLenWithRefine NullPadTo getNNulls$fPredicateNullPadToabaseGHC.Err undefined Data.EitherRightcereal-0.5.8.2-13dbdc6e063ad81d1f731350139fd2aed81ef8be2adcd291f96bbfe80cc18ad0Data.Serialize SerializeputgetversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir