anchor.diff:      /// Creates a pickler/unpickler pair (PU) for strings using the supplied encoding
       let encodingPU encoding =
           let pickleEncodingS byteCount = 
  -            {
  -            Pickle = fun (str, s) -> pickleHelper (PickleConvertors.Encodings.convFromEncoding encoding) str s
  -            Unpickle = fun st -> unpickleHelperSized byteCount (PickleConvertors.Encodings.convToEncoding encoding byteCount) st
  -            }
  +            EagerPU
  +                {
  +                Pickle = fun (str, s) -> pickleHelper (PickleConvertors.Encodings.convFromEncoding encoding) str s
  +                Unpickle = fun st -> unpickleHelperSized byteCount (PickleConvertors.Encodings.convToEncoding encoding byteCount) st
  +                }
           sequ (Encoding.byteLength encoding) intPU pickleEncodingS
   
       /// A pickler/unpickler pair (PU) for UTF-8 strings
  
positive.code:                 let a = f b
                  let pb = k a
                  runPickle (b, runPickle (a, s) pa) pb
              {Unpickle = unPck'; Pickle = pck'}
  
      /// Combines two PU into a PU that pickles a tuple-2
      let tuple2 pa pb =
  
negative.code: 
      /// A pickler/unpickler pair (PU) for bools
      let boolPU =
          EagerPU
              {
              Pickle = fun (b, s) -> pickleHelper (PickleConvertors.convFromBool) b s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToBool) st
              }
  
      /// A pickler/unpickler pair (PU) for bytes
      let bytePU =
          EagerPU
              {
              Pickle = fun (b, s) -> pickleHelper (Array.singleton) b s
              Unpickle = fun st -> unpickleHelper (Array.item) st
              }
  
      /// A pickler/unpickler pair (PU) for int16s of the supplied endianness
      let private int16PUE endianness =
          EagerPU
              {
              Pickle = fun (i16, s) -> pickleHelper (PickleConvertors.convFromInt16 endianness) i16 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt16 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for uint16s of the supplied endianness
      let private uint16PUE endianness =
          EagerPU
              {
              Pickle = fun (i16, s) -> pickleHelper (PickleConvertors.convFromUInt16 endianness) i16 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToUInt16 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for int32s of the supplied endianness
      let private int32PUE endianness =
          EagerPU
              {
              Pickle = fun (i32, s) -> pickleHelper (PickleConvertors.convFromInt32 endianness) i32 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt32 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for uint32s of the supplied endianness
      let private uint32PUE endianness =
          EagerPU
              {
              Pickle = fun (i32, s) -> pickleHelper (PickleConvertors.convFromUInt32 endianness) i32 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToUInt32 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for int64s of the supplied endianness
      let private int64PUE endianness =
          EagerPU
              {
              Pickle = fun (i64, s) -> pickleHelper (PickleConvertors.convFromInt64 endianness) i64 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt64 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for uint64s of the supplied endianness
      let private uint64PUE endianness =
          EagerPU
              {
              Pickle = fun (i64, s) -> pickleHelper (PickleConvertors.convFromUInt64 endianness) i64 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToUInt64 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for float32s of the supplied endianness
      let private float32PUE endianness =
          EagerPU
              {
              Pickle = fun (f32, s) -> pickleHelper (PickleConvertors.convFromFloat32 endianness) f32 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToFloat32 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for floats of the supplied endianness
      let private floatPUE endianness =
          EagerPU
              {
              Pickle = fun (f64, s) -> pickleHelper (PickleConvertors.convFromFloat64 endianness) f64 s
              Unpickle = fun st -> unpickleHelper (PickleConvertors.convToFloat64 endianness) st
              }
  
      /// A pickler/unpickler pair (PU) for decimals of the supplied endianness
      let private decimalPUE endianness =
  