diff --git a/CMakeLists.txt b/CMakeLists.txt
index f16b8717..4a993257 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -62,6 +62,7 @@ set(SPARROW_HEADERS
     ${SPARROW_INCLUDE_DIR}/sparrow/allocator.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/array_data.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/buffer.hpp
+    ${SPARROW_INCLUDE_DIR}/sparrow/buffer_view.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/data_type.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/data_traits.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/dynamic_bitset.hpp
diff --git a/include/sparrow/allocator.hpp b/include/sparrow/allocator.hpp
index ae514081..3ef93af4 100644
--- a/include/sparrow/allocator.hpp
+++ b/include/sparrow/allocator.hpp
@@ -17,8 +17,8 @@
 #include <cstdint>
 #include <memory>
 #include <memory_resource>
-#include <typeindex>
 #include <type_traits>
+#include <typeindex>
 #include <variant>
 
 namespace sparrow
@@ -29,16 +29,19 @@ namespace sparrow
      */
     template <class T>
     concept allocator = std::copy_constructible<std::remove_cvref_t<T>>
-        and std::move_constructible<std::remove_cvref_t<T>>
-        and std::equality_comparable<std::remove_cvref_t<T>>
-        and requires(std::remove_cvref_t<T>& alloc,
-                     typename std::remove_cvref_t<T>::value_type* p,
-                     std::size_t n)
-        {
-            typename std::remove_cvref_t<T>::value_type;
-            { alloc.allocate(n) } -> std::same_as<typename std::remove_cvref_t<T>::value_type*>;
-            { alloc.deallocate(p, n) } -> std::same_as<void>;
-        };
+                        and std::move_constructible<std::remove_cvref_t<T>>
+                        and std::equality_comparable<std::remove_cvref_t<T>>
+                        and requires(
+                            std::remove_cvref_t<T>& alloc,
+                            typename std::remove_cvref_t<T>::value_type* p,
+                            std::size_t n
+                        ) {
+                                typename std::remove_cvref_t<T>::value_type;
+                                {
+                                    alloc.allocate(n)
+                                } -> std::same_as<typename std::remove_cvref_t<T>::value_type*>;
+                                { alloc.deallocate(p, n) } -> std::same_as<void>;
+                            };
 
     /*
      * When the allocator A with value_type T satisfies this concept, any_allocator
@@ -46,8 +49,9 @@ namespace sparrow
      * (Small Buffer Optimization).
      */
     template <class A, class T>
-    concept can_any_allocator_sbo = allocator<A> &&
-        (std::same_as<A, std::allocator<T>> || std::same_as<A, std::pmr::polymorphic_allocator<T>>);
+    concept can_any_allocator_sbo = allocator<A>
+                                    && (std::same_as<A, std::allocator<T>>
+                                        || std::same_as<A, std::pmr::polymorphic_allocator<T>>);
 
     /*
      * Type erasure class for allocators. This allows to use any kind of allocator
@@ -71,18 +75,17 @@ namespace sparrow
 
         template <class A>
         any_allocator(A&& alloc)
-        requires (not std::same_as<std::remove_cvref_t<A>, any_allocator>
-                and sparrow::allocator<A>)
+            requires(not std::same_as<std::remove_cvref_t<A>, any_allocator> and sparrow::allocator<A>)
             : m_storage(make_storage(std::forward<A>(alloc)))
         {
         }
 
         [[nodiscard]] T* allocate(std::size_t n);
         void deallocate(T* p, std::size_t n);
-        
+
         any_allocator select_on_container_copy_construction() const;
 
-        bool equal(const any_allocator& rhs) const; 
+        bool equal(const any_allocator& rhs) const;
 
     private:
 
@@ -100,7 +103,10 @@ namespace sparrow
         {
             A m_alloc;
 
-            explicit impl(A alloc) : m_alloc(std::move(alloc)) {}
+            explicit impl(A alloc)
+                : m_alloc(std::move(alloc))
+            {
+            }
 
             [[nodiscard]] T* allocate(std::size_t n) override
             {
@@ -127,12 +133,8 @@ namespace sparrow
             }
         };
 
-        using storage_type = std::variant
-        <
-            std::allocator<T>,
-            std::pmr::polymorphic_allocator<T>,
-            std::unique_ptr<interface>
-        >;
+        using storage_type = std::
+            variant<std::allocator<T>, std::pmr::polymorphic_allocator<T>, std::unique_ptr<interface>>;
 
         template <class A>
         std::unique_ptr<interface> make_storage(A&& alloc) const
@@ -141,35 +143,56 @@ namespace sparrow
         }
 
         template <class A>
-        requires can_any_allocator_sbo<A, T>
+            requires can_any_allocator_sbo<A, T>
         A&& make_storage(A&& alloc) const
         {
             return std::forward<A>(alloc);
         }
 
-        template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+        template <class... Ts>
+        struct overloaded : Ts...
+        {
+            using Ts::operator()...;
+        };
         // Although not required in C++20, clang needs it to build the code below
-        template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
-        
+        template <class... Ts>
+        overloaded(Ts...) -> overloaded<Ts...>;
+
         storage_type copy_storage(const storage_type& rhs) const
         {
-            return std::visit(overloaded {
-                [](const auto& arg) -> storage_type { return { std::decay_t<decltype(arg)>(arg) }; },
-                [](const std::unique_ptr<interface>& arg) -> storage_type { return { arg->clone() }; }
-            }, rhs);
+            return std::visit(
+                overloaded{
+                    [](const auto& arg) -> storage_type
+                    {
+                        return {std::decay_t<decltype(arg)>(arg)};
+                    },
+                    [](const std::unique_ptr<interface>& arg) -> storage_type
+                    {
+                        return {arg->clone()};
+                    }
+                },
+                rhs
+            );
         }
 
         template <class F>
         decltype(auto) visit_storage(F&& f)
         {
-            return std::visit([&f](auto&& arg)
-            {
-                using A = std::decay_t<decltype(arg)>;
-                if constexpr (can_any_allocator_sbo<A, T>)
-                    return f(arg);
-                else
-                    return f(*arg);
-            }, m_storage);
+            return std::visit(
+                [&f](auto&& arg)
+                {
+                    using A = std::decay_t<decltype(arg)>;
+                    if constexpr (can_any_allocator_sbo<A, T>)
+                    {
+                        return f(arg);
+                    }
+                    else
+                    {
+                        return f(*arg);
+                    }
+                },
+                m_storage
+            );
         }
 
         storage_type m_storage;
@@ -194,13 +217,23 @@ namespace sparrow
     template <class T>
     [[nodiscard]] T* any_allocator<T>::allocate(std::size_t n)
     {
-        return visit_storage([n](auto& allocator) { return allocator.allocate(n); });
+        return visit_storage(
+            [n](auto& allocator)
+            {
+                return allocator.allocate(n);
+            }
+        );
     }
 
     template <class T>
     void any_allocator<T>::deallocate(T* p, std::size_t n)
     {
-        return visit_storage([n, p](auto& allocator) { return allocator.deallocate(p, n); });
+        return visit_storage(
+            [n, p](auto& allocator)
+            {
+                return allocator.deallocate(p, n);
+            }
+        );
     }
 
     template <class T>
@@ -213,33 +246,49 @@ namespace sparrow
     bool any_allocator<T>::equal(const any_allocator& rhs) const
     {
         // YOLO!!
-        return std::visit([&rhs](auto&& arg)
-        {
-            using A = std::decay_t<decltype(arg)>;
-            if constexpr (can_any_allocator_sbo<A, T>)
+        return std::visit(
+            [&rhs](auto&& arg)
             {
-                return std::visit([&arg](auto&& arg2)
+                using A = std::decay_t<decltype(arg)>;
+                if constexpr (can_any_allocator_sbo<A, T>)
                 {
-                    using A2 = std::decay_t<decltype(arg2)>;
-                    if constexpr (can_any_allocator_sbo<A2, T> && std::same_as<A, A2>)
-                        return arg == arg2;
-                    else
-                        return false;
-                }, rhs.m_storage);
-            }
-            else
-            {
-                return std::visit([&arg](auto&& arg2)
+                    return std::visit(
+                        [&arg](auto&& arg2)
+                        {
+                            using A2 = std::decay_t<decltype(arg2)>;
+                            if constexpr (can_any_allocator_sbo<A2, T> && std::same_as<A, A2>)
+                            {
+                                return arg == arg2;
+                            }
+                            else
+                            {
+                                return false;
+                            }
+                        },
+                        rhs.m_storage
+                    );
+                }
+                else
                 {
-                    using A2 = std::decay_t<decltype(arg2)>;
-                    if constexpr (can_any_allocator_sbo<A2, T>)
-                        return false;
-                    else
-                        return arg->equal(*arg2);
-                }, rhs.m_storage);
-            }
-
-        }, m_storage);
+                    return std::visit(
+                        [&arg](auto&& arg2)
+                        {
+                            using A2 = std::decay_t<decltype(arg2)>;
+                            if constexpr (can_any_allocator_sbo<A2, T>)
+                            {
+                                return false;
+                            }
+                            else
+                            {
+                                return arg->equal(*arg2);
+                            }
+                        },
+                        rhs.m_storage
+                    );
+                }
+            },
+            m_storage
+        );
     }
 
     template <class T>
@@ -248,4 +297,3 @@ namespace sparrow
         return lhs.equal(rhs);
     }
 }
-
diff --git a/include/sparrow/buffer.hpp b/include/sparrow/buffer.hpp
index 1b828be2..d5172b42 100644
--- a/include/sparrow/buffer.hpp
+++ b/include/sparrow/buffer.hpp
@@ -18,454 +18,838 @@
 #include <cassert>
 #include <concepts>
 #include <cstdint>
+#include <iterator>
+#include <stdexcept>
 
+#include "sparrow/allocator.hpp"
 #include "sparrow/iterator.hpp"
 #include "sparrow/mp_utils.hpp"
 
 namespace sparrow
 {
+
     /**
-     * @class buffer_base
-     * @brief Base class for buffer and buffer_view
-     *
-     * This class implements the common API for buffer and buffer_view.
-     * The only difference between these two inheriting classes is
-     * that buffer owns its memory while buffer_view only references it.
+     * Base class for buffer.
      *
-     **/
+     * This class provides memory management for the buffer class.
+     * The constructor and destructor perform allocation and deallocation
+     * of the internal storage, but do not initialize any element.
+     */
     template <class T>
     class buffer_base
     {
+    protected:
+
+        using allocator_type = any_allocator<T>;
+        using alloc_traits = std::allocator_traits<allocator_type>;
+        using pointer = typename alloc_traits::pointer;
+        using size_type = typename alloc_traits::size_type;
+
+        struct buffer_data
+        {
+            pointer p_begin = nullptr;
+            pointer p_end = nullptr;
+            pointer p_storage_end = nullptr;
+
+            buffer_data() = default;
+            constexpr buffer_data(buffer_data&&) noexcept;
+            constexpr buffer_data& operator=(buffer_data&&) noexcept;
+        };
+
+        buffer_base() = default;
+
+        template <allocator A>
+        constexpr buffer_base(const A& a) noexcept;
+
+        template <allocator A = allocator_type>
+        constexpr buffer_base(size_type n, const A& a = A());
+
+        template <allocator A = allocator_type>
+        constexpr buffer_base(pointer p, size_type n, const A& a = A());
+
+        ~buffer_base();
+
+        buffer_base(buffer_base&&) = default;
+
+        template <allocator A>
+        constexpr buffer_base(buffer_base&& rhs, const A& a);
+
+        constexpr allocator_type& get_allocator() noexcept;
+        constexpr const allocator_type& get_allocator() const noexcept;
+        constexpr buffer_data& get_data() noexcept;
+        constexpr const buffer_data& get_data() const noexcept;
+
+        constexpr pointer allocate(size_type n);
+        constexpr void deallocate(pointer p, size_type n);
+        constexpr void create_storage(size_type n);
+        constexpr void assign_storage(pointer p, size_type n, size_type cap);
+
+    private:
+
+        allocator_type m_alloc;
+        buffer_data m_data;
+    };
+
+    /**
+     * Object that owns a piece of contiguous memory.
+     *
+     * This class provides an API similar to std::vector, with
+     * two main differences:
+     * - it is not templated by the allocator type, but makes use of
+     *   any_allocator which type-erases it.
+     * - it can acquire ownership of an already allocated raw buffer.
+     */
+    template <class T>
+    class buffer : private buffer_base<T>
+    {
+        using base_type = buffer_base<T>;
+        using alloc_traits = typename base_type::alloc_traits;
+
+        static_assert(
+            std::same_as<std::remove_cvref_t<T>, T>,
+            "buffer must have a non-const, non-volatile, non-reference value_type"
+        );
+
     public:
 
-        using self_type = buffer_base<T>;
+        using allocator_type = typename base_type::allocator_type;
         using value_type = T;
-        using reference = T&;
-        using const_reference = const T&;
-        using pointer = T*;
-        using const_pointer = const T*;
-        using size_type = std::size_t;
-        using difference_type = std::ptrdiff_t;
-
+        using reference = value_type&;
+        using const_reference = const value_type&;
+        using pointer = typename alloc_traits::pointer;
+        using const_pointer = typename alloc_traits::const_pointer;
+        using size_type = typename alloc_traits::size_type;
+        using difference_type = typename alloc_traits::difference_type;
         using iterator = pointer_iterator<pointer>;
         using const_iterator = pointer_iterator<const_pointer>;
         using reverse_iterator = std::reverse_iterator<iterator>;
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-        bool empty() const noexcept;
-        size_type size() const noexcept;
+        buffer() = default;
+
+        template <class A>
+            requires(not std::same_as<A, buffer<T>> and allocator<A>)
+        constexpr explicit buffer(const A& a)
+            : base_type(a)
+        {
+        }
+
+        template <allocator A = allocator_type>
+        constexpr explicit buffer(size_type n, const A& a = A());
+
+        template <allocator A = allocator_type>
+        constexpr buffer(size_type n, const value_type& v, const A& a = A());
 
-        reference operator[](size_type);
-        const_reference operator[](size_type) const;
+        template <allocator A = allocator_type>
+        constexpr buffer(pointer p, size_type n, const A& a = A());
 
-        reference front();
-        const_reference front() const;
+        template <allocator A = allocator_type>
+        constexpr buffer(std::initializer_list<value_type> init, const A& a = A());
+
+        template <class It, allocator A = allocator_type>
+        constexpr buffer(It first, It last, const A& a = A());
+
+        ~buffer();
 
-        reference back();
-        const_reference back() const;
+        buffer(const buffer& rhs);
 
+        template <allocator A>
+        buffer(const buffer& rhs, const A& a);
+
+        buffer(buffer&& rhs) = default;
+
+        template <allocator A>
+        buffer(buffer&& rhs, const A& a);
+
+        buffer& operator=(const buffer& rhs);
+        buffer& operator=(buffer&& rhs);
+        buffer& operator=(std::initializer_list<value_type> init);
+
+        // Element access
+
+        constexpr reference operator[](size_type i);
+        constexpr const_reference operator[](size_type i) const;
+
+        constexpr reference front();
+        constexpr const_reference front() const;
+
+        constexpr reference back();
+        constexpr const_reference back() const;
+
+        // TODO: make this non template and make a buffer_caster class
         template <class U = T>
-        U* data() noexcept;
+        constexpr U* data() noexcept;
 
+        // TODO: make this non template and make a buffer_caster class
         template <class U = T>
-        const U* data() const noexcept;
+        constexpr const U* data() const noexcept;
 
-        iterator begin();
-        iterator end();
+        // Iterators
 
-        const_iterator begin() const;
-        const_iterator end() const;
-        const_iterator cbegin() const;
-        const_iterator cend() const;
+        constexpr iterator begin() noexcept;
+        constexpr iterator end() noexcept;
 
-        reverse_iterator rbegin();
-        reverse_iterator rend();
+        constexpr const_iterator begin() const noexcept;
+        constexpr const_iterator end() const noexcept;
 
-        const_reverse_iterator rbegin() const;
-        const_reverse_iterator rend() const;
-        const_reverse_iterator crbegin() const;
-        const_reverse_iterator crend() const;
+        constexpr const_iterator cbegin() const noexcept;
+        constexpr const_iterator cend() const noexcept;
 
-        void swap(buffer_base& rhs) noexcept;
-        bool equal(const buffer_base& rhs) const;
+        constexpr reverse_iterator rbegin() noexcept;
+        constexpr reverse_iterator rend() noexcept;
 
-    protected:
+        constexpr const_reverse_iterator rbegin() const noexcept;
+        constexpr const_reverse_iterator rend() const noexcept;
 
-        buffer_base() = default;
-        buffer_base(pointer p, size_type n);
-        ~buffer_base() = default;
+        constexpr const_reverse_iterator crbegin() const noexcept;
+        constexpr const_reverse_iterator crend() const noexcept;
 
-        buffer_base(const self_type&) = default;
-        self_type& operator=(const self_type&) = default;
+        // Capacity
 
-        buffer_base(self_type&&) = default;
-        self_type& operator=(self_type&&) = default;
+        constexpr bool empty() const noexcept;
+        constexpr size_type capacity() const noexcept;
+        constexpr size_type size() const noexcept;
+        constexpr size_type max_size() const noexcept;
+        constexpr void reserve(size_type new_cap);
+        constexpr void shrink_to_fit();
 
-        void reset(pointer p, size_type n);
+        // Modifiers
+
+        constexpr void clear();
+        constexpr void resize(size_type new_size);
+        constexpr void resize(size_type new_size, const value_type& value);
+        constexpr void swap(buffer& rhs);
 
     private:
 
-        pointer p_data = nullptr;
-        size_type m_size = 0u;
+        using base_type::get_allocator;
+        using base_type::get_data;
+
+        template <class F>
+        constexpr void resize_impl(size_type new_size, F&& initializer);
+
+        template <class It>
+        constexpr void assign_range_impl(It first, It last, std::forward_iterator_tag);
+
+        constexpr void erase_at_end(pointer p);
+
+        template <class It>
+        constexpr pointer allocate_and_copy(size_type n, It first, It last);
+
+        // The following methods are static because:
+        // - they accept an allocator argument, and do not depend on
+        //   the state of buffer
+        // - taking an allocator argument instead of relying on get_allocator
+        //   will make it easier to support allocators that propagate
+        //   on copy / move, as these methods will be called with allocators
+        //   from different instances of buffers.
+
+        static constexpr size_type check_init_length(size_type n, const allocator_type& a);
+
+        static constexpr size_type max_size_impl(const allocator_type& a) noexcept;
+
+        static constexpr pointer default_initialize(pointer begin, size_type n, allocator_type& a);
+
+        static constexpr pointer
+        fill_initialize(pointer begin, size_type n, const value_type& v, allocator_type& a);
+
+        template <class It>
+        static constexpr pointer copy_initialize(It first, It last, pointer begin, allocator_type& a);
+
+        static constexpr void destroy(pointer first, pointer last, allocator_type& a);
     };
 
     template <class T>
-    bool operator==(const buffer_base<T>& lhs, const buffer_base<T>& rhs);
+    constexpr bool operator==(const buffer<T>& lhs, const buffer<T>& rhs) noexcept;
+
+    /******************************
+     * buffer_base implementation *
+     ******************************/
 
-    /**
-     * @class buffer
-     * @brief Object that owns a piece of contiguous memory
-     */
     template <class T>
-    class buffer : public buffer_base<T>
+    constexpr buffer_base<T>::buffer_data::buffer_data(buffer_data&& rhs) noexcept
+        : p_begin(rhs.p_begin)
+        , p_end(rhs.p_end)
+        , p_storage_end(rhs.p_storage_end)
     {
-    public:
+        rhs.p_begin = nullptr;
+        rhs.p_end = nullptr;
+        rhs.p_storage_end = nullptr;
+    }
 
-        using base_type = buffer_base<T>;
-        using value_type = typename base_type::value_type;
-        using pointer = typename base_type::pointer;
-        using size_type = typename base_type::size_type;
+    template <class T>
+    constexpr auto buffer_base<T>::buffer_data::operator=(buffer_data&& rhs) noexcept -> buffer_data&
+    {
+        std::swap(p_begin, rhs.p_begin);
+        std::swap(p_end, rhs.p_end);
+        std::swap(p_storage_end, rhs.p_storage_end);
+        return *this;
+    }
 
-        buffer() = default;
-        explicit buffer(size_type size);
-        buffer(size_type size, value_type);
-        buffer(pointer data, size_type size);
+    template <class T>
+    template <allocator A>
+    constexpr buffer_base<T>::buffer_base(const A& a) noexcept
+        : m_alloc(a)
+    {
+    }
 
-        ~buffer();
+    template <class T>
+    template <allocator A>
+    constexpr buffer_base<T>::buffer_base(size_type n, const A& a)
+        : m_alloc(a)
+    {
+        create_storage(n);
+    }
 
-        buffer(const buffer&);
-        buffer& operator=(const buffer&);
+    template <class T>
+    template <allocator A>
+    constexpr buffer_base<T>::buffer_base(pointer p, size_type n, const A& a)
+        : m_alloc(a)
+    {
+        assign_storage(p, n, n);
+    }
 
-        buffer(buffer&&);
-        buffer& operator=(buffer&&);
+    template <class T>
+    buffer_base<T>::~buffer_base()
+    {
+        deallocate(m_data.p_begin, (m_data.p_storage_end - m_data.p_begin));
+    }
 
-        void resize(size_type new_size);
-        void resize(size_type new_size, value_type value);
-        void clear();
+    template <class T>
+    template <allocator A>
+    constexpr buffer_base<T>::buffer_base(buffer_base&& rhs, const A& a)
+        : m_alloc(a)
+        , m_data(std::move(rhs.m_data))
+    {
+    }
 
-    private:
+    template <class T>
+    constexpr auto buffer_base<T>::get_allocator() noexcept -> allocator_type&
+    {
+        return m_alloc;
+    }
 
-        pointer allocate(size_type size) const;
-        void deallocate(pointer mem) const;
-    };
+    template <class T>
+    constexpr auto buffer_base<T>::get_allocator() const noexcept -> const allocator_type&
+    {
+        return m_alloc;
+    }
 
