anchor.diff:  
       /// A pickler/unpickler pair (PU) for bools
       let boolPU =
  -        {
  -        Pickle = fun (b, s) -> pickleHelper (PickleConvertors.convFromBool) b s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToBool) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (b, s) -> pickleHelper (Array.singleton) b s
  -        Unpickle = fun st -> unpickleHelper (Array.item) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (i16, s) -> pickleHelper (PickleConvertors.convFromInt16 endianness) i16 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt16 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (i16, s) -> pickleHelper (PickleConvertors.convFromUInt16 endianness) i16 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToUInt16 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (i32, s) -> pickleHelper (PickleConvertors.convFromInt32 endianness) i32 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt32 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (i32, s) -> pickleHelper (PickleConvertors.convFromUInt32 endianness) i32 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToUInt32 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (i64, s) -> pickleHelper (PickleConvertors.convFromInt64 endianness) i64 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt64 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (i64, s) -> pickleHelper (PickleConvertors.convFromUInt64 endianness) i64 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToUInt64 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (f32, s) -> pickleHelper (PickleConvertors.convFromFloat32 endianness) f32 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToFloat32 endianness) st
  -        }
  +        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 =
  -        {
  -        Pickle = fun (f64, s) -> pickleHelper (PickleConvertors.convFromFloat64 endianness) f64 s
  -        Unpickle = fun st -> unpickleHelper (PickleConvertors.convToFloat64 endianness) st
  -        }
  +        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 =
  
positive.code:             
  
      /// Given a value of x, returns a PU of x without affecting the underlying read/write states
      let lift x = {Pickle = (fun (_,st) -> st); Unpickle = (fun s -> x, s)}
  
      /// Creates a sequential combination of PU 
      let sequ (f : 'b -> 'a) (pa : BinaryPU<'a>) (k : 'a -> BinaryPU<'b>) : BinaryPU<'b> =
          match pa with
          |{Unpickle = unPck; Pickle = pck} ->
              // unpickling is sequenced like bind in the reader monad
              let unPck' s =
                  let a, s' = runUnpickle s pa
                  runUnpickle s' (k a)
  
negative.code:     /// Creates a pickler/unpickler pair (PU) for strings using the supplied encoding
      let encodingPU encoding =
          let pickleEncodingS byteCount = 
              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
  