Everything from here onward (line 33 to 103) was recently added with no discussion about the usecase. I was personally happy with having utils to "cleanup" memory manually, which AFAIK was the original idea behind this PR.

Some of the things here ressemble `Bytes._unsafeReadBytesOffset, which was left private (and not internal) because we could not guarantee the memory safety. This library goes way furter, with assembly marked memory safe when its not something we know (depends on the user input).

Using the copy function, its quite easy to break stuff by writting to the wrong locations (for example to 0x60).

The background for these changes is that they're used by the RLP library and we previously kept private:
0332ffe#diff-0399261b2cd954212dda0147b86044380b879ab21e1d1b89c564cb48f3552216L304-L328

I agree with your take. However I think it's worth pursuing this pattern since it composes pretty well imo (as long as we add proper WARNINGS and docs). See how it looks in some places in RLP:

function readRawBytes(Item memory item) internal pure returns (bytes memory) {
    uint256 itemLength = item.length;
    bytes memory result = new bytes(itemLength);
    result.contentPointer().copy(item.ptr, itemLength);

    return result;
}

I would be fine removing these functions. Want to hear your thoughts on the pattern

Rather than exposing these in Memory when they're only used in the RLP library, maybe make them private within the RLP library?

Would also consider constraining destPtr to be greater than fmp offset.

@Amxx Worth noting the original proveth implementation does essentially the same, but manually, without mcopy.

  /*
  * @param src Pointer to source
  * @param dest Pointer to destination
  * @param len Amount of memory to copy from the source
  */
  function copy(uint src, uint dest, uint len) private pure {
      if (len == 0) return;

      // copy as many word sizes as possible
      for (; len >= WORD_SIZE; len -= WORD_SIZE) {
          assembly {
              mstore(dest, mload(src))
          }

          src += WORD_SIZE;
          dest += WORD_SIZE;
      }

      // left over bytes. Mask is used to remove unwanted bytes from the word
      uint mask = 256 ** (WORD_SIZE - len) - 1;
      assembly {
          let srcpart := and(mload(src), not(mask)) // zero out src
          let destpart := and(mload(dest), mask) // retrieve the bytes
          mstore(dest, or(destpart, srcpart))
      }
  }

I removed all new controversial functions. Opened #5792 instead. Also updated the RLP PR (#5680) accordingly as suggested @0xClandestine