-    /*
-     * @class buffer_view
-     * @brief Object that references but does not own a piece of contiguous memory
-     */
     template <class T>
-    class buffer_view : public buffer_base<T>
+    constexpr auto buffer_base<T>::get_data() noexcept -> buffer_data&
     {
-    public:
+        return m_data;
+    }
 
-        using base_type = buffer_base<T>;
-        using pointer = typename base_type::pointer;
-        using size_type = typename base_type::size_type;
+    template <class T>
+    constexpr auto buffer_base<T>::get_data() const noexcept -> const buffer_data&
+    {
+        return m_data;
+    }
 
-        explicit buffer_view(buffer<T>& buffer);
-        buffer_view(pointer data, size_type size);
-        ~buffer_view() = default;
+    template <class T>
+    constexpr auto buffer_base<T>::allocate(size_type n) -> pointer
+    {
+        return alloc_traits::allocate(m_alloc, n);
+    }
 
-        buffer_view(const buffer_view&) = default;
-        buffer_view& operator=(const buffer_view&) = default;
+    template <class T>
+    constexpr void buffer_base<T>::deallocate(pointer p, size_type n)
+    {
+        alloc_traits::deallocate(m_alloc, p, n);
+    }
 
-        buffer_view(buffer_view&&) = default;
-        buffer_view& operator=(buffer_view&&) = default;
-    };
+    template <class T>
+    constexpr void buffer_base<T>::create_storage(size_type n)
+    {
+        m_data.p_begin = allocate(n);
+        m_data.p_end = m_data.p_begin + n;
+        m_data.p_storage_end = m_data.p_begin + n;
+    }
 
