anchor.diff:  
       /// Uses the supplied pickler to unpickle the supplied byte array into some type 'a 
       let unpickle pickler array =
  -        fst <| runUnpickle {Raw = array; Position = 0; Endianness = ByteOrder.systemEndianness} pickler
  +        fst <| runUnpickle (UnpickleComplete {Raw = array; Position = 0; Endianness = ByteOrder.systemEndianness}) pickler
   
       /// Uses the supplied pickler to pickle the supplied value into a byte array
       let pickle pickler value =
  -        (runPickle (value, {Raw = []; Endianness = ByteOrder.systemEndianness}) pickler).Raw 
  -        |> Seq.rev
  -        |> Array.ofSeq
  +        let st = PickleComplete {Raw = []; Endianness = ByteOrder.systemEndianness}
  +        match (runPickle (value, st) pickler) with 
  +        |PickleComplete ps -> ps.Raw |> Seq.rev |> Array.ofSeq
  +        |_ -> invalidOp "A non-complete binary pickler state was returned from an initially complete pickler"
  +
  
positive.code: 
          /// Convert a string into a byte list in reverse order using the supplied .NET encoding
          let private convFromStringWithDotNetEncoding (encoding : System.Text.Encoding) (str : string) =
              let bytes = Array.concat [encoding.GetPreamble(); encoding.GetBytes str]
              arrayFlipToList bytes
  
          /// Convert a chunk of a byte array into a string with exception checking using the supplied encoding
          let convToEncoding pos byteCount encoding array =
              convToStringWithDotNetEncoding pos byteCount (Encoding.createDotNetEncoding encoding) array
  
          /// Convert a string into a byte list in reverse order using the supplied encoding
  
negative.code:         match x with
          |{Unpickle = _; Pickle = g} -> g (a, st)
  
      /// Helper function that chooses between complete or incremental pickling
      let private pickleHelper f b st =
          match st with
          |PickleComplete ps -> PickleComplete {ps with Raw = (PickleConvertors.arrayFlipToList << f <| b) @ ps.Raw}
          |PickleIncremental ips -> 
              ips.Writer.Write (f b)
              st
      /// Helper function that chooses between complete or incremental unpickling and accepts an arbitrary data-size
      let private unpickleHelperSized size f st =
          match st with
          |UnpickleComplete ps -> 
              let pos = ps.Position
              let result = f pos (ps.Raw)
              result, UnpickleComplete {ps with Position = pos + size}
          |UnpickleIncremental ips ->
              let result = f 0 (ips.Reader.ReadBytes size)
              result, st
  
      /// Helper function that chooses between complete or incremental unpickling and gets the size from the size of the data type
      let private unpickleHelper (f : int -> byte array -> 'a) st =
          unpickleHelperSized (sizeof<'a>) f st
              
  
      /// Given a value of x, returns a pickler of x
  