code: func String(b []byte) string {
  	var s string
  	if len(b) == 0 {
  		return s
  	}
  
  	// NB(r): We need to declare a real string so internally the compiler
  	// knows to use an unsafe.Pointer to keep track of the underlying memory so that
  	// once the strings's array pointer is updated with the pointer to the byte slices's
  	// underlying bytes, the compiler won't prematurely GC the memory when the byte slice
  	// goes out of scope.
  	stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
  
  	// NB(r): This makes sure that even if GC relocates the byte slices's underlying
  	// memory after this assignment, the corresponding unsafe.Pointer in the internal
  	// string struct will be updated accordingly to reflect the memory relocation.
  	stringHeader.Data = (*reflect.SliceHeader)(unsafe.Pointer(&b)).Data
  
  	// NB(r): It is important that we access b after we assign the Data
  	// pointer of the byte slice header to the Data pointer of the string header to
  	// make sure the bytes don't get GC'ed before the assignment happens.
  	l := len(b)
  	stringHeader.Len = l
  
  	return s
  }
docs: // String returns a string backed by a byte slice, it is the caller's
  // responsibility not to mutate the bytes while using the string returned. It
  // is much safer to use WithString and WithStringAndArg if possible, which is
  // more likely to force use of the result to just a small block of code.