-    /******************************
-     * buffer_base implementation *
-     ******************************/
+    template <class T>
+    constexpr void buffer_base<T>::assign_storage(pointer p, size_type n, size_type cap)
+    {
+        assert(n <= cap);
+        m_data.p_begin = p;
+        m_data.p_end = p + n;
+        m_data.p_storage_end = p + cap;
+    }
+
+    /*************************
+     * buffer implementation *
+     *************************/
+
+    template <class T>
+    template <allocator A>
+    constexpr buffer<T>::buffer(size_type n, const A& a)
+        : base_type(check_init_length(n, a), a)
+    {
+        get_data().p_end = default_initialize(get_data().p_begin, n, get_allocator());
+    }
+
+    template <class T>
+    template <allocator A>
+    constexpr buffer<T>::buffer(size_type n, const value_type& v, const A& a)
+        : base_type(check_init_length(n, a), a)
+    {
+        get_data().p_end = fill_initialize(get_data().p_begin, n, v, get_allocator());
+    }
+
+    template <class T>
+    template <allocator A>
+    constexpr buffer<T>::buffer(pointer p, size_type n, const A& a)
+        : base_type(p, check_init_length(n, a), a)
+    {
+    }
+
+    template <class T>
+    template <allocator A>
+    constexpr buffer<T>::buffer(std::initializer_list<value_type> init, const A& a)
+        : base_type(check_init_length(init.size(), a), a)
+    {
+        get_data().p_end = copy_initialize(init.begin(), init.end(), get_data().p_begin, get_allocator());
+    }
 
     template <class T>
