diff --git a/src/stdplus/fd/gmock.hpp b/src/stdplus/fd/gmock.hpp
index 37dc3eb..97a4f01 100644
--- a/src/stdplus/fd/gmock.hpp
+++ b/src/stdplus/fd/gmock.hpp
@@ -10,21 +10,23 @@
 class FdMock : public Fd
 {
   public:
-    MOCK_METHOD(span<std::byte>, read, (span<std::byte> buf), (override));
-    MOCK_METHOD(span<std::byte>, recv, (span<std::byte> buf, RecvFlags flags),
+    MOCK_METHOD(std::span<std::byte>, read, (std::span<std::byte> buf),
                 (override));
-    MOCK_METHOD(span<const std::byte>, write, (span<const std::byte> data),
-                (override));
-    MOCK_METHOD(span<const std::byte>, send,
-                (span<const std::byte> data, SendFlags flags), (override));
+    MOCK_METHOD(std::span<std::byte>, recv,
+                (std::span<std::byte> buf, RecvFlags flags), (override));
+    MOCK_METHOD(std::span<const std::byte>, write,
+                (std::span<const std::byte> data), (override));
+    MOCK_METHOD(std::span<const std::byte>, send,
+                (std::span<const std::byte> data, SendFlags flags), (override));
     MOCK_METHOD(size_t, lseek, (off_t offset, Whence whence), (override));
     MOCK_METHOD(void, truncate, (off_t size), (override));
-    MOCK_METHOD(void, bind, (span<const std::byte> sockaddr), (override));
+    MOCK_METHOD(void, bind, (std::span<const std::byte> sockaddr), (override));
     MOCK_METHOD(void, listen, (int backlog), (override));
-    MOCK_METHOD((std::tuple<std::optional<int>, span<std::byte>>), accept,
-                (span<std::byte> sockaddr), (override));
+    MOCK_METHOD((std::tuple<std::optional<int>, std::span<std::byte>>), accept,
+                (std::span<std::byte> sockaddr), (override));
     MOCK_METHOD(void, setsockopt,
-                (SockLevel level, SockOpt optname, span<const std::byte> opt),
+                (SockLevel level, SockOpt optname,
+                 std::span<const std::byte> opt),
                 (override));
     MOCK_METHOD(int, ioctl, (unsigned long id, void* data), (override));
     MOCK_METHOD(int, constIoctl, (unsigned long id, void* data),
diff --git a/src/stdplus/fd/impl.cpp b/src/stdplus/fd/impl.cpp
index 4335cf5..2d92b72 100644
--- a/src/stdplus/fd/impl.cpp
+++ b/src/stdplus/fd/impl.cpp
@@ -15,7 +15,7 @@
 
 using namespace std::literals::string_view_literals;
 
-span<std::byte> FdImpl::read(span<std::byte> buf)
+std::span<std::byte> FdImpl::read(std::span<std::byte> buf)
 {
     ssize_t amt = ::read(get(), buf.data(), buf.size());
     if (amt == -1)
@@ -33,7 +33,7 @@
     return buf.subspan(0, amt);
 }
 
-span<std::byte> FdImpl::recv(span<std::byte> buf, RecvFlags flags)
+std::span<std::byte> FdImpl::recv(std::span<std::byte> buf, RecvFlags flags)
 {
     ssize_t amt =
         ::recv(get(), buf.data(), buf.size(), static_cast<int>(flags));
@@ -52,7 +52,7 @@
     return buf.subspan(0, amt);
 }
 
-span<const std::byte> FdImpl::write(span<const std::byte> data)
+std::span<const std::byte> FdImpl::write(std::span<const std::byte> data)
 {
     ssize_t amt = ::write(get(), data.data(), data.size());
     if (amt == -1)
@@ -66,7 +66,8 @@
     return data.subspan(0, amt);
 }
 
-span<const std::byte> FdImpl::send(span<const std::byte> data, SendFlags flags)
+std::span<const std::byte> FdImpl::send(std::span<const std::byte> data,
+                                        SendFlags flags)
 {
     ssize_t amt =
         ::send(get(), data.data(), data.size(), static_cast<int>(flags));
@@ -107,7 +108,7 @@
     CHECK_ERRNO(::ftruncate(get(), size), fmt::format("ftruncate {}B", size));
 }
 
-void FdImpl::bind(span<const std::byte> sockaddr)
+void FdImpl::bind(std::span<const std::byte> sockaddr)
 {
     CHECK_ERRNO(
         ::bind(get(), reinterpret_cast<const struct sockaddr*>(sockaddr.data()),
@@ -120,8 +121,8 @@
     CHECK_ERRNO(::listen(get(), backlog), "listen");
 }
 
-std::tuple<std::optional<int>, span<std::byte>>
-    FdImpl::accept(span<std::byte> sockaddr)
+std::tuple<std::optional<int>, std::span<std::byte>>
+    FdImpl::accept(std::span<std::byte> sockaddr)
 {
     socklen_t len = sockaddr.size();
     auto fd = ::accept(
@@ -138,7 +139,7 @@
 }
 
 void FdImpl::setsockopt(SockLevel level, SockOpt optname,
-                        span<const std::byte> opt)
+                        std::span<const std::byte> opt)
 {
     CHECK_ERRNO(::setsockopt(get(), static_cast<int>(level),
                              static_cast<int>(optname), opt.data(), opt.size()),
diff --git a/src/stdplus/fd/impl.hpp b/src/stdplus/fd/impl.hpp
index 0487aba..b4e134c 100644
--- a/src/stdplus/fd/impl.hpp
+++ b/src/stdplus/fd/impl.hpp
@@ -11,19 +11,20 @@
   public:
     virtual int get() const = 0;
 
-    span<std::byte> read(span<std::byte> buf) override;
-    span<std::byte> recv(span<std::byte> buf, RecvFlags flags) override;
-    span<const std::byte> write(span<const std::byte> data) override;
-    span<const std::byte> send(span<const std::byte> data,
-                               SendFlags flags) override;
+    std::span<std::byte> read(std::span<std::byte> buf) override;
+    std::span<std::byte> recv(std::span<std::byte> buf,
+                              RecvFlags flags) override;
+    std::span<const std::byte> write(std::span<const std::byte> data) override;
+    std::span<const std::byte> send(std::span<const std::byte> data,
+                                    SendFlags flags) override;
     size_t lseek(off_t offset, Whence whence) override;
     void truncate(off_t size) override;
-    void bind(span<const std::byte> sockaddr) override;
+    void bind(std::span<const std::byte> sockaddr) override;
     void listen(int backlog) override;
-    std::tuple<std::optional<int>, span<std::byte>>
-        accept(span<std::byte> sockaddr) override;
+    std::tuple<std::optional<int>, std::span<std::byte>>
+        accept(std::span<std::byte> sockaddr) override;
     void setsockopt(SockLevel level, SockOpt optname,
-                    span<const std::byte> opt) override;
+                    std::span<const std::byte> opt) override;
     int ioctl(unsigned long id, void* data) override;
     int constIoctl(unsigned long id, void* data) const override;
     void fcntlSetfd(FdFlags flags) override;
diff --git a/src/stdplus/fd/intf.hpp b/src/stdplus/fd/intf.hpp
index bd8de13..7778ae1 100644
--- a/src/stdplus/fd/intf.hpp
+++ b/src/stdplus/fd/intf.hpp
@@ -2,8 +2,8 @@
 #include <cstddef>
 #include <fcntl.h>
 #include <optional>
+#include <span>
 #include <stdplus/flags.hpp>
-#include <stdplus/types.hpp>
 #include <sys/socket.h>
 #include <tuple>
 
@@ -85,19 +85,21 @@
   public:
     virtual ~Fd() = default;
 
-    virtual span<std::byte> read(span<std::byte> buf) = 0;
-    virtual span<std::byte> recv(span<std::byte> buf, RecvFlags flags) = 0;
-    virtual span<const std::byte> write(span<const std::byte> data) = 0;
-    virtual span<const std::byte> send(span<const std::byte> data,
-                                       SendFlags flags) = 0;
+    virtual std::span<std::byte> read(std::span<std::byte> buf) = 0;
+    virtual std::span<std::byte> recv(std::span<std::byte> buf,
+                                      RecvFlags flags) = 0;
+    virtual std::span<const std::byte>
+        write(std::span<const std::byte> data) = 0;
+    virtual std::span<const std::byte> send(std::span<const std::byte> data,
+                                            SendFlags flags) = 0;
     virtual size_t lseek(off_t offset, Whence whence) = 0;
     virtual void truncate(off_t size) = 0;
-    virtual void bind(span<const std::byte> sockaddr) = 0;
+    virtual void bind(std::span<const std::byte> sockaddr) = 0;
     virtual void listen(int backlog) = 0;
-    virtual std::tuple<std::optional<int>, span<std::byte>>
-        accept(span<std::byte> sockaddr) = 0;
+    virtual std::tuple<std::optional<int>, std::span<std::byte>>
+        accept(std::span<std::byte> sockaddr) = 0;
     virtual void setsockopt(SockLevel level, SockOpt optname,
-                            span<const std::byte> opt) = 0;
+                            std::span<const std::byte> opt) = 0;
     virtual int ioctl(unsigned long id, void* data) = 0;
     virtual int constIoctl(unsigned long id, void* data) const = 0;
     virtual void fcntlSetfd(FdFlags flags) = 0;
diff --git a/src/stdplus/fd/ops.cpp b/src/stdplus/fd/ops.cpp
index d96dbb5..d47dbb3 100644
--- a/src/stdplus/fd/ops.cpp
+++ b/src/stdplus/fd/ops.cpp
@@ -11,7 +11,7 @@
 {
 
 template <typename Fun, typename Byte, typename... Args>
-static void opExact(const char* name, Fun&& fun, Fd& fd, span<Byte> data,
+static void opExact(const char* name, Fun&& fun, Fd& fd, std::span<Byte> data,
                     Args&&... args)
 {
     while (data.size() > 0)
@@ -26,31 +26,32 @@
     }
 }
 
-void readExact(Fd& fd, span<std::byte> data)
+void readExact(Fd& fd, std::span<std::byte> data)
 {
     opExact("readExact", &Fd::read, fd, data);
 }
 
-void recvExact(Fd& fd, span<std::byte> data, RecvFlags flags)
+void recvExact(Fd& fd, std::span<std::byte> data, RecvFlags flags)
 {
     opExact("recvExact", &Fd::recv, fd, data, flags);
 }
 
-void writeExact(Fd& fd, span<const std::byte> data)
+void writeExact(Fd& fd, std::span<const std::byte> data)
 {
     opExact("writeExact", &Fd::write, fd, data);
 }
 
-void sendExact(Fd& fd, span<const std::byte> data, SendFlags flags)
+void sendExact(Fd& fd, std::span<const std::byte> data, SendFlags flags)
 {
     opExact("sendExact", &Fd::send, fd, data, flags);
 }
 
 template <typename Fun, typename Byte, typename... Args>
-static span<Byte> opAligned(const char* name, Fun&& fun, Fd& fd, size_t align,
-                            span<Byte> data, Args&&... args)
+static std::span<Byte> opAligned(const char* name, Fun&& fun, Fd& fd,
+                                 size_t align, std::span<Byte> data,
+                                 Args&&... args)
 {
-    span<Byte> ret;
+    std::span<Byte> ret;
     do
     {
         auto r =
@@ -65,25 +66,26 @@
     return ret;
 }
 
-span<std::byte> readAligned(Fd& fd, size_t align, span<std::byte> buf)
+std::span<std::byte> readAligned(Fd& fd, size_t align, std::span<std::byte> buf)
 {
     return opAligned("readAligned", &Fd::read, fd, align, buf);
 }
 
-span<std::byte> recvAligned(Fd& fd, size_t align, span<std::byte> buf,
-                            RecvFlags flags)
+std::span<std::byte> recvAligned(Fd& fd, size_t align, std::span<std::byte> buf,
+                                 RecvFlags flags)
 {
     return opAligned("recvAligned", &Fd::recv, fd, align, buf, flags);
 }
 
-span<const std::byte> writeAligned(Fd& fd, size_t align,
-                                   span<const std::byte> data)
+std::span<const std::byte> writeAligned(Fd& fd, size_t align,
+                                        std::span<const std::byte> data)
 {
     return opAligned("writeAligned", &Fd::write, fd, align, data);
 }
 
-span<const std::byte> sendAligned(Fd& fd, size_t align,
-                                  span<const std::byte> data, SendFlags flags)
+std::span<const std::byte> sendAligned(Fd& fd, size_t align,
+                                       std::span<const std::byte> data,
+                                       SendFlags flags)
 {
     return opAligned("sendAligned", &Fd::send, fd, align, data, flags);
 }
diff --git a/src/stdplus/fd/ops.hpp b/src/stdplus/fd/ops.hpp
index 4bfc5ba..8f3735b 100644
--- a/src/stdplus/fd/ops.hpp
+++ b/src/stdplus/fd/ops.hpp
@@ -1,9 +1,9 @@
 #pragma once
+#include <span>
 #include <stdexcept>
 #include <stdplus/fd/dupable.hpp>
 #include <stdplus/fd/intf.hpp>
 #include <stdplus/raw.hpp>
-#include <stdplus/types.hpp>
 #include <utility>
 
 namespace stdplus
@@ -13,18 +13,20 @@
 namespace detail
 {
 
-void readExact(Fd& fd, span<std::byte> data);
-void recvExact(Fd& fd, span<std::byte> data, RecvFlags flags);
-void writeExact(Fd& fd, span<const std::byte> data);
-void sendExact(Fd& fd, span<const std::byte> data, SendFlags flags);
+void readExact(Fd& fd, std::span<std::byte> data);
+void recvExact(Fd& fd, std::span<std::byte> data, RecvFlags flags);
+void writeExact(Fd& fd, std::span<const std::byte> data);
+void sendExact(Fd& fd, std::span<const std::byte> data, SendFlags flags);
 
-span<std::byte> readAligned(Fd& fd, size_t align, span<std::byte> buf);
-span<std::byte> recvAligned(Fd& fd, size_t align, span<std::byte> buf,
-                            RecvFlags flags);
-span<const std::byte> writeAligned(Fd& fd, size_t align,
-                                   span<const std::byte> data);
-span<const std::byte> sendAligned(Fd& fd, size_t align,
-                                  span<const std::byte> data, SendFlags flags);
+std::span<std::byte> readAligned(Fd& fd, size_t align,
+                                 std::span<std::byte> buf);
+std::span<std::byte> recvAligned(Fd& fd, size_t align, std::span<std::byte> buf,
+                                 RecvFlags flags);
+std::span<const std::byte> writeAligned(Fd& fd, size_t align,
+                                        std::span<const std::byte> data);
+std::span<const std::byte> sendAligned(Fd& fd, size_t align,
+                                       std::span<const std::byte> data,
+                                       SendFlags flags);
 
 template <typename Fun, typename Container, typename... Args>
 auto alignedOp(Fun&& fun, Fd& fd, Container&& c, Args&&... args)
@@ -32,7 +34,7 @@
     using Data = raw::detail::dataType<Container>;
     auto ret = fun(fd, sizeof(Data), raw::asSpan<std::byte>(c),
                    std::forward<Args>(args)...);
-    return span<Data>(std::begin(c), ret.size() / sizeof(Data));
+    return std::span<Data>(std::begin(c), ret.size() / sizeof(Data));
 }
 
 } // namespace detail
@@ -127,7 +129,7 @@
 
 inline std::optional<stdplus::DupableFd> accept(Fd& fd)
 {
-    auto ret = std::get<0>(fd.accept(span<std::byte>{}));
+    auto ret = std::get<0>(fd.accept(std::span<std::byte>{}));
     if (!ret)
     {
         return std::nullopt;