This feels awkward to me given that we have an actual mechanism in the language for "I don't want to write this messy return type here". Did you consider:

• Change the return type of as_bytes to auto,
• "Let U be span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>.", and
• return U{/*...*/};?
  (Ditto as_writable_bytes.)

I did consider introducing a type (or the extent) with "Let" but for some reason I didn't consider using auto. The form I used is what Tomasz (paper author) proposed in a pending-LWG issue.

I'll use your suggestion and push a new commit.

After trying a few ways to say it, I think the clearest is to use auto as the return type and say:

Effects: Equivalent to:

auto p = reinterpret_cast<const byte*>(s.data());
auto n = s.size_bytes();
if constexpr (Extent == dynamic_extent)
  return span<const byte>{p, n};
else
  return span<const byte, sizeof(ElementType) * Extent>{p, n};

Works for me.

I think we could factor out some more commonality with:

Let E be dynamic_extent if Extent == dynamic_extent, and sizeof(ElementType) * Extent otherwise.

Effects: Equivalent to: return span<const byte, E>{reinterpret_cast<const byte*>(s.data()), s.size_bytes()};

but this is much better in any case - feel free to ignore if you have better things to do than twaddle with this bit of wording over and over.

These changes are missing in the synopsis.

Not really, since the synopsis just spells out Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent in full, which is exactly what the see below expands to.

I pushed a new commit that does it differently anyway.