-    buffer_base<T>::buffer_base(pointer p, size_type n)
-        : p_data(p)
-        , m_size(n)
+    template <class It, allocator A>
+    constexpr buffer<T>::buffer(It first, It last, const A& a)
+        : base_type(check_init_length(std::distance(first, last), a), a)
+    {
+        get_data().p_end = copy_initialize(first, last, get_data().p_begin, get_allocator());
+    }
+
+    template <class T>
+    buffer<T>::~buffer()
     {
+        destroy(get_data().p_begin, get_data().p_end, get_allocator());
+    }
+
+    template <class T>
+    buffer<T>::buffer(const buffer& rhs)
+        : base_type(rhs.size(), rhs.get_allocator())
+    {
+        get_data().p_end = copy_initialize(rhs.begin(), rhs.end(), get_data().p_begin, get_allocator());
+    }
+
+    template <class T>
+    template <allocator A>
+    buffer<T>::buffer(const buffer& rhs, const A& a)
+        : base_type(rhs.size(), a)
+    {
+        get_data().p_end = copy_initialize(rhs.begin(), rhs.end(), get_data().p_begin, get_allocator());
+    }
+
+    template <class T>
+    template <allocator A>
+    buffer<T>::buffer(buffer&& rhs, const A& a)
+        : base_type(a)
+    {
+        if (rhs.get_allocator() == get_allocator())
+        {
+            get_data() = std::move(rhs.m_data);
+        }
+        else if (!rhs.empty())
+        {
+            this->create_storage(rhs.size());
+            get_data().p_end = copy_initialize(rhs.begin(), rhs.end(), get_data().p_begin, get_allocator());
+            rhs.clear();
+        }
     }
 
     template <class T>
-    void buffer_base<T>::reset(pointer p, size_type n)
+    buffer<T>& buffer<T>::operator=(const buffer& rhs)
     {
-        p_data = p;
-        m_size = n;
+        if (std::addressof(rhs) != this)
+        {
+            // We assume that any_allocator never propagates on assign
+            assign_range_impl(rhs.get_data().p_begin, rhs.get_data().p_end, std::random_access_iterator_tag());
+        }
+        return *this;
     }
 
     template <class T>
-    bool buffer_base<T>::empty() const noexcept
+    buffer<T>& buffer<T>::operator=(buffer&& rhs)
     {
-        return size() == size_type(0);
+        if (get_allocator() == rhs.get_allocator())
+        {
+            get_data() = std::move(rhs.get_data());
+        }
+        else
+        {
+            assign_range_impl(
+                std::make_move_iterator(rhs.begin()),
+                std::make_move_iterator(rhs.end()),
+                std::random_access_iterator_tag()
+            );
+            rhs.clear();
+        }
+        return *this;
     }
 
     template <class T>
-    auto buffer_base<T>::size() const noexcept -> size_type
+    buffer<T>& buffer<T>::operator=(std::initializer_list<value_type> init)
     {
-        return m_size;
+        assign_range_impl(
+            std::make_move_iterator(init.begin()),
+            std::make_move_iterator(init.end()),
+            std::random_access_iterator_tag()
+        );
+        return *this;
     }
 
     template <class T>
-    auto buffer_base<T>::operator[](size_type pos) -> reference
+    constexpr auto buffer<T>::operator[](size_type i) -> reference
     {
-        assert(pos < size());
-        return data()[pos];
+        return get_data().p_begin[i];
     }
 
     template <class T>
-    auto buffer_base<T>::operator[](size_type pos) const -> const_reference
+    constexpr auto buffer<T>::operator[](size_type i) const -> const_reference
     {
-        assert(pos < size());
-        return data()[pos];
+        return get_data().p_begin[i];
     }
 
     template <class T>
-    auto buffer_base<T>::front() -> reference
+    constexpr auto buffer<T>::front() -> reference
     {
-        assert(!empty());
-        return data()[0];
+        return *(get_data().p_begin);
     }
 
     template <class T>
-    auto buffer_base<T>::front() const -> const_reference
+    constexpr auto buffer<T>::front() const -> const_reference
     {
-        assert(!empty());
-        return data()[0];
+        return *(get_data().p_begin);
     }
 
     template <class T>
-    auto buffer_base<T>::back() -> reference
+    constexpr auto buffer<T>::back() -> reference
     {
-        assert(!empty());
-        return data()[m_size - 1];
+        return *(get_data().p_end - 1);
     }
 
     template <class T>
-    auto buffer_base<T>::back() const -> const_reference
+    constexpr auto buffer<T>::back() const -> const_reference
     {
-        assert(!empty());
-        return data()[m_size - 1];
+        return *(get_data().p_end - 1);
     }
 
     template <class T>
     template <class U>
-    U* buffer_base<T>::data() noexcept
+    constexpr U* buffer<T>::data() noexcept
     {
-        return reinterpret_cast<U*>(p_data);
+        return reinterpret_cast<U*>(get_data().p_begin);
     }
 
     template <class T>
     template <class U>
-    const U* buffer_base<T>::data() const noexcept
+    constexpr const U* buffer<T>::data() const noexcept
     {
-        return reinterpret_cast<const U*>(p_data);
+        return reinterpret_cast<U*>(get_data().p_begin);
     }
 
     template <class T>
-    auto buffer_base<T>::begin() -> iterator
+    constexpr auto buffer<T>::begin() noexcept -> iterator
     {
-        return iterator(p_data);
+        return make_pointer_iterator(get_data().p_begin);
     }
 
     template <class T>
-    auto buffer_base<T>::end() -> iterator
+    constexpr auto buffer<T>::end() noexcept -> iterator
     {
-        return iterator(p_data + m_size);
+        return make_pointer_iterator(get_data().p_end);
     }
 
     template <class T>
-    auto buffer_base<T>::begin() const -> const_iterator
+    constexpr auto buffer<T>::begin() const noexcept -> const_iterator
     {
         return cbegin();
     }
 
     template <class T>
-    auto buffer_base<T>::end() const -> const_iterator
+    constexpr auto buffer<T>::end() const noexcept -> const_iterator
     {
         return cend();
     }
 
     template <class T>
-    auto buffer_base<T>::cbegin() const -> const_iterator
+    constexpr auto buffer<T>::cbegin() const noexcept -> const_iterator
     {
-        return const_iterator(p_data);
+        return make_pointer_iterator(const_pointer(get_data().p_begin));
     }
 
     template <class T>
-    auto buffer_base<T>::cend() const -> const_iterator
+    constexpr auto buffer<T>::cend() const noexcept -> const_iterator
     {
-        return const_iterator(p_data + m_size);
+        return make_pointer_iterator(const_pointer(get_data().p_end));
     }
 
     template <class T>
-    auto buffer_base<T>::rbegin() -> reverse_iterator
+    constexpr auto buffer<T>::rbegin() noexcept -> reverse_iterator
     {
         return reverse_iterator(end());
     }
 
     template <class T>
-    auto buffer_base<T>::rend() -> reverse_iterator
+    constexpr auto buffer<T>::rend() noexcept -> reverse_iterator
     {
         return reverse_iterator(begin());
     }
 
     template <class T>
-    auto buffer_base<T>::rbegin() const -> const_reverse_iterator
+    constexpr auto buffer<T>::rbegin() const noexcept -> const_reverse_iterator
     {
         return crbegin();
     }
 
     template <class T>
-    auto buffer_base<T>::rend() const -> const_reverse_iterator
+    constexpr auto buffer<T>::rend() const noexcept -> const_reverse_iterator
     {
         return crend();
     }
 
     template <class T>
-    auto buffer_base<T>::crbegin() const -> const_reverse_iterator
+    constexpr auto buffer<T>::crbegin() const noexcept -> const_reverse_iterator
     {
-        return const_reverse_iterator(cend());
+        return const_reverse_iterator(end());
     }
 
     template <class T>
-    auto buffer_base<T>::crend() const -> const_reverse_iterator
+    constexpr auto buffer<T>::crend() const noexcept -> const_reverse_iterator
     {
-        return const_reverse_iterator(cbegin());
+        return const_reverse_iterator(begin());
     }
 
     template <class T>
-    void buffer_base<T>::swap(buffer_base<T>& rhs) noexcept
+    constexpr bool buffer<T>::empty() const noexcept
     {
-        std::swap(p_data, rhs.p_data);
-        std::swap(m_size, rhs.m_size);
+        return get_data().p_begin == get_data().p_end;
     }
 
     template <class T>
-    bool buffer_base<T>::equal(const buffer_base<T>& rhs) const
+    constexpr auto buffer<T>::capacity() const noexcept -> size_type
     {
-        return m_size == rhs.m_size && std::equal(p_data, p_data + m_size, rhs.p_data);
+        return static_cast<size_type>(get_data().p_storage_end - get_data().p_begin);
     }
 
     template <class T>
-    bool operator==(const buffer_base<T>& lhs, const buffer_base<T>& rhs)
+    constexpr auto buffer<T>::size() const noexcept -> size_type
     {
-        return lhs.equal(rhs);
+        return static_cast<size_type>(get_data().p_end - get_data().p_begin);
     }
 
-    /*************************
-     * buffer implementation *
-     *************************/
+    template <class T>
+    constexpr auto buffer<T>::max_size() const noexcept -> size_type
+    {
+        return max_size_impl(get_allocator());
+    }
 
     template <class T>
-    buffer<T>::buffer(size_type size)
-        : base_type{allocate(size), size}
+    constexpr void buffer<T>::reserve(size_type new_cap)
     {
+        if (new_cap > max_size())
+        {
+            throw std::length_error("buffer::reserve called with new_cap > max_size()");
+        }
+        if (new_cap > capacity())
+        {
+            const size_type old_size = size();
+            pointer tmp = allocate_and_copy(
+                new_cap,
+                std::make_move_iterator(get_data().p_begin),
+                std::make_move_iterator(get_data().p_end)
+            );
+            destroy(get_data().p_begin, get_data().p_end, get_allocator());
+            this->deallocate(get_data().p_begin, get_data().p_storage_end - get_data().p_begin);
+            this->assign_storage(tmp, old_size, new_cap);
+        }
     }
 
     template <class T>
-    buffer<T>::buffer(size_type size, value_type value)
-        : base_type{allocate(size), size}
+    constexpr void buffer<T>::shrink_to_fit()
     {
-        std::fill_n(base_type::data(), size, value);
+        if (capacity() != size())
+        {
+            buffer(std::make_move_iterator(begin()), std::make_move_iterator(end()), get_allocator()).swap(*this);
+        }
     }
 
     template <class T>
-    buffer<T>::buffer(pointer data, size_type size)
-        : base_type{data, size}
+    constexpr void buffer<T>::clear()
     {
+        erase_at_end(get_data().p_begin);
     }
 
     template <class T>
-    buffer<T>::~buffer()
+    constexpr void buffer<T>::resize(size_type new_size)
+    {
+        resize_impl(
+            new_size,
+            [this](size_type nb_init)
+            {
+                get_data().p_end = default_initialize(get_data().p_end, nb_init, get_allocator());
+            }
+        );
+    }
+
+    template <class T>
+    constexpr void buffer<T>::resize(size_type new_size, const value_type& value)
     {
-        deallocate(base_type::data());
+        resize_impl(
+            new_size,
+            [this, &value](size_type nb_init)
+            {
+                get_data().p_end = fill_initialize(get_data().p_end, nb_init, value, get_allocator());
+            }
+        );
     }
 
     template <class T>
-    buffer<T>::buffer(const buffer<T>& rhs)
-        : base_type{allocate(rhs.size()), rhs.size()}
+    constexpr void buffer<T>::swap(buffer& rhs)
     {
-        std::copy(rhs.data(), rhs.data() + rhs.size(), base_type::data());
+        std::swap(this->get_data(), rhs.get_data());
     }
 
     template <class T>
-    buffer<T>& buffer<T>::operator=(const buffer<T>& rhs)
+    template <class F>
+    constexpr void buffer<T>::resize_impl(size_type new_size, F&& initializer)
     {
-        if (this != &rhs)
+        if (new_size > size())
         {
-            buffer<T> tmp(rhs);
-            base_type::swap(tmp);
+            const size_t nb_init = new_size - size();
+            if (new_size <= capacity())
+            {
+                initializer(nb_init);
+            }
+            else
+            {
+                reserve(new_size);
+                initializer(nb_init);
+            }
+        }
+        else if (new_size < size())
+        {
+            erase_at_end(get_data().p_begin + new_size);
         }
-        return *this;
     }
 
     template <class T>
-    buffer<T>::buffer(buffer&& rhs)
-        : base_type{rhs.data(), rhs.size()}
+    template <class It>
+    constexpr void buffer<T>::assign_range_impl(It first, It last, std::forward_iterator_tag)
     {
-        rhs.reset(nullptr, 0u);
+        const size_type sz = size();
+        const size_type len = std::distance(first, last);
+        if (len > capacity())
+        {
+            check_init_length(len, get_allocator());
+            pointer p = allocate_and_copy(len, first, last);
+            destroy(get_data().p_begin, get_data().p_end, get_allocator());
+            this->deallocate(get_data().p_begin, capacity());
+            this->assign_storage(p, len, len);
+        }
+        else if (sz >= len)
+        {
+            pointer p = std::copy(first, last, get_data().p_begin);
+            erase_at_end(p);
+        }
+        else
+        {
+            It mid = first;
+            std::advance(mid, sz);
+            std::copy(first, mid, get_data().p_begin);
+            get_data().p_end = copy_initialize(mid, last, get_data().p_end, get_allocator());
+        }
     }
 
     template <class T>
-    buffer<T>& buffer<T>::operator=(buffer<T>&& rhs)
+    constexpr void buffer<T>::erase_at_end(pointer p)
     {
-        base_type::swap(rhs);
-        return *this;
+        destroy(p, get_data().p_end, get_allocator());
+        get_data().p_end = p;
     }
 
     template <class T>
-    void buffer<T>::resize(size_type n)
+    template <class It>
+    constexpr auto buffer<T>::allocate_and_copy(size_type n, It first, It last) -> pointer
     {
-        // TODO: add capacity, resize if growing only and define a shrink_to_fit method
-        if (n != base_type::size())
+        pointer p = this->allocate(n);
+        try
+        {
+            copy_initialize(first, last, p, get_allocator());
+        }
+        catch (...)
         {
-            buffer<T> tmp(n);
-            const size_type copy_size = std::min(base_type::size(), n);
-            std::copy(base_type::data(), base_type::data() + copy_size, tmp.data());
-            base_type::swap(tmp);
+            this->deallocate(p, n);
+            throw;
         }
+        return p;
     }
 
     template <class T>
-    void buffer<T>::resize(size_type n, value_type value)
+    constexpr auto buffer<T>::check_init_length(size_type n, const allocator_type& a) -> size_type
     {
-        const size_type old_size = base_type::size();
-        resize(n);
-        if (old_size < n)
+        if (n > max_size_impl(a))
         {
-            std::fill(base_type::data() + old_size, base_type::data() + n, value);
+            throw std::length_error("cannot create buffer larger than max_size()");
         }
+        return n;
     }
 
     template <class T>
-    void buffer<T>::clear()
+    constexpr auto buffer<T>::max_size_impl(const allocator_type& a) noexcept -> size_type
     {
-        resize(size_type(0));
+        const size_type diff_max = std::numeric_limits<difference_type>::max();
+        const size_type alloc_max = std::allocator_traits<allocator_type>::max_size(a);
+        return (std::min)(diff_max, alloc_max);
     }
 
     template <class T>
-    auto buffer<T>::allocate(size_type size) const -> pointer
+    constexpr auto buffer<T>::default_initialize(pointer begin, size_type n, allocator_type& a) -> pointer
     {
-        return new T[size];
+        pointer current = begin;
+        for (; n > 0; --n, ++current)
+        {
+            alloc_traits::construct(a, current);
+        }
+        return current;
     }
 
     template <class T>
-    void buffer<T>::deallocate(pointer mem) const
+    constexpr auto
+    buffer<T>::fill_initialize(pointer begin, size_type n, const value_type& v, allocator_type& a) -> pointer
     {
-        delete[] mem;
+        pointer current = begin;
+        for (; n > 0; --n, ++current)
+        {
+            alloc_traits::construct(a, current, v);
+        }
+        return current;
     }
 
-    /******************************
-     * buffer_view implementation *
-     ******************************/
+    template <class T>
+    template <class It>
+    constexpr auto buffer<T>::copy_initialize(It first, It last, pointer begin, allocator_type& a) -> pointer
+    {
+        pointer current = begin;
+        for (; first != last; ++first, ++current)
+        {
+            alloc_traits::construct(a, current, *first);
+        }
+        return current;
+    }
 
     template <class T>
-    buffer_view<T>::buffer_view(buffer<T>& buffer)
-        : base_type{buffer.data(), buffer.size()}
+    constexpr void buffer<T>::destroy(pointer first, pointer last, allocator_type& a)
     {
+        for (; first != last; ++first)
+        {
+            alloc_traits::destroy(a, first);
+        }
     }
 
     template <class T>
-    buffer_view<T>::buffer_view(pointer data, size_type size)
-        : base_type{data, size}
+    constexpr bool operator==(const buffer<T>& lhs, const buffer<T>& rhs) noexcept
     {
+        return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
     }
 }
diff --git a/include/sparrow/buffer_view.hpp b/include/sparrow/buffer_view.hpp
new file mode 100644
index 00000000..7c7399ee
--- /dev/null
+++ b/include/sparrow/buffer_view.hpp
@@ -0,0 +1,270 @@
+// Copyright 2024 Man Group Operations Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "sparrow/buffer.hpp"
+
+namespace sparrow
+{
+    /*
+     * Non-owning view of a contiguous sequence of objects of type T.
+     *
+     * Although this class looks very similar to std::span, it provides
+     * methods that are missing in C++20 std::span (like cbegin / cend),
+     * and additional std::vector-like APIs. 
+     */
+    template <class T>
+    class buffer_view
+    {
+    public:
+
+        using self_type = buffer_view<T>;
+        using value_type = T;
+        using reference = T&;
+        using const_reference = const T&;
+        using pointer = T*;
+        using const_pointer = const T*;
+        using size_type = std::size_t;
+        using difference_type = std::ptrdiff_t;
+
+        using iterator = pointer_iterator<pointer>;
+        using const_iterator = pointer_iterator<const_pointer>;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        explicit buffer_view(buffer<T>& buffer);
+        buffer_view(pointer p, size_type n);
+        // TODO: To be complete we also need a subrange(...) function
+        // and a constructor that takes a pair of iterators (they should
+        // be template parameters constrained by concept, not buffer_view::iterator).
+        // These are often used with view types (see std::span, which also provides
+        // first and last subview functions).
+
+        bool empty() const noexcept;
+        size_type size() const noexcept;
+
+        reference operator[](size_type);
+        const_reference operator[](size_type) const;
+
+        reference front();
+        const_reference front() const;
+
+        reference back();
+        const_reference back() const;
+
+        template <class U = T>
+        U* data() noexcept;
+
+        template <class U = T>
+        const U* data() const noexcept;
+
+        iterator begin();
+        iterator end();
+
+        const_iterator begin() const;
+        const_iterator end() const;
+        const_iterator cbegin() const;
+        const_iterator cend() const;
+
+        reverse_iterator rbegin();
+        reverse_iterator rend();
+
+        const_reverse_iterator rbegin() const;
+        const_reverse_iterator rend() const;
+        const_reverse_iterator crbegin() const;
+        const_reverse_iterator crend() const;
+
+        void swap(buffer_view& rhs) noexcept;
+
+    private:
+
+        pointer p_data = nullptr;
+        size_type m_size = 0u;
+    };
+
+    template <class T>
+    bool operator==(const buffer_view<T>& lhs, const buffer_view<T>& rhs);
+
+    /******************************
+     * buffer_view implementation *
+     ******************************/
+
+    template <class T>
+    buffer_view<T>::buffer_view(buffer<T>& buffer)
+        : p_data(buffer.data())
+        , m_size(buffer.size())
+    {
+    }
+
+    template <class T>
+    buffer_view<T>::buffer_view(pointer p, size_type n)
+        : p_data(p)
+        , m_size(n)
+    {
+    }
+
+    template <class T>
+    bool buffer_view<T>::empty() const noexcept
+    {
+        return size() == size_type(0);
+    }
+
+    template <class T>
+    auto buffer_view<T>::size() const noexcept -> size_type
+    {
+        return m_size;
+    }
+
+    template <class T>
+    auto buffer_view<T>::operator[](size_type pos) -> reference
+    {
+        assert(pos < size());
+        return data()[pos];
+    }
+
+    template <class T>
+    auto buffer_view<T>::operator[](size_type pos) const -> const_reference
+    {
+        assert(pos < size());
+        return data()[pos];
+    }
+
+    template <class T>
+    auto buffer_view<T>::front() -> reference
+    {
+        assert(!empty());
+        return data()[0];
+    }
+
+    template <class T>
+    auto buffer_view<T>::front() const -> const_reference
+    {
+        assert(!empty());
+        return data()[0];
+    }
+
+    template <class T>
+    auto buffer_view<T>::back() -> reference
+    {
+        assert(!empty());
+        return data()[m_size - 1];
+    }
+
+    template <class T>
+    auto buffer_view<T>::back() const -> const_reference
+    {
+        assert(!empty());
+        return data()[m_size - 1];
+    }
+
+    template <class T>
+    template <class U>
+    U* buffer_view<T>::data() noexcept
+    {
+        return reinterpret_cast<U*>(p_data);
+    }
+
+    template <class T>
+    template <class U>
+    const U* buffer_view<T>::data() const noexcept
+    {
+        return reinterpret_cast<const U*>(p_data);
+    }
+
+    template <class T>
+    auto buffer_view<T>::begin() -> iterator
+    {
+        return iterator(p_data);
+    }
+
+    template <class T>
+    auto buffer_view<T>::end() -> iterator
+    {
+        return iterator(p_data + m_size);
+    }
+
+    template <class T>
+    auto buffer_view<T>::begin() const -> const_iterator
+    {
+        return cbegin();
+    }
+
+    template <class T>
+    auto buffer_view<T>::end() const -> const_iterator
+    {
+        return cend();
+    }
+
+    template <class T>
+    auto buffer_view<T>::cbegin() const -> const_iterator
+    {
+        return const_iterator(p_data);
+    }
+
+    template <class T>
+    auto buffer_view<T>::cend() const -> const_iterator
+    {
+        return const_iterator(p_data + m_size);
+    }
+
+    template <class T>
+    auto buffer_view<T>::rbegin() -> reverse_iterator
+    {
+        return reverse_iterator(end());
+    }
+
+    template <class T>
+    auto buffer_view<T>::rend() -> reverse_iterator
+    {
+        return reverse_iterator(begin());
+    }
+
+    template <class T>
+    auto buffer_view<T>::rbegin() const -> const_reverse_iterator
+    {
+        return crbegin();
+    }
+
+    template <class T>
+    auto buffer_view<T>::rend() const -> const_reverse_iterator
+    {
+        return crend();
+    }
+
+    template <class T>
+    auto buffer_view<T>::crbegin() const -> const_reverse_iterator
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    template <class T>
+    auto buffer_view<T>::crend() const -> const_reverse_iterator
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+    template <class T>
+    void buffer_view<T>::swap(buffer_view<T>& rhs) noexcept
+    {
+        std::swap(p_data, rhs.p_data);
+        std::swap(m_size, rhs.m_size);
+    }
+
+    template <class T>
+    bool operator==(const buffer_view<T>& lhs, const buffer_view<T>& rhs)
+    {
+        return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
+    }
+}
diff --git a/include/sparrow/dynamic_bitset.hpp b/include/sparrow/dynamic_bitset.hpp
index 7daff465..78de7c25 100644
--- a/include/sparrow/dynamic_bitset.hpp
+++ b/include/sparrow/dynamic_bitset.hpp
@@ -20,6 +20,7 @@
 #include <ranges>
 
 #include "sparrow/buffer.hpp"
+#include "sparrow/buffer_view.hpp"
 #include "sparrow/mp_utils.hpp"
 
 namespace sparrow
diff --git a/test/test_allocator.cpp b/test/test_allocator.cpp
index 9d5ac6bc..acd0cced 100644
--- a/test/test_allocator.cpp
+++ b/test/test_allocator.cpp
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "doctest/doctest.h"
-
 #include <memory>
 #include <memory_resource>
 #include <numeric>
@@ -21,6 +19,8 @@
 
 #include "sparrow/allocator.hpp"
 
+#include "doctest/doctest.h"
+
 TEST_SUITE("any_allocator")
 {
     TEST_CASE_TEMPLATE_DEFINE("value semantic", A, value_semantic_id)
@@ -81,11 +81,13 @@ TEST_SUITE("any_allocator")
 #if __APPLE__
     // /usr/lib/libc++.1.dylib is missing the symbol __ZNSt3__13pmr20get_default_resourceEv, leading
     // to an exception at runtime.
-    TEST_CASE_TEMPLATE_INVOKE(value_semantic_id, std::allocator<int>/*, std::pmr::polymorphic_allocator<int>*/);
-    TEST_CASE_TEMPLATE_INVOKE(allocate_id, std::allocator<int>/*, std::pmr::polymorphic_allocator<int>*/);
+    TEST_CASE_TEMPLATE_INVOKE(
+        value_semantic_id,
+        std::allocator<int> /*, std::pmr::polymorphic_allocator<int>*/
+    );
+    TEST_CASE_TEMPLATE_INVOKE(allocate_id, std::allocator<int> /*, std::pmr::polymorphic_allocator<int>*/);
 #else
     TEST_CASE_TEMPLATE_INVOKE(value_semantic_id, std::allocator<int>, std::pmr::polymorphic_allocator<int>);
     TEST_CASE_TEMPLATE_INVOKE(allocate_id, std::allocator<int>, std::pmr::polymorphic_allocator<int>);
 #endif
 }
-
diff --git a/test/test_buffer.cpp b/test/test_buffer.cpp
index 298cd6f4..f5f220f1 100644
--- a/test/test_buffer.cpp
+++ b/test/test_buffer.cpp
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <iterator>
 #include <numeric>
+#include <ranges>
 
 #include "sparrow/buffer.hpp"
+#include "sparrow/buffer_view.hpp"
 
 #include "doctest/doctest.h"
 
@@ -69,6 +72,20 @@ namespace sparrow
             {
                 CHECK_EQ(b3[i], expected_value);
             }
+
+            buffer_test_type b4 = {1u, 3u, 5u};
+            CHECK_EQ(b4.size(), 3u);
+            CHECK_EQ(b4[0], 1u);
+            CHECK_EQ(b4[1], 3u);
+            CHECK_EQ(b4[2], 5u);
+
+            std::vector<buffer_test_type::value_type> exp = {2u, 4u, 6u};
+            buffer_test_type b5(exp.cbegin(), exp.cend());
+            CHECK_EQ(b5.size(), exp.size());
+            for (size_t i = 0; i < 3u; ++i)
+            {
+                CHECK_EQ(b5[i], exp[i]);
+            }
         }
 
         TEST_CASE("copy semantic")
@@ -104,15 +121,7 @@ namespace sparrow
             CHECK_EQ(b4, control);
         }
 
-        TEST_CASE("empty")
-        {
-            buffer_test_type b1;
-            CHECK(b1.empty());
-
-            const std::size_t size = 4u;
-            buffer_test_type b2(make_test_buffer(size), size);
-            CHECK(!b2.empty());
-        }
+        // Element access
 
         TEST_CASE("operator[]")
         {
@@ -161,32 +170,124 @@ namespace sparrow
             CHECK_EQ(b3.data()[idx], expected_value);
         }
 
-        TEST_CASE("equality comparison")
+        // Iterators
+
+        static_assert(std::ranges::contiguous_range<buffer_test_type>);
+        static_assert(std::contiguous_iterator<buffer_test_type::iterator>);
+        static_assert(std::contiguous_iterator<buffer_test_type::const_iterator>);
+
+        TEST_CASE("iterator")
+        {
+            const std::size_t size = 8u;
+            buffer_test_type b(make_test_buffer(size), size);
+            auto iter = b.begin();
+            auto citer = b.cbegin();
+            for (std::size_t i = 0; i < b.size(); ++i)
+            {
+                CHECK_EQ(*iter++, b[i]);
+                CHECK_EQ(*citer++, b[i]);
+            }
+            CHECK_EQ(iter, b.end());
+            CHECK_EQ(citer, b.cend());
+        }
+
+        TEST_CASE("reverse_iterator")
         {
+            const std::size_t size = 8u;
+            buffer_test_type b(make_test_buffer(size), size);
+            auto iter = b.rbegin();
+            auto citer = b.crbegin();
+            for (std::size_t i = b.size(); i != 0u; --i)
+            {
+                CHECK_EQ(*iter++, b[i - 1]);
+                CHECK_EQ(*citer++, b[i - 1]);
+            }
+            CHECK_EQ(iter, b.rend());
+            CHECK_EQ(citer, b.crend());
+        }
+
+        TEST_CASE("iterator_consistency")
+        {
+            const std::size_t size = 8u;
+            buffer_test_type b(make_test_buffer(size), size);
+
+            {
+                auto iter = --b.end();
+                auto riter = b.rbegin();
+                auto citer = --b.cend();
+                auto criter = b.crbegin();
+
+                while (iter != b.begin())
+                {
+                    CHECK_EQ(*iter, *riter);
+                    CHECK_EQ(*citer, *criter);
+                    --iter, --citer, ++riter, ++criter;
+                }
+            }
+
+            {
+                auto iter = b.begin();
+                auto riter = --b.rend();
+                auto citer = b.cbegin();
+                auto criter = --b.crend();
+
+                while (iter != b.end())
+                {
+                    CHECK_EQ(*iter, *riter);
+                    CHECK_EQ(*citer, *criter);
+                    ++iter, ++citer, --riter, --criter;
+                }
+            }
+        }
+
+        // capacity
+
+        TEST_CASE("empty")
+        {
+            buffer_test_type b1;
+            CHECK(b1.empty());
+
             const std::size_t size = 4u;
-            buffer_test_type b1(make_test_buffer(size), size);
             buffer_test_type b2(make_test_buffer(size), size);
-            CHECK(b1 == b2);
+            CHECK(!b2.empty());
+        }
 
-            const std::size_t size2 = 8u;
-            buffer_test_type b3(make_test_buffer(size2), size2);
-            CHECK(b1 != b3);
+        TEST_CASE("capacity")
+        {
+            const std::size_t size = 4u;
+            buffer_test_type b(make_test_buffer(size), size);
+            CHECK_EQ(b.capacity(), size);
         }
 
-        TEST_CASE("swap")
+        TEST_CASE("size")
+        {
+            const std::size_t size = 4u;
+            buffer_test_type b(make_test_buffer(size), size);
+            CHECK_EQ(b.size(), size);
+        }
+
+        // modifiers
+
+        TEST_CASE("clear")
         {
             const std::size_t size1 = 4u;
-            const std::size_t size2 = 8u;
+            buffer_test_type b(make_test_buffer(size1), size1);
+            b.clear();
+            CHECK_EQ(b.size(), 0u);
+        }
 
+        TEST_CASE("reserve")
+        {
+            const std::size_t size1 = 4u;
             buffer_test_type b1(make_test_buffer(size1), size1);
-            buffer_test_type b2(make_test_buffer(size2), size2);
-            auto* data1 = b1.data();
-            auto* data2 = b2.data();
-            b1.swap(b2);
-            CHECK_EQ(b1.size(), size2);
-            CHECK_EQ(b1.data(), data2);
-            CHECK_EQ(b2.size(), size1);
-            CHECK_EQ(b2.data(), data1);
+            buffer_test_type b2(b1);
+            const std::size_t new_cap = 8u;
+            b1.reserve(new_cap);
+            CHECK_EQ(b1.capacity(), new_cap);
+            for (std::size_t i = 0; i < size1; ++i)
+            {
+                CHECK_EQ(b1.data()[i], b2.data()[i]);
+            }
         }
 
         TEST_CASE("resize")
@@ -203,47 +304,51 @@ namespace sparrow
             CHECK_EQ(b.data()[2], 2);
 
             const std::size_t size3 = 6u;
-            b.resize(size3);
+            const buffer_test_type::value_type v = 7u;
+            b.resize(size3, v);
             CHECK_EQ(b.size(), size3);
             CHECK_EQ(b.data()[2], 2);
+            CHECK_EQ(b.data()[4], v);
+            CHECK_EQ(b.data()[5], v);
         }
 
-        TEST_CASE("clear")
+        TEST_CASE("shrink_to_fit")
         {
             const std::size_t size1 = 4u;
-            buffer_test_type b(make_test_buffer(size1), size1);
-            b.clear();
-            CHECK_EQ(b.size(), 0u);
+            buffer_test_type b1(make_test_buffer(size1), size1);
+            const std::size_t new_cap = 8u;
+            b1.reserve(new_cap);
+            CHECK_EQ(b1.capacity(), new_cap);
+            b1.shrink_to_fit();
+            CHECK_EQ(b1.capacity(), size1);
         }
 
-        TEST_CASE("iterator")
+        TEST_CASE("swap")
         {
-            const std::size_t size = 8u;
-            buffer_test_type b(make_test_buffer(size), size);
-            auto iter = b.begin();
-            auto citer = b.cbegin();
-            for (std::size_t i = 0; i < b.size(); ++i)
-            {
-                CHECK_EQ(*iter++, b[i]);
-                CHECK_EQ(*citer++, b[i]);
-            }
-            CHECK_EQ(iter, b.end());
-            CHECK_EQ(citer, b.cend());
+            const std::size_t size1 = 4u;
+            const std::size_t size2 = 8u;
+
+            buffer_test_type b1(make_test_buffer(size1), size1);
+            buffer_test_type b2(make_test_buffer(size2), size2);
+            auto* data1 = b1.data();
+            auto* data2 = b2.data();
+            b1.swap(b2);
+            CHECK_EQ(b1.size(), size2);
+            CHECK_EQ(b1.data(), data2);
+            CHECK_EQ(b2.size(), size1);
+            CHECK_EQ(b2.data(), data1);
         }
 
-        TEST_CASE("reverse_iterator")
+        TEST_CASE("equality comparison")
         {
-            const std::size_t size = 8u;
-            buffer_test_type b(make_test_buffer(size), size);
-            auto iter = b.rbegin();
-            auto citer = b.crbegin();
-            for (std::size_t i = b.size(); i != 0u; --i)
-            {
-                CHECK_EQ(*iter++, b[i - 1]);
-                CHECK_EQ(*citer++, b[i - 1]);
-            }
-            CHECK_EQ(iter, b.rend());
-            CHECK_EQ(citer, b.crend());
+            const std::size_t size = 4u;
+            buffer_test_type b1(make_test_buffer(size), size);
+            buffer_test_type b2(make_test_buffer(size), size);
+            CHECK(b1 == b2);
+
+            const std::size_t size2 = 8u;
+            buffer_test_type b3(make_test_buffer(size2), size2);
+            CHECK(b1 != b3);
         }
     }