From 15728b20307f91cac2eb4709e4d012ce7da40569 Mon Sep 17 00:00:00 2001
From: DerThorsten <derthorstenbeier@gmail.com>
Date: Tue, 17 Dec 2024 10:50:45 +0100
Subject: [PATCH 1/2] precommit-fixes

---
 .pre-commit-config.yaml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 987e5aa1..3e99ab08 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,4 +2,5 @@ repos:
 - repo: https://github.com/pre-commit/mirrors-clang-format
   rev: v19.1.5
   hooks:
-  - id: clang-format
\ No newline at end of file
+  - id: clang-format
+    exclude_types: [javascript, json]
\ No newline at end of file

From bb20ce720a00afed4c9f989d78aa07fc6d56a21e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 17 Dec 2024 09:51:21 +0000
Subject: [PATCH 2/2] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 examples/builder_example.cpp                  | 120 ++-
 examples/typed_array_high_level.cpp           |  17 +-
 examples/typed_array_low_level.cpp            |   5 +-
 include/sparrow/array.hpp                     |   2 +-
 include/sparrow/array_factory.hpp             |   2 +-
 .../arrow_array/private_data.hpp              |   1 -
 .../arrow_array_schema_info_utils.hpp         |   2 +-
 .../arrow_array_schema_utils.hpp              |   8 +-
 .../sparrow/arrow_interface/arrow_schema.hpp  |   4 +-
 include/sparrow/buffer/allocator.hpp          |   1 -
 include/sparrow/buffer/buffer.hpp             |   6 +-
 include/sparrow/buffer/buffer_adaptor.hpp     |   8 +-
 include/sparrow/buffer/buffer_view.hpp        |   8 +-
 include/sparrow/buffer/dynamic_bitset.hpp     |   4 +-
 .../buffer/dynamic_bitset/bitset_iterator.hpp |   8 +-
 .../dynamic_bitset/bitset_reference.hpp       |   2 +-
 .../buffer/dynamic_bitset/dynamic_bitset.hpp  |  61 +-
 .../dynamic_bitset/dynamic_bitset_base.hpp    |  17 +-
 .../dynamic_bitset/dynamic_bitset_view.hpp    |   1 -
 include/sparrow/buffer/u8_buffer.hpp          |  55 +-
 include/sparrow/builder/builder.hpp           | 715 +++++++++---------
 include/sparrow/builder/builder_utils.hpp     | 549 +++++++-------
 include/sparrow/builder/nested_eq.hpp         |  82 +-
 include/sparrow/builder/nested_less.hpp       | 112 +--
 include/sparrow/config/config.hpp             |  16 +-
 include/sparrow/layout/array_access.hpp       |   8 +-
 include/sparrow/layout/array_base.hpp         |  16 +-
 include/sparrow/layout/array_bitmap_base.hpp  |  14 +-
 include/sparrow/layout/array_wrapper.hpp      |  47 +-
 .../layout/dictionary_encoded_array.hpp       |   5 +-
 include/sparrow/layout/dispatch.hpp           | 164 ++--
 include/sparrow/layout/layout_utils.hpp       |  22 +-
 .../sparrow/layout/list_layout/list_array.hpp | 208 ++---
 .../sparrow/layout/list_layout/list_value.hpp |   1 -
 include/sparrow/layout/nested_value_types.hpp |   2 +-
 include/sparrow/layout/null_array.hpp         |   2 +-
 .../run_end_encoded_array.hpp                 |  61 +-
 .../run_end_encoded_iterator.hpp              |  61 +-
 .../layout/struct_layout/struct_array.hpp     |  59 +-
 .../layout/struct_layout/struct_value.hpp     |   3 +-
 include/sparrow/layout/union_array.hpp        | 272 +++----
 .../variable_size_binary_array.hpp            |  27 +-
 .../variable_size_binary_iterator.hpp         |   4 +-
 .../variable_size_binary_reference.hpp        |   1 -
 .../variable_size_binary_view_array.hpp       | 186 ++---
 include/sparrow/record_batch.hpp              |   3 +-
 include/sparrow/types/data_traits.hpp         |  21 +-
 include/sparrow/utils/bit.hpp                 |   2 +-
 include/sparrow/utils/crtp_base.hpp           |   6 +-
 .../sparrow/utils/functor_index_iterator.hpp  |  21 +-
 include/sparrow/utils/iterator.hpp            |   2 +-
 include/sparrow/utils/large_int.hpp           |  63 +-
 include/sparrow/utils/memory.hpp              |  93 +--
 include/sparrow/utils/mp_utils.hpp            |  25 +-
 include/sparrow/utils/nullable.hpp            | 271 +++----
 include/sparrow/utils/offsets.hpp             |  18 +-
 include/sparrow/utils/ranges.hpp              |  14 +-
 src/array_factory.cpp                         | 183 ++---
 src/array_helper.cpp                          |  37 +-
 src/arrow_array_schema_proxy.cpp              |   3 +-
 src/arrow_interface/arrow_array.cpp           |  48 +-
 src/arrow_interface/arrow_schema.cpp          |   1 -
 src/dummy32bit.cpp                            |   6 +-
 src/list_value.cpp                            |   5 +-
 src/run_encoded_array.cpp                     |  86 +--
 src/struct_value.cpp                          |   4 +-
 test/better_junit_reporter.hpp                |   4 +-
 test/external_array_data_creation.cpp         | 154 ++--
 test/external_array_data_creation.hpp         |   1 -
 test/junit_xml_writer.hpp                     |   4 +-
 test/test_array_wrapper.cpp                   |  10 +-
 test/test_arrow_array.cpp                     |  10 +-
 test/test_buffer_adaptor.cpp                  |   3 +-
 test/test_builder.cpp                         |  92 +--
 test/test_builder_dict_encoded.cpp            | 145 ++--
 test/test_builder_run_end_encoded.cpp         | 133 ++--
 test/test_builder_utils.cpp                   | 147 ++--
 test/test_decimal.cpp                         | 110 +--
 test/test_decimal_array.cpp                   |  31 +-
 test/test_dispatch.cpp                        |  10 +-
 test/test_high_level_constructors.cpp         |  57 +-
 test/test_list_array.cpp                      | 106 ++-
 test/test_list_value.cpp                      |  14 +-
 test/test_memory.cpp                          |   9 +-
 test/test_nested_comperators.cpp              |  38 +-
 test/test_null_array.cpp                      |   4 +-
 test/test_nullable.cpp                        |  96 ++-
 test/test_record_batch.cpp                    |  26 +-
 test/test_run_end_encoded_array.cpp           |  92 ++-
 test/test_struct_array.cpp                    |  55 +-
 test/test_traits.cpp                          |  31 +-
 test/test_union_array.cpp                     | 332 ++++----
 test/test_utils.cpp                           |   2 +-
 test/test_utils.hpp                           | 101 +--
 test/test_utils_buffers.cpp                   |   1 -
 test/test_utils_offsets.cpp                   |   3 +-
 test/test_variable_size_binary_view_array.cpp |  17 +-
 97 files changed, 2929 insertions(+), 2790 deletions(-)

diff --git a/examples/builder_example.cpp b/examples/builder_example.cpp
index 36aebf2d..6406c016 100644
--- a/examples/builder_example.cpp
+++ b/examples/builder_example.cpp
@@ -3,17 +3,17 @@
  */
 
 
-#include <vector>
 #include <array>
-#include <tuple>
+#include <cassert>
 #include <list>
 #include <string>
-#include <cassert>
+#include <tuple>
+#include <vector>
 
 #include <sparrow/builder/builder.hpp>
 
 void primitve_array()
-{   
+{
     //! [builder_primitive_array]
     // using initializer_list
     auto arr = sparrow::build({1, 2, 3, 4, 5});
@@ -27,9 +27,13 @@ void primitve_array()
     auto arr3 = sparrow::build(l);
     /////////////////////
     // using any range
-    auto iota = std::views::iota(1, 6) | std::views::transform([](int i){ 
-        return static_cast<int>(i);
-    });
+    auto iota = std::views::iota(1, 6)
+                | std::views::transform(
+                    [](int i)
+                    {
+                        return static_cast<int>(i);
+                    }
+                );
     auto arr4 = sparrow::build(iota);
     /////////////////////
     // all of the arrays above are equivalent to the manually built array
@@ -42,8 +46,8 @@ void primitve_array()
 }
 
 void primitve_array_with_nulls()
-{   
-//! [builder_primitive_array_with_nulls]
+{
+    //! [builder_primitive_array_with_nulls]
     // using initializer_list (here we have to explicitly specify the type when using an
     // initializer list with nulls)
     auto arr = sparrow::build<sparrow::nullable<int>>({1, 2, sparrow::nullval, 4, 5});
@@ -57,9 +61,13 @@ void primitve_array_with_nulls()
     auto arr3 = sparrow::build(l);
     /////////////////////
     // using any range
-    auto iota = std::views::iota(1, 6) | std::views::transform([](int i) -> sparrow::nullable<int> { 
-        return i == 3 ? sparrow::nullable<int>{} : sparrow::nullable<int>{i};
-    });
+    auto iota = std::views::iota(1, 6)
+                | std::views::transform(
+                    [](int i) -> sparrow::nullable<int>
+                    {
+                        return i == 3 ? sparrow::nullable<int>{} : sparrow::nullable<int>{i};
+                    }
+                );
     auto arr4 = sparrow::build(iota);
     // all of the arrays above are equivalent to the manually built array
     std::vector<std::size_t> where_nulls{2};
@@ -68,29 +76,26 @@ void primitve_array_with_nulls()
     assert(arr == arr2);
     assert(arr == arr3);
     assert(arr == arr4);
-//! [builder_primitive_array_with_nulls]
+    //! [builder_primitive_array_with_nulls]
 }
 
 void list_of_strings()
-{   
+{
     //! [builder_list_of_strings]
     // [["hello", "world","!"], ["Another", "sentence"]]
-    std::vector<std::vector<std::string>> v{
-        {"hello", "world", "!"}, 
-        {"Another", "sentence"}
-    };
+    std::vector<std::vector<std::string>> v{{"hello", "world", "!"}, {"Another", "sentence"}};
     auto arr = sparrow::build(v);
     //! [builder_list_of_strings]
 }
 
-void list_of_strings_with_nulls()   
+void list_of_strings_with_nulls()
 {
     //! [builder_list_of_strings_with_nulls]
     // [["hello", "world","!"],NULL , ["Another", "sentence"]]
     using string_vector = std::vector<std::string>;
     using nullable_string_vector = sparrow::nullable<string_vector>;
     std::vector<nullable_string_vector> v{
-        nullable_string_vector{string_vector{"hello", "world", "!"}}, 
+        nullable_string_vector{string_vector{"hello", "world", "!"}},
         nullable_string_vector{},
         nullable_string_vector{string_vector{"Another", "sentence"}}
     };
@@ -98,19 +103,18 @@ void list_of_strings_with_nulls()
     //! [builder_list_of_strings_with_nulls]
 }
 
-
 void list_of_struct()
 {
     //! [builder_list_of_struct]
     /*
     [
         [
-            (1, 2.5), 
+            (1, 2.5),
             (2, 3.5)
         ],
         [
-            (3, 5.5), 
-            (5, 6.5), 
+            (3, 5.5),
+            (5, 6.5),
             (6, 7.5)
         ],
         [
@@ -119,45 +123,28 @@ void list_of_struct()
     ]
     */
     std::vector<std::vector<std::tuple<int, float>>> v{
-        {
-            std::tuple<int, float>{1, 2.5}, 
-            std::tuple<int, float>{2, 3.5}
-        },
-        {	
-            std::tuple<int, float>{3, 5.5}, 
-            std::tuple<int, float>{5, 6.5},
-            std::tuple<int, float>{6, 7.5}
-        },
-        {
-            std::tuple<int, float>{7, 8.5}
-        }
+        {std::tuple<int, float>{1, 2.5}, std::tuple<int, float>{2, 3.5}},
+        {std::tuple<int, float>{3, 5.5}, std::tuple<int, float>{5, 6.5}, std::tuple<int, float>{6, 7.5}},
+        {std::tuple<int, float>{7, 8.5}}
     };
     auto arr = sparrow::build(v);
     //! [builder_list_of_struct]
 }
 
 void fixed_sized_list_strings()
-{	
+{
     //! [builder_fixed_sized_list_strings]
-    std::vector<std::array<std::string, 2>> v{
-        {"hello", "world"},
-        {"Another", "sentence"},
-        {"This", "is"}
-    };
+    std::vector<std::array<std::string, 2>> v{{"hello", "world"}, {"Another", "sentence"}, {"This", "is"}};
     auto arr = sparrow::build(v);
     //! [builder_fixed_sized_list_strings]
 }
 
 void fixed_sized_list_of_union()
-{	
+{
     //! [builder_fixed_sized_list_of_union]
     using variant_type = std::variant<int, float>;
     using array_type = std::array<variant_type, 2>;
-    std::vector<array_type> v{
-        {1, 2.5f},
-        {2, 3.5f},
-        {3, 4.5f}
-    };
+    std::vector<array_type> v{{1, 2.5f}, {2, 3.5f}, {3, 4.5f}};
     auto arr = sparrow::build(v);
     //! [builder_fixed_sized_list_of_union]
 }
@@ -165,15 +152,13 @@ void fixed_sized_list_of_union()
 void dict_encoded_variable_sized_binary()
 {
     //! [builder_dict_encoded_variable_sized_binary]
-    sparrow::dict_encode<std::vector<std::string>> v{
-        std::vector<std::string>{
-            "hello", 
-            "world", 
-            "hello",
-            "world",
-            "hello",
-        }
-    };
+    sparrow::dict_encode<std::vector<std::string>> v{std::vector<std::string>{
+        "hello",
+        "world",
+        "hello",
+        "world",
+        "hello",
+    }};
     auto arr = sparrow::build(v);
     //! [builder_dict_encoded_variable_sized_binary]
 }
@@ -181,15 +166,13 @@ void dict_encoded_variable_sized_binary()
 void run_end_encoded_variable_sized_binary()
 {
     //! [builder_run_end_encoded_variable_sized_binary]
-    sparrow::run_end_encode<std::vector<std::string>> v{
-        std::vector<std::string>{
-            "hello", 
-            "hello", 
-            "hello",
-            "world",
-            "world",
-        }
-    };
+    sparrow::run_end_encode<std::vector<std::string>> v{std::vector<std::string>{
+        "hello",
+        "hello",
+        "hello",
+        "world",
+        "world",
+    }};
     auto arr = sparrow::build(v);
     //! [builder_run_end_encoded_variable_sized_binary]
 }
@@ -197,7 +180,7 @@ void run_end_encoded_variable_sized_binary()
 void struct_array()
 {
     //! [builder_struct_array]
-    using tuple_type = std::tuple<int,  std::array<std::string, 2>, sparrow::nullable<float>>;
+    using tuple_type = std::tuple<int, std::array<std::string, 2>, sparrow::nullable<float>>;
     std::vector<tuple_type> v{
         {1, {"hello", "world"}, 2.5f},
         {2, {"Another", "sentence"}, sparrow::nullval},
@@ -210,7 +193,7 @@ void struct_array()
 void sparse_union_array()
 {
     //! [builder_union_array]
-    using variant_type = std::variant<int,  std::array<std::string, 2>, sparrow::nullable<float>>;
+    using variant_type = std::variant<int, std::array<std::string, 2>, sparrow::nullable<float>>;
     std::vector<variant_type> v{
         int{1},
         std::array<std::string, 2>{{"A", "sentence"}},
@@ -221,7 +204,6 @@ void sparse_union_array()
     //! [builder_union_array]
 }
 
-
 int main()
 {
     primitve_array();
diff --git a/examples/typed_array_high_level.cpp b/examples/typed_array_high_level.cpp
index 57bcf95a..b1256fbd 100644
--- a/examples/typed_array_high_level.cpp
+++ b/examples/typed_array_high_level.cpp
@@ -3,13 +3,13 @@
  * The range can be a range of values or a range of nullable values.
  */
 
-//#include <sparrow/array/array_data.hpp>
+// #include <sparrow/array/array_data.hpp>
 
 
 /*void example_typed_array_of_floats(){
     using value_type = float;
     std::vector<value_type> data = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
-    
+
     // construct the array
     auto array = sparrow::typed_array<value_type>(data);
 
@@ -34,7 +34,7 @@ void example_typed_array_of_strings(){
         "four",
         "five"
     };
-    
+
     // construct the array
     auto array = sparrow::typed_array<value_type>(data);
 
@@ -61,7 +61,7 @@ void example_typed_array_of_strings_from_nullables(){
         nullable_type("four"),
         nullable_type("five")
     };
-    
+
     // construct the array
     auto array = sparrow::typed_array<value_type>(data);
 
@@ -75,9 +75,10 @@ void example_typed_array_of_strings_from_nullables(){
         }
     }
 }*/
-int main() {
-    //example_typed_array_of_floats();
-    //example_typed_array_of_strings();
-    //example_typed_array_of_strings_from_nullables();
+int main()
+{
+    // example_typed_array_of_floats();
+    // example_typed_array_of_strings();
+    // example_typed_array_of_strings_from_nullables();
     return 0;
 }
diff --git a/examples/typed_array_low_level.cpp b/examples/typed_array_low_level.cpp
index c19e5bd2..2d84725e 100644
--- a/examples/typed_array_low_level.cpp
+++ b/examples/typed_array_low_level.cpp
@@ -4,9 +4,10 @@
  * The typed_array is created from the array_data and the data is accessed.
  */
 
-//#include <sparrow/array/array_data.hpp>
+// #include <sparrow/array/array_data.hpp>
 
-int main() {
+int main()
+{
     /////////////////////////////////////////////////
     // create array_data with 5 float32 elements
     // where the value at index 2 is missing
diff --git a/include/sparrow/array.hpp b/include/sparrow/array.hpp
index 1766e5cf..58ffe80e 100644
--- a/include/sparrow/array.hpp
+++ b/include/sparrow/array.hpp
@@ -20,7 +20,7 @@
 namespace sparrow
 {
     template <layout A>
-    requires (not std::is_lvalue_reference_v<A>)
+        requires(not std::is_lvalue_reference_v<A>)
     array::array(A&& a)
         : p_array(new array_wrapper_impl<A>(std::move(a)))
     {
diff --git a/include/sparrow/array_factory.hpp b/include/sparrow/array_factory.hpp
index 4672d9dd..ed4ba700 100644
--- a/include/sparrow/array_factory.hpp
+++ b/include/sparrow/array_factory.hpp
@@ -24,5 +24,5 @@
 namespace sparrow
 {
     SPARROW_API cloning_ptr<array_wrapper> array_factory(arrow_proxy proxy);
-    
+
 }
diff --git a/include/sparrow/arrow_interface/arrow_array/private_data.hpp b/include/sparrow/arrow_interface/arrow_array/private_data.hpp
index 277dcf33..68c65919 100644
--- a/include/sparrow/arrow_interface/arrow_array/private_data.hpp
+++ b/include/sparrow/arrow_interface/arrow_array/private_data.hpp
@@ -55,7 +55,6 @@ namespace sparrow
 
         BufferType m_buffers;
         std::vector<std::uint8_t*> m_buffers_pointers;
-
     };
 
     constexpr arrow_array_private_data::arrow_array_private_data(BufferType buffers, std::size_t children_size)
diff --git a/include/sparrow/arrow_interface/arrow_array_schema_info_utils.hpp b/include/sparrow/arrow_interface/arrow_array_schema_info_utils.hpp
index ce625c84..d6539a57 100644
--- a/include/sparrow/arrow_interface/arrow_array_schema_info_utils.hpp
+++ b/include/sparrow/arrow_interface/arrow_array_schema_info_utils.hpp
@@ -31,7 +31,7 @@ namespace sparrow
         return true;
         /* THE CODE USED TO MAKES WRONG ASSUMPTIONS AND NEEDS TO BE REFACTORED IN A SEPERATE PR*/
     }
-    
+
     constexpr bool has_bitmap(data_type dt)
     {
         switch (dt)
diff --git a/include/sparrow/arrow_interface/arrow_array_schema_utils.hpp b/include/sparrow/arrow_interface/arrow_array_schema_utils.hpp
index dd095af1..2af6fa6a 100644
--- a/include/sparrow/arrow_interface/arrow_array_schema_utils.hpp
+++ b/include/sparrow/arrow_interface/arrow_array_schema_utils.hpp
@@ -53,12 +53,12 @@ namespace sparrow
 
     /**
      * Release the children and dictionnary of an `ArrowArray` or `ArrowSchema`.
-     * 
+     *
      * @tparam T `ArrowArray` or `ArrowSchema`
      * @param t The `ArrowArray` or `ArrowSchema` to release.
      */
     template <class T>
-    requires std::same_as<T, ArrowArray> || std::same_as<T, ArrowSchema>
+        requires std::same_as<T, ArrowArray> || std::same_as<T, ArrowSchema>
     void release_common_arrow(T& t);
 
     /**
@@ -174,14 +174,14 @@ namespace sparrow
     }
 
     template <class T>
-    requires std::same_as<T, ArrowArray> || std::same_as<T, ArrowSchema>
+        requires std::same_as<T, ArrowArray> || std::same_as<T, ArrowSchema>
     void release_common_arrow(T& t)
     {
         if (t.release == nullptr)
         {
             return;
         }
-        
+
         if (t.dictionary)
         {
             if (t.dictionary->release)
diff --git a/include/sparrow/arrow_interface/arrow_schema.hpp b/include/sparrow/arrow_interface/arrow_schema.hpp
index 67bf60e5..309760bb 100644
--- a/include/sparrow/arrow_interface/arrow_schema.hpp
+++ b/include/sparrow/arrow_interface/arrow_schema.hpp
@@ -20,7 +20,6 @@
 #include "sparrow/config/config.hpp"
 #include "sparrow/utils/contracts.hpp"
 
-
 namespace sparrow
 {
     /**
@@ -65,7 +64,8 @@ namespace sparrow
     SPARROW_API void release_arrow_schema(ArrowSchema* schema);
 
     /**
-     * Empty release function to use for the `ArrowSchema.release` member.  Should be used for view of ArrowSchema.
+     * Empty release function to use for the `ArrowSchema.release` member.  Should be used for view of
+     * ArrowSchema.
      */
     SPARROW_API void empty_release_arrow_schema(ArrowSchema* schema);
 
diff --git a/include/sparrow/buffer/allocator.hpp b/include/sparrow/buffer/allocator.hpp
index a0dc13a4..a965e937 100644
--- a/include/sparrow/buffer/allocator.hpp
+++ b/include/sparrow/buffer/allocator.hpp
@@ -22,7 +22,6 @@
 
 #include "sparrow/utils/variant_visitor.hpp"
 
-
 namespace sparrow
 {
     /*
diff --git a/include/sparrow/buffer/buffer.hpp b/include/sparrow/buffer/buffer.hpp
index a91b47bd..ddcf5354 100644
--- a/include/sparrow/buffer/buffer.hpp
+++ b/include/sparrow/buffer/buffer.hpp
@@ -736,10 +736,10 @@ namespace sparrow
         }
     }
 
-    template<class T>
+    template <class T>
     constexpr void buffer<T>::reserve_with_growth_factor(size_type new_cap)
     {
-        if(new_cap > capacity())
+        if (new_cap > capacity())
         {
             reserve(new_cap * SPARROW_BUFFER_GROWTH_FACTOR);
         }
@@ -785,7 +785,7 @@ namespace sparrow
         const difference_type offset = std::distance(cbegin(), pos);
         if (count != 0)
         {
-            reserve_with_growth_factor( size() + count);
+            reserve_with_growth_factor(size() + count);
             const iterator it = std::next(begin(), offset);
             std::move_backward(it, end(), std::next(end(), static_cast<difference_type>(count)));
             std::fill_n(it, count, value);
diff --git a/include/sparrow/buffer/buffer_adaptor.hpp b/include/sparrow/buffer/buffer_adaptor.hpp
index d4d46a84..28ccdecd 100644
--- a/include/sparrow/buffer/buffer_adaptor.hpp
+++ b/include/sparrow/buffer/buffer_adaptor.hpp
@@ -22,7 +22,6 @@
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/mp_utils.hpp"
 
-
 namespace sparrow
 {
     template <typename FromBufferRef, typename T>
@@ -184,16 +183,17 @@ namespace sparrow
         size_type m_max_size;
     };
 
-
-    template<class T>
+    template <class T>
     class holder
     {
     public:
-        template<class ...Args>
+
+        template <class... Args>
         holder(Args&&... args)
             : value(std::forward<Args>(args)...)
         {
         }
+
         T value;
     };
 
diff --git a/include/sparrow/buffer/buffer_view.hpp b/include/sparrow/buffer/buffer_view.hpp
index 69535b5f..c06b3493 100644
--- a/include/sparrow/buffer/buffer_view.hpp
+++ b/include/sparrow/buffer/buffer_view.hpp
@@ -46,7 +46,8 @@ namespace sparrow
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
         buffer_view() = default;
-        explicit buffer_view(buffer<T>& buffer) requires (!std::is_const_v<T>);
+        explicit buffer_view(buffer<T>& buffer)
+            requires(!std::is_const_v<T>);
         template <class U>
             requires std::same_as<std::remove_const_t<T>, U>
         explicit buffer_view(const buffer<U>& buffer);
@@ -114,7 +115,8 @@ namespace sparrow
      ******************************/
 
     template <class T>
-    buffer_view<T>::buffer_view(buffer<T>& buffer) requires (!std::is_const_v<T>)
+    buffer_view<T>::buffer_view(buffer<T>& buffer)
+        requires(!std::is_const_v<T>)
         : p_data(buffer.data())
         , m_size(buffer.size())
     {
@@ -339,7 +341,7 @@ namespace sparrow
     template <class T>
     buffer_view<T>::operator buffer<std::remove_const_t<T>>() const
     {
-        return { p_data, p_data + m_size };
+        return {p_data, p_data + m_size};
     }
 
     template <class T>
diff --git a/include/sparrow/buffer/dynamic_bitset.hpp b/include/sparrow/buffer/dynamic_bitset.hpp
index 78038abd..70d8251f 100644
--- a/include/sparrow/buffer/dynamic_bitset.hpp
+++ b/include/sparrow/buffer/dynamic_bitset.hpp
@@ -14,6 +14,6 @@
 
 #pragma once
 
+#include "sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp"
-#include "sparrow/buffer/dynamic_bitset/non_owning_dynamic_bitset.hpp"
-#include "sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp"
\ No newline at end of file
+#include "sparrow/buffer/dynamic_bitset/non_owning_dynamic_bitset.hpp"
\ No newline at end of file
diff --git a/include/sparrow/buffer/dynamic_bitset/bitset_iterator.hpp b/include/sparrow/buffer/dynamic_bitset/bitset_iterator.hpp
index 05470832..aaf8cdbd 100644
--- a/include/sparrow/buffer/dynamic_bitset/bitset_iterator.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/bitset_iterator.hpp
@@ -14,9 +14,9 @@
 
 #pragma once
 
+#include "sparrow/utils/contracts.hpp"
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/mp_utils.hpp"
-#include "sparrow/utils/contracts.hpp"
 
 namespace sparrow
 {
@@ -94,7 +94,7 @@ namespace sparrow
     {
         if constexpr (is_const)
         {
-            if(p_bitset->data() == nullptr)
+            if (p_bitset->data() == nullptr)
             {
                 return true;
             }
@@ -182,8 +182,8 @@ namespace sparrow
     }
 
     template <class B, bool is_const>
-    constexpr auto
-    bitset_iterator<B, is_const>::distance_to(const self_type& rhs) const noexcept -> difference_type
+    constexpr auto bitset_iterator<B, is_const>::distance_to(const self_type& rhs) const noexcept
+        -> difference_type
     {
         if (p_block == rhs.p_block)
         {
diff --git a/include/sparrow/buffer/dynamic_bitset/bitset_reference.hpp b/include/sparrow/buffer/dynamic_bitset/bitset_reference.hpp
index ef7585ad..98b8f893 100644
--- a/include/sparrow/buffer/dynamic_bitset/bitset_reference.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/bitset_reference.hpp
@@ -101,7 +101,7 @@ namespace sparrow
     template <class B>
     constexpr bitset_reference<B>::operator bool() const noexcept
     {
-        if(m_bitset.data() == nullptr)
+        if (m_bitset.data() == nullptr)
         {
             return true;
         }
diff --git a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp
index b1dcf204..971e8cf1 100644
--- a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp
@@ -14,8 +14,8 @@
 
 #pragma once
 
-#include "sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp"
 #include "sparrow/buffer/buffer.hpp"
+#include "sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp"
 #include "sparrow/utils/ranges.hpp"
 
 namespace sparrow
@@ -38,15 +38,16 @@ namespace sparrow
         using value_type = typename base_type::value_type;
         using size_type = typename base_type::size_type;
 
-        template<std::ranges::input_range R>
-        requires std::convertible_to<std::ranges::range_value_t<R>, value_type>
+        template <std::ranges::input_range R>
+            requires std::convertible_to<std::ranges::range_value_t<R>, value_type>
         explicit dynamic_bitset(const R& r)
             : dynamic_bitset(std::ranges::size(r), true)
         {
             std::size_t i = 0;
-            for(auto value : r)
+            for (auto value : r)
             {
-                if(!value){
+                if (!value)
+                {
                     this->set(i, false);
                 }
                 i++;
@@ -109,25 +110,24 @@ namespace sparrow
     {
     }
 
-
     using validity_bitmap = dynamic_bitset<std::uint8_t>;
 
-    
     namespace detail
     {
         using validity_bitmap = sparrow::validity_bitmap;
-        inline validity_bitmap ensure_validity_bitmap_impl(std::size_t size, const validity_bitmap & bitmap)
+
+        inline validity_bitmap ensure_validity_bitmap_impl(std::size_t size, const validity_bitmap& bitmap)
         {
-            if(bitmap.size() == 0)
+            if (bitmap.size() == 0)
             {
                 return validity_bitmap(size, true);
             }
-            return bitmap; // copy
+            return bitmap;  // copy
         }
-    
-        inline validity_bitmap ensure_validity_bitmap_impl(std::size_t size, validity_bitmap && bitmap)
+
+        inline validity_bitmap ensure_validity_bitmap_impl(std::size_t size, validity_bitmap&& bitmap)
         {
-            if(bitmap.size() == 0)
+            if (bitmap.size() == 0)
             {
                 bitmap.resize(size, true);
             }
@@ -136,15 +136,16 @@ namespace sparrow
 
         // range of booleans
         template <std::ranges::input_range R>
-        requires(std::same_as<std::ranges::range_value_t<R>, bool>)
+            requires(std::same_as<std::ranges::range_value_t<R>, bool>)
         validity_bitmap ensure_validity_bitmap_impl(std::size_t size, R&& range)
-        {   
+        {
             SPARROW_ASSERT_TRUE(size == range_size(range) || range_size(range) == 0);
             validity_bitmap bitmap(size, true);
             std::size_t i = 0;
-            for(auto value : range)
+            for (auto value : range)
             {
-                if(!value){
+                if (!value)
+                {
                     bitmap.set(i, false);
                 }
                 i++;
@@ -154,33 +155,29 @@ namespace sparrow
 
         // range of indices / integers (but not booleans)
         template <std::ranges::input_range R>
-        requires(
-            std::unsigned_integral<std::ranges::range_value_t<R>> &&
-            !std::same_as<std::ranges::range_value_t<R>, bool> &&
-            !std::same_as<std::decay_t<R>, validity_bitmap> 
-        )
+            requires(std::unsigned_integral<std::ranges::range_value_t<R>> && !std::same_as<std::ranges::range_value_t<R>, bool> && !std::same_as<std::decay_t<R>, validity_bitmap>)
         validity_bitmap ensure_validity_bitmap_impl(std::size_t size, R&& range_of_indices)
-        { 
+        {
             validity_bitmap bitmap(size, true);
-            for(auto index : range_of_indices)
+            for (auto index : range_of_indices)
             {
                 bitmap.set(index, false);
             }
             return bitmap;
         }
-    } // namespace detail
+    }  // namespace detail
 
     template <class T>
-    concept validity_bitmap_input = 
-        std::same_as<T, validity_bitmap> || 
-        std::same_as<T, const validity_bitmap&> ||
-        (std::ranges::input_range<T> && std::same_as<std::ranges::range_value_t<T>, bool>) ||
-        (std::ranges::input_range<T> && std::unsigned_integral<std::ranges::range_value_t<T>> );
+    concept validity_bitmap_input = std::same_as<T, validity_bitmap> || std::same_as<T, const validity_bitmap&>
+                                    || (std::ranges::input_range<T>
+                                        && std::same_as<std::ranges::range_value_t<T>, bool>)
+                                    || (std::ranges::input_range<T>
+                                        && std::unsigned_integral<std::ranges::range_value_t<T>>);
 
     template <validity_bitmap_input R>
     validity_bitmap ensure_validity_bitmap(std::size_t size, R&& validity_input)
     {
         return detail::ensure_validity_bitmap_impl(size, std::forward<R>(validity_input));
     }
-       
-} // namespace sparrow
\ No newline at end of file
+
+}  // namespace sparrow
\ No newline at end of file
diff --git a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp
index 074b537f..a5c55746 100644
--- a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp
@@ -110,10 +110,11 @@ namespace sparrow
             }
         }
 
-        static constexpr size_type compute_block_count(size_type bits_count) noexcept;        
+        static constexpr size_type compute_block_count(size_type bits_count) noexcept;
 
-        // storage_type is a value_type 
-        storage_type extract_storage() noexcept requires std::same_as<storage_type, storage_type_without_cvrefpointer>
+        // storage_type is a value_type
+        storage_type extract_storage() noexcept
+            requires std::same_as<storage_type, storage_type_without_cvrefpointer>
         {
             return std::move(m_buffer);
         }
@@ -208,7 +209,7 @@ namespace sparrow
     constexpr bool dynamic_bitset_base<B>::test(size_type pos) const
     {
         SPARROW_ASSERT_TRUE(pos < size());
-        if(data() == nullptr)
+        if (data() == nullptr)
         {
             return true;
         }
@@ -350,7 +351,7 @@ namespace sparrow
     constexpr auto dynamic_bitset_base<B>::front() const -> const_reference
     {
         SPARROW_ASSERT_TRUE(size() >= 1);
-        if(data() == nullptr)
+        if (data() == nullptr)
         {
             return true;
         }
@@ -370,7 +371,7 @@ namespace sparrow
     constexpr auto dynamic_bitset_base<B>::back() const -> const_reference
     {
         SPARROW_ASSERT_TRUE(size() >= 1);
-        if(data() == nullptr)
+        if (data() == nullptr)
         {
             return true;
         }
@@ -437,7 +438,7 @@ namespace sparrow
         requires std::ranges::random_access_range<std::remove_pointer_t<B>>
     auto dynamic_bitset_base<B>::count_non_null() const noexcept -> size_type
     {
-        if(data() == nullptr)
+        if (data() == nullptr)
         {
             return m_size;
         }
@@ -474,7 +475,7 @@ namespace sparrow
         requires std::ranges::random_access_range<std::remove_pointer_t<B>>
     constexpr void dynamic_bitset_base<B>::zero_unused_bits()
     {
-        if(data() == nullptr)
+        if (data() == nullptr)
         {
             return;
         }
diff --git a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp
index 56faff72..037fa34b 100644
--- a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp
@@ -17,7 +17,6 @@
 #include "sparrow/buffer/buffer_view.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp"
 
-
 namespace sparrow
 {
     /**
diff --git a/include/sparrow/buffer/u8_buffer.hpp b/include/sparrow/buffer/u8_buffer.hpp
index 4c3e2f37..6d014b44 100644
--- a/include/sparrow/buffer/u8_buffer.hpp
+++ b/include/sparrow/buffer/u8_buffer.hpp
@@ -18,7 +18,6 @@
 #include <ranges>
 #include <type_traits>
 
-#include "sparrow/utils/ranges.hpp"
 #include "sparrow/buffer/buffer_adaptor.hpp"
 #include "sparrow/utils/ranges.hpp"
 
@@ -27,30 +26,34 @@ namespace sparrow
 
     namespace detail
     {
-        template<class T>
+        template <class T>
         class holder
         {
         public:
-            template<class ...Args>
+
+            template <class... Args>
             holder(Args&&... args)
                 : value(std::forward<Args>(args)...)
             {
             }
+
             T value;
 
-            T extract_storage() && 
+            T extract_storage() &&
             {
                 return std::move(value);
             }
 
-            const T & storage() const
+            const T& storage() const
             {
                 return value;
             }
-            T & storage()
+
+            T& storage()
             {
                 return value;
             }
+
             void assign(T&& other)
             {
                 value = std::move(other);
@@ -59,14 +62,15 @@ namespace sparrow
     }
 
     // like buffer<T> but for any type T, nut always use buffer<std::uint8_t> as storage
-    // This internal storage can be extracted 
-    template<class T>
+    // This internal storage can be extracted
+    template <class T>
     class u8_buffer : private detail::holder<buffer<std::uint8_t>>,
-                           public buffer_adaptor<T, buffer<std::uint8_t>&>
+                      public buffer_adaptor<T, buffer<std::uint8_t>&>
     {
     public:
+
         using holder_type = detail::holder<buffer<std::uint8_t>>;
-        using buffer_adaptor_type  = buffer_adaptor<T, buffer<std::uint8_t>&>;
+        using buffer_adaptor_type = buffer_adaptor<T, buffer<std::uint8_t>&>;
         using holder_type::extract_storage;
 
         u8_buffer(u8_buffer&& other);
@@ -74,50 +78,49 @@ namespace sparrow
         u8_buffer& operator=(u8_buffer&& other) = delete;
         u8_buffer& operator=(u8_buffer& other) = delete;
 
-        u8_buffer(std::size_t n, const T & val = T{});
-        template<std::ranges::input_range R>
-        requires(!std::same_as<u8_buffer<T>, std::decay_t<R>> && std::convertible_to<std::ranges::range_value_t<R>, T>)
+        u8_buffer(std::size_t n, const T& val = T{});
+        template <std::ranges::input_range R>
+            requires(!std::same_as<u8_buffer<T>, std::decay_t<R>> && std::convertible_to<std::ranges::range_value_t<R>, T>)
         u8_buffer(R&& range);
         u8_buffer(std::initializer_list<T> ilist);
     };
 
-
-    template<class T>
+    template <class T>
     u8_buffer<T>::u8_buffer(u8_buffer&& other)
         : holder_type(std::move(other).extract_storage())
         , buffer_adaptor_type(holder_type::value)
     {
     }
 
-    template<class T>
+    template <class T>
     u8_buffer<T>::u8_buffer(const u8_buffer& other)
         : holder_type(other.storage())
         , buffer_adaptor_type(holder_type::value)
     {
     }
 
-    template<class T>
-    u8_buffer<T>::u8_buffer(std::size_t n, const T & val)
+    template <class T>
+    u8_buffer<T>::u8_buffer(std::size_t n, const T& val)
         : holder_type{n * sizeof(T)}
         , buffer_adaptor_type(holder_type::value)
     {
         std::fill(this->begin(), this->end(), val);
     }
-    
 
-    template<class T>
-    template<std::ranges::input_range R>
-    requires(!std::same_as<u8_buffer<T>, std::decay_t<R>> && std::convertible_to<std::ranges::range_value_t<R>, T>)
+    template <class T>
+    template <std::ranges::input_range R>
+        requires(!std::same_as<u8_buffer<T>, std::decay_t<R>>
+                 && std::convertible_to<std::ranges::range_value_t<R>, T>)
     u8_buffer<T>::u8_buffer(R&& range)
-        : holder_type{range_size(range)* sizeof(T)}
-        ,buffer_adaptor_type(holder_type::value)
+        : holder_type{range_size(range) * sizeof(T)}
+        , buffer_adaptor_type(holder_type::value)
     {
         std::ranges::copy(range, this->begin());
     }
 
-    template<class T>
+    template <class T>
     u8_buffer<T>::u8_buffer(std::initializer_list<T> ilist)
-    : holder_type{ilist.size() * sizeof(T)}
+        : holder_type{ilist.size() * sizeof(T)}
         , buffer_adaptor_type(holder_type::value)
     {
         std::copy(ilist.begin(), ilist.end(), this->begin());
diff --git a/include/sparrow/builder/builder.hpp b/include/sparrow/builder/builder.hpp
index ff306fa0..7a881a11 100644
--- a/include/sparrow/builder/builder.hpp
+++ b/include/sparrow/builder/builder.hpp
@@ -15,414 +15,421 @@
 
 #pragma once
 
-#include <vector>
-#include <string>
 #include <array>
-#include <tuple>
 #include <map>
-#include <type_traits>
 #include <ranges>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
-#include <sparrow/utils/ranges.hpp>
-#include <sparrow/layout/primitive_array.hpp>
-#include <sparrow/layout/list_layout/list_array.hpp>
-#include <sparrow/layout/struct_layout/struct_array.hpp>
-#include <sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp>
-#include <sparrow/layout/union_array.hpp>
-#include <sparrow/layout/dictionary_encoded_array.hpp>
 #include <sparrow/array.hpp>
 #include <sparrow/builder/builder_utils.hpp>
-#include <sparrow/builder/nested_less.hpp>
 #include <sparrow/builder/nested_eq.hpp>
+#include <sparrow/builder/nested_less.hpp>
+#include <sparrow/layout/dictionary_encoded_array.hpp>
+#include <sparrow/layout/list_layout/list_array.hpp>
+#include <sparrow/layout/primitive_array.hpp>
+#include <sparrow/layout/struct_layout/struct_array.hpp>
+#include <sparrow/layout/union_array.hpp>
+#include <sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp>
 #include <sparrow/utils/ranges.hpp>
-#include <tuple>
-#include <utility> 
 
 namespace sparrow
 {
 
-// forward declaration
-namespace detail
-{   
-    template<class T, class LAYOUT_POLICY, class OPTIONS_TYPE>
-    struct builder;
-}
-
-struct dense_union_flag_t{};
-struct sparse_union_flag_t{};
-struct large_list_flag_t{};
-struct large_binary_flag_t{};
-
-// option flag to indicate the desire for large lists
-inline constexpr large_list_flag_t large_list_flag;
-
-/**
- * @brief  function to create a sparrow array from arbitrary  nested
- * combinations of ranges, tuples, and nullable types, variants. 
- * Have a look at the  \ref builder "buider documentation" for more information.
- */
-template<class T, class ... OPTION_FLAGS>
-auto build(T&& t, OPTION_FLAGS&& ... )
-{
-    // for toplevel build calls, the layout policy is determined by the type itself
-    using decayed_t = std::decay_t<T>;
-    using layout_policy = detail::layout_flag_t<decayed_t>;
-    using option_flags_type = sparrow::mpl::typelist<std::decay_t<OPTION_FLAGS>...>;
-    
-    if constexpr(detail::is_express_layout_desire<decayed_t>)
-    {   
-        // directely unpack
-        using value_type = typename decayed_t::value_type;
-        return detail::builder<value_type, layout_policy, option_flags_type>::create(
-            std::forward<T>(t).get()
-        );
-    }
-    else if constexpr(detail::is_nullable_like<T>)
-    {
-        static_assert(mpl::dependent_false<T>::value, "toplevel type must not be nullable");
-    }
-    else
+    // forward declaration
+    namespace detail
     {
-        return detail::builder<T, layout_policy, option_flags_type>::create(std::forward<T>(t)); 
+        template <class T, class LAYOUT_POLICY, class OPTIONS_TYPE>
+        struct builder;
     }
-}
-
-template<class T, class ... OPTION_FLAGS>
-auto build(std::initializer_list<T> t, OPTION_FLAGS&& ... flags)
-{
-    auto subranges = std::views::all(t);
-    return build(std::forward<decltype(subranges)>(subranges), std::forward<OPTION_FLAGS>(flags)...);
-}
 
+    struct dense_union_flag_t
+    {
+    };
 
-namespace detail
-{
+    struct sparse_union_flag_t
+    {
+    };
 
-// this is called by the nested recursive calls
-template<class LAYOUT_POLICY, class T, class ... OPTION_FLAGS>
-auto build_impl(T&& t, [[maybe_unused]] sparrow::mpl::typelist<OPTION_FLAGS...> typelist)
-{
-    using option_flags_type = sparrow::mpl::typelist<OPTION_FLAGS...>;
-    return builder<T, LAYOUT_POLICY, option_flags_type>::create(std::forward<T>(t));
-}
-
-template <class T>
-concept translates_to_primitive_layout = 
-    std::ranges::input_range<T> &&
-    std::is_scalar_v<ensured_range_value_t<T>> 
-;
-
-template<class T> 
-concept translate_to_variable_sized_list_layout = 
-    std::ranges::input_range<T> &&     
-    std::ranges::input_range<ensured_range_value_t<T>> &&
-    !tuple_like<ensured_range_value_t<T>> && // tuples go to struct layout
-    // value type of inner should not be 'char-like'( char, byte, uint8), these are handled by variable_size_binary_array
-    !mpl::char_like<nested_ensured_range_inner_value_t<T>>
-;
-
-template<class T>
-concept translate_to_struct_layout = 
-    std::ranges::input_range<T> &&
-    tuple_like<ensured_range_value_t<T>> &&
-    !all_elements_same<ensured_range_value_t<T>>
-;
-
-template<class T>
-concept translate_to_fixed_sized_list_layout =
-    std::ranges::input_range<T> &&
-    tuple_like<ensured_range_value_t<T>> &&
-    all_elements_same<ensured_range_value_t<T>>
-;
-
-template<class T> 
-concept translate_to_variable_sized_binary_layout = 
-    std::ranges::input_range<T> &&  
-    std::ranges::input_range<ensured_range_value_t<T>> &&
-    !tuple_like<ensured_range_value_t<T>> && // tuples go to struct layout
-    // value type of inner must be char like ( char, byte, uint8)
-    mpl::char_like<nested_ensured_range_inner_value_t<T>>
-;
-
-template<class T> 
-concept translate_to_union_layout = 
-    std::ranges::input_range<T> &&
-    // value type must be a variant-like type
-    // *NOTE* we don't check for nullable here, as we want to handle nullable variants
-    // as in the arrow spec, the nulls are handled by the elements **in** the variant
-    variant_like<
-        std::ranges::range_value_t<T>
-    >
-;
-
-template< translates_to_primitive_layout T, class OPTION_FLAGS>
-struct builder<T, dont_enforce_layout, OPTION_FLAGS>
-{
-    using type = sparrow::primitive_array<ensured_range_value_t<T>>;
-    template<class U>
-    static type create(U&& t)
+    struct large_list_flag_t
     {
-        return type(std::forward<U>(t));
-    } 
-};
+    };
 
-template< translate_to_variable_sized_list_layout T, class OPTION_FLAGS>
-struct builder<T, dont_enforce_layout, OPTION_FLAGS>
-{
-    using raw_value_type = std::ranges::range_value_t<T>;
+    struct large_binary_flag_t
+    {
+    };
+
+    // option flag to indicate the desire for large lists
+    inline constexpr large_list_flag_t large_list_flag;
+
+    /**
+     * @brief  function to create a sparrow array from arbitrary  nested
+     * combinations of ranges, tuples, and nullable types, variants.
+     * Have a look at the  \ref builder "buider documentation" for more information.
+     */
+    template <class T, class... OPTION_FLAGS>
+    auto build(T&& t, OPTION_FLAGS&&...)
+    {
+        // for toplevel build calls, the layout policy is determined by the type itself
+        using decayed_t = std::decay_t<T>;
+        using layout_policy = detail::layout_flag_t<decayed_t>;
+        using option_flags_type = sparrow::mpl::typelist<std::decay_t<OPTION_FLAGS>...>;
 
-    using type = std::conditional_t<
-        mpl::contains<large_list_flag_t>(OPTION_FLAGS{}),
-        sparrow::big_list_array,
-        sparrow::list_array
-    >;
+        if constexpr (detail::is_express_layout_desire<decayed_t>)
+        {
+            // directely unpack
+            using value_type = typename decayed_t::value_type;
+            return detail::builder<value_type, layout_policy, option_flags_type>::create(
+                std::forward<T>(t).get()
+            );
+        }
+        else if constexpr (detail::is_nullable_like<T>)
+        {
+            static_assert(mpl::dependent_false<T>::value, "toplevel type must not be nullable");
+        }
+        else
+        {
+            return detail::builder<T, layout_policy, option_flags_type>::create(std::forward<T>(t));
+        }
+    }
 
-    template<class U>
-    static type create(U && t)
+    template <class T, class... OPTION_FLAGS>
+    auto build(std::initializer_list<T> t, OPTION_FLAGS&&... flags)
     {
-        auto flat_list_view = std::ranges::views::join(ensure_value_range(t));
-        
-        auto sizes = t | std::views::transform([](const auto& l){ 
-            return get_size_save(l);
-        });
-
-        // when the raw_value_type is a "express layout desire" we need to
-        // propagate this information to the builder, so it can handle the
-        using layout_policy_type = layout_flag_t<raw_value_type>;
-        auto typed_array = build_impl<layout_policy_type>(flat_list_view, OPTION_FLAGS{});
-        auto detyped_array = array(std::move(typed_array));
- 
-        return type(
-            std::move(detyped_array),
-            type::offset_from_sizes(sizes),
-            where_null(t)
-        );
+        auto subranges = std::views::all(t);
+        return build(std::forward<decltype(subranges)>(subranges), std::forward<OPTION_FLAGS>(flags)...);
     }
-};
-
-template< translate_to_fixed_sized_list_layout T, class OPTION_FLAGS>
-struct builder<T, dont_enforce_layout, OPTION_FLAGS>
-{
-    using type = sparrow::fixed_sized_list_array;
-    constexpr static std::size_t list_size = std::tuple_size_v<look_trough_t<std::ranges::range_value_t<T>>>;
-    using raw_value_type = std::ranges::range_value_t<T>;
 
-    template<class U>
-    static type create(U && t)
+    namespace detail
     {
-        auto flat_list_view = std::ranges::views::join(ensure_value_range(t));
 
-        // when the raw_value_type is a "express layout desire" we need to
-        // propagate this information to the builder.
-        using layout_policy_type = layout_flag_t<raw_value_type>;
+        // this is called by the nested recursive calls
+        template <class LAYOUT_POLICY, class T, class... OPTION_FLAGS>
+        auto build_impl(T&& t, [[maybe_unused]] sparrow::mpl::typelist<OPTION_FLAGS...> typelist)
+        {
+            using option_flags_type = sparrow::mpl::typelist<OPTION_FLAGS...>;
+            return builder<T, LAYOUT_POLICY, option_flags_type>::create(std::forward<T>(t));
+        }
+
+        template <class T>
+        concept translates_to_primitive_layout = std::ranges::input_range<T>
+                                                 && std::is_scalar_v<ensured_range_value_t<T>>;
+
+        template <class T>
+        concept translate_to_variable_sized_list_layout = std::ranges::input_range<T>
+                                                          && std::ranges::input_range<ensured_range_value_t<T>>
+                                                          && !tuple_like<ensured_range_value_t<T>>
+                                                          &&  // tuples go to struct layout
+                                                          // value type of inner should not be 'char-like'(
+                                                          // char, byte, uint8), these are handled by
+                                                          // variable_size_binary_array
+                                                          !mpl::char_like<nested_ensured_range_inner_value_t<T>>;
+
+        template <class T>
+        concept translate_to_struct_layout = std::ranges::input_range<T> && tuple_like<ensured_range_value_t<T>>
+                                             && !all_elements_same<ensured_range_value_t<T>>;
+
+        template <class T>
+        concept translate_to_fixed_sized_list_layout = std::ranges::input_range<T>
+                                                       && tuple_like<ensured_range_value_t<T>>
+                                                       && all_elements_same<ensured_range_value_t<T>>;
+
+        template <class T>
+        concept translate_to_variable_sized_binary_layout = std::ranges::input_range<T>
+                                                            && std::ranges::input_range<ensured_range_value_t<T>>
+                                                            && !tuple_like<ensured_range_value_t<T>>
+                                                            &&  // tuples go to struct layout
+                                                            // value type of inner must be char like ( char,
+                                                            // byte, uint8)
+                                                            mpl::char_like<nested_ensured_range_inner_value_t<T>>;
+
+        template <class T>
+        concept translate_to_union_layout = std::ranges::input_range<T> &&
+                                            // value type must be a variant-like type
+                                            // *NOTE* we don't check for nullable here, as we want to handle
+                                            // nullable variants as in the arrow spec, the nulls are handled
+                                            // by the elements **in** the variant
+                                            variant_like<std::ranges::range_value_t<T>>;
+
+        template <translates_to_primitive_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::primitive_array<ensured_range_value_t<T>>;
 
-        return type(
-            static_cast<std::uint64_t>(list_size), 
-            array(build_impl<layout_policy_type>(flat_list_view, OPTION_FLAGS{})),
-            where_null(t)
-        );
-    }
-};
+            template <class U>
+            static type create(U&& t)
+            {
+                return type(std::forward<U>(t));
+            }
+        };
 
-template< translate_to_struct_layout T, class OPTION_FLAGS>
-struct builder<T, dont_enforce_layout, OPTION_FLAGS>{
-    using type = sparrow::struct_array;
-    static constexpr std::size_t n_children = std::tuple_size_v<mnv_t<std::ranges::range_value_t<T>>>;
-    using tuple_type = ensured_range_value_t<T>;
+        template <translate_to_variable_sized_list_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using raw_value_type = std::ranges::range_value_t<T>;
 
-    template<class U>
-    static type create(U&& t) 
-    {
-        std::vector<array> detyped_children(n_children);
-        for_each_index<n_children>([&](auto i)
-        {   
-            auto tuple_i_col = t | std::views::transform([](const auto& maybe_nullable_tuple)
+            using type = std::conditional_t<
+                mpl::contains<large_list_flag_t>(OPTION_FLAGS{}),
+                sparrow::big_list_array,
+                sparrow::list_array>;
+
+            template <class U>
+            static type create(U&& t)
             {
-                const auto & tuple_val = ensure_value(maybe_nullable_tuple);
-                return std::get<decltype(i)::value>(tuple_val);
-            }); 
-
-            using tuple_element_type = std::tuple_element_t<decltype(i)::value, tuple_type>;
-            using layout_policy_type = layout_flag_t<tuple_element_type>;
-            detyped_children[decltype(i)::value] = array(build_impl<layout_policy_type>(tuple_i_col, OPTION_FLAGS{}));
-        });
-
-        return type(
-            std::move(detyped_children),
-            where_null(t)
-       );
-    }
-};
+                auto flat_list_view = std::ranges::views::join(ensure_value_range(t));
+
+                auto sizes = t
+                             | std::views::transform(
+                                 [](const auto& l)
+                                 {
+                                     return get_size_save(l);
+                                 }
+                             );
+
+                // when the raw_value_type is a "express layout desire" we need to
+                // propagate this information to the builder, so it can handle the
+                using layout_policy_type = layout_flag_t<raw_value_type>;
+                auto typed_array = build_impl<layout_policy_type>(flat_list_view, OPTION_FLAGS{});
+                auto detyped_array = array(std::move(typed_array));
+
+                return type(std::move(detyped_array), type::offset_from_sizes(sizes), where_null(t));
+            }
+        };
 
-template< translate_to_variable_sized_binary_layout T, class OPTION_FLAGS>
-struct builder<T, dont_enforce_layout, OPTION_FLAGS>
-{
-    using type = sparrow::string_array;
+        template <translate_to_fixed_sized_list_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::fixed_sized_list_array;
+            static constexpr std::size_t
+                list_size = std::tuple_size_v<look_trough_t<std::ranges::range_value_t<T>>>;
+            using raw_value_type = std::ranges::range_value_t<T>;
 
-    template<class U>
-    static type create(U && t)
-    {
-        auto flat_list_view = std::ranges::views::join(ensure_value_range(t));
-        u8_buffer<char> data_buffer(flat_list_view);
-
-        auto sizes = t | std::views::transform([](const auto& l){ 
-            return get_size_save(l);
-        });
- 
-        return type(
-            std::move(data_buffer),
-            type::offset_from_sizes(sizes),
-            where_null(t)
-        );
-    }
-};
+            template <class U>
+            static type create(U&& t)
+            {
+                auto flat_list_view = std::ranges::views::join(ensure_value_range(t));
 
-template< translate_to_union_layout T, class OPTION_FLAGS>
-struct builder<T, dont_enforce_layout, OPTION_FLAGS>
-{
-    using type = sparrow::sparse_union_array; // TODO use options to select between sparse and dense
-    using variant_type = std::ranges::range_value_t<T>;
-    static constexpr std::size_t variant_size = std::variant_size_v<variant_type>;
+                // when the raw_value_type is a "express layout desire" we need to
+                // propagate this information to the builder.
+                using layout_policy_type = layout_flag_t<raw_value_type>;
 
+                return type(
+                    static_cast<std::uint64_t>(list_size),
+                    array(build_impl<layout_policy_type>(flat_list_view, OPTION_FLAGS{})),
+                    where_null(t)
+                );
+            }
+        };
 
-    template<class U>
-    static type create(U && t) requires(std::is_same_v<type, sparrow::sparse_union_array>)
-    {
-        std::vector<array> detyped_children(variant_size);
-        for_each_index<variant_size>([&](auto i)
+        template <translate_to_struct_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
         {
-            using type_at_index = std::variant_alternative_t<decltype(i)::value, variant_type>;
-            auto type_i_col = t | std::views::transform([](const auto& variant)
-            {   
-                return variant.index() == decltype(i)::value ? 
-                    std::get<type_at_index>(variant) : type_at_index{};
-            });
-
-            using layout_policy_type = layout_flag_t<type_at_index>;
-            detyped_children[decltype(i)::value] = array(build_impl<layout_policy_type>(type_i_col,  OPTION_FLAGS{}));
-        });
-
-        // type-ids
-        auto type_id_range = t | std::views::transform([](const auto& v){
-            return static_cast<std::uint8_t>(v.index());
-        });
-        sparrow::u8_buffer<std::uint8_t> type_id_buffer(type_id_range);
-
-        return type(
-            std::move(detyped_children),
-            std::move(type_id_buffer)
-        );
-    }
-};
+            using type = sparrow::struct_array;
+            static constexpr std::size_t n_children = std::tuple_size_v<mnv_t<std::ranges::range_value_t<T>>>;
+            using tuple_type = ensured_range_value_t<T>;
 
-template< class T, class OPTION_FLAGS>
-struct builder<T, enforce_dict_encoded_layout,OPTION_FLAGS>
-{
-    using key_type = std::uint64_t;
-    using type = sparrow::dictionary_encoded_array<key_type>;
-    // keep the nulls
-    using raw_range_value_type = std::ranges::range_value_t<T>;
-
-    template<class U>
-    static type create(U && t)
-    {   
-        const auto input_size = range_size(t);
-        key_type key = 0;
-        std::map<raw_range_value_type, key_type, nested_less<raw_range_value_type>> value_map;
-        std::vector<raw_range_value_type> values;
-        std::vector<key_type> keys;
-
-        values.reserve(input_size);
-        keys.reserve(input_size);
-
-        for(const auto& v : t)
-        {
-            auto find_res = value_map.find(v);
-            if(find_res == value_map.end())
+            template <class U>
+            static type create(U&& t)
             {
-                value_map.insert({v, key});
-                values.push_back(v);
-                keys.push_back(key);
-                ++key;
+                std::vector<array> detyped_children(n_children);
+                for_each_index<n_children>(
+                    [&](auto i)
+                    {
+                        auto tuple_i_col = t
+                                           | std::views::transform(
+                                               [](const auto& maybe_nullable_tuple)
+                                               {
+                                                   const auto& tuple_val = ensure_value(maybe_nullable_tuple);
+                                                   return std::get<decltype(i)::value>(tuple_val);
+                                               }
+                                           );
+
+                        using tuple_element_type = std::tuple_element_t<decltype(i)::value, tuple_type>;
+                        using layout_policy_type = layout_flag_t<tuple_element_type>;
+                        detyped_children[decltype(i)::value] = array(
+                            build_impl<layout_policy_type>(tuple_i_col, OPTION_FLAGS{})
+                        );
+                    }
+                );
+
+                return type(std::move(detyped_children), where_null(t));
             }
-            else
+        };
+
+        template <translate_to_variable_sized_binary_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::string_array;
+
+            template <class U>
+            static type create(U&& t)
             {
-                keys.push_back(find_res->second);
+                auto flat_list_view = std::ranges::views::join(ensure_value_range(t));
+                u8_buffer<char> data_buffer(flat_list_view);
+
+                auto sizes = t
+                             | std::views::transform(
+                                 [](const auto& l)
+                                 {
+                                     return get_size_save(l);
+                                 }
+                             );
+
+                return type(std::move(data_buffer), type::offset_from_sizes(sizes), where_null(t));
             }
-            
-        }
-        auto keys_buffer = sparrow::u8_buffer<key_type>(keys);
+        };
 
-        // since we do not support dict[dict or dict[run_end 
-        // we can hard code the layout policy here
-        using layout_policy_type = dont_enforce_layout;
-
-        auto values_array = build_impl<layout_policy_type>(values, OPTION_FLAGS{});
+        template <translate_to_union_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::sparse_union_array;  // TODO use options to select between sparse and dense
+            using variant_type = std::ranges::range_value_t<T>;
+            static constexpr std::size_t variant_size = std::variant_size_v<variant_type>;
 
-        return type(
-            std::move(keys_buffer),
-            array(std::move(values_array))
-        );
-    }
-};
+            template <class U>
+            static type create(U&& t)
+                requires(std::is_same_v<type, sparrow::sparse_union_array>)
+            {
+                std::vector<array> detyped_children(variant_size);
+                for_each_index<variant_size>(
+                    [&](auto i)
+                    {
+                        using type_at_index = std::variant_alternative_t<decltype(i)::value, variant_type>;
+                        auto type_i_col = t
+                                          | std::views::transform(
+                                              [](const auto& variant)
+                                              {
+                                                  return variant.index() == decltype(i)::value
+                                                             ? std::get<type_at_index>(variant)
+                                                             : type_at_index{};
+                                              }
+                                          );
+
+                        using layout_policy_type = layout_flag_t<type_at_index>;
+                        detyped_children[decltype(i)::value] = array(
+                            build_impl<layout_policy_type>(type_i_col, OPTION_FLAGS{})
+                        );
+                    }
+                );
+
+                // type-ids
+                auto type_id_range = t
+                                     | std::views::transform(
+                                         [](const auto& v)
+                                         {
+                                             return static_cast<std::uint8_t>(v.index());
+                                         }
+                                     );
+                sparrow::u8_buffer<std::uint8_t> type_id_buffer(type_id_range);
+
+                return type(std::move(detyped_children), std::move(type_id_buffer));
+            }
+        };
 
-template< class T, class OPTION_FLAGS>
-struct builder<T, enforce_run_end_encoded_layout, OPTION_FLAGS>
-{
-    using type = sparrow::run_end_encoded_array;
-    using raw_range_value_type = std::ranges::range_value_t<T>;
+        template <class T, class OPTION_FLAGS>
+        struct builder<T, enforce_dict_encoded_layout, OPTION_FLAGS>
+        {
+            using key_type = std::uint64_t;
+            using type = sparrow::dictionary_encoded_array<key_type>;
+            // keep the nulls
+            using raw_range_value_type = std::ranges::range_value_t<T>;
 
-    template<class U>
-    static type create(U && t)
-    {   
-        using value_type = std::decay_t<raw_range_value_type>;
+            template <class U>
+            static type create(U&& t)
+            {
+                const auto input_size = range_size(t);
+                key_type key = 0;
+                std::map<raw_range_value_type, key_type, nested_less<raw_range_value_type>> value_map;
+                std::vector<raw_range_value_type> values;
+                std::vector<key_type> keys;
 
-        const auto input_size = range_size(t);
+                values.reserve(input_size);
+                keys.reserve(input_size);
 
-        std::vector<value_type> values{};
-        std::vector<std::size_t> acc_run_lengths{};
+                for (const auto& v : t)
+                {
+                    auto find_res = value_map.find(v);
+                    if (find_res == value_map.end())
+                    {
+                        value_map.insert({v, key});
+                        values.push_back(v);
+                        keys.push_back(key);
+                        ++key;
+                    }
+                    else
+                    {
+                        keys.push_back(find_res->second);
+                    }
+                }
+                auto keys_buffer = sparrow::u8_buffer<key_type>(keys);
 
-        values.reserve(input_size);
-        acc_run_lengths.reserve(input_size);
+                // since we do not support dict[dict or dict[run_end
+                // we can hard code the layout policy here
+                using layout_policy_type = dont_enforce_layout;
 
-        const auto eq = nested_eq<value_type>{};
+                auto values_array = build_impl<layout_policy_type>(values, OPTION_FLAGS{});
 
-        // accumulate the run lengths
-        std::size_t i = 0;
-        for(const auto& v : t)
-        {   
-            // first value
-            if(i == 0)
-            {
-                values.push_back(v);
+                return type(std::move(keys_buffer), array(std::move(values_array)));
             }
-            // rest
-            else
+        };
+
+        template <class T, class OPTION_FLAGS>
+        struct builder<T, enforce_run_end_encoded_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::run_end_encoded_array;
+            using raw_range_value_type = std::ranges::range_value_t<T>;
+
+            template <class U>
+            static type create(U&& t)
             {
-                if(!eq(values.back(), v))
+                using value_type = std::decay_t<raw_range_value_type>;
+
+                const auto input_size = range_size(t);
+
+                std::vector<value_type> values{};
+                std::vector<std::size_t> acc_run_lengths{};
+
+                values.reserve(input_size);
+                acc_run_lengths.reserve(input_size);
+
+                const auto eq = nested_eq<value_type>{};
+
+                // accumulate the run lengths
+                std::size_t i = 0;
+                for (const auto& v : t)
                 {
-                    acc_run_lengths.push_back(i);
-                    values.push_back(v);
+                    // first value
+                    if (i == 0)
+                    {
+                        values.push_back(v);
+                    }
+                    // rest
+                    else
+                    {
+                        if (!eq(values.back(), v))
+                        {
+                            acc_run_lengths.push_back(i);
+                            values.push_back(v);
+                        }
+                    }
+                    ++i;
                 }
+                acc_run_lengths.push_back(i);
+
+                auto run_length_typed_array = primitive_array<std::size_t>(acc_run_lengths);
+
+                // since we do not support dict[dict or dict[run_end
+                // we can hard code the layout policy here
+                using layout_policy_type = dont_enforce_layout;
+                auto values_array = build_impl<layout_policy_type>(values, OPTION_FLAGS{});
+
+                return type(array(std::move(run_length_typed_array)), array(std::move(values_array)));
             }
-            ++i;
-        }
-        acc_run_lengths.push_back(i);
-    
-        auto run_length_typed_array = primitive_array<std::size_t>(acc_run_lengths);
-
-        // since we do not support dict[dict or dict[run_end
-        // we can hard code the layout policy here
-        using layout_policy_type = dont_enforce_layout;
-        auto values_array = build_impl<layout_policy_type>(values, OPTION_FLAGS{});
-
-        return type(
-            array(std::move(run_length_typed_array)),
-            array(std::move(values_array))
-        );
-    }
-};
+        };
 
 
-} // namespace detail
-}// namespace sparrow
+    }  // namespace detail
+}  // namespace sparrow
diff --git a/include/sparrow/builder/builder_utils.hpp b/include/sparrow/builder/builder_utils.hpp
index 0fd7c58b..ee659710 100644
--- a/include/sparrow/builder/builder_utils.hpp
+++ b/include/sparrow/builder/builder_utils.hpp
@@ -15,352 +15,355 @@
 
 #pragma once
 
-#include <vector>
-#include <string>
 #include <array>
+#include <ranges>
+#include <string>
 #include <tuple>
 #include <type_traits>
-#include <ranges>
+#include <utility>
+#include <vector>
 
 #include <sparrow/array.hpp>
 #include <sparrow/utils/ranges.hpp>
-#include <tuple>
-#include <utility> 
- 
+
 namespace sparrow
 {
 
-namespace detail
-{
-    template<class T>
-    class express_layout_desire
+    namespace detail
     {
-    public:
-        using self_type = express_layout_desire<T>;
-        using value_type = T;
-
-        // default constructor
-        express_layout_desire() = default;
-
-        // variadic perfect forwarding constructor
-        template<class... Args>
-        express_layout_desire(Args&& ... args)
-            : m_value(std::forward<Args>(args)...)
+        template <class T>
+        class express_layout_desire
         {
-        }
+        public:
 
-        const T& get() const
-        {
-            return m_value;
-        }
-        T& get()
-        {
-            return m_value;
-        }
-    private:
-        T m_value = T{};
-    };
-}
+            using self_type = express_layout_desire<T>;
+            using value_type = T;
 
+            // default constructor
+            express_layout_desire() = default;
 
-// express the desire to use a dictionary encoding layout for
-// whatever is inside. Note that what is inside **is not yet**
-// encoded. This is done once the complete data which is to be 
-// dict encoded is known
-template<class T, class KEY_TYPE = std::uint64_t>
-class dict_encode : public detail::express_layout_desire<T>
-{
-    using base_type = detail::express_layout_desire<T>;
-public:
-    using base_type::base_type;
-    using key_type = KEY_TYPE;
-};
-
-// express the desire to use a run-length encoding layout for
-// whatever is inside. Note that what is inside **is not yet**
-// encoded. This is done once the complete data which is to be 
-// dict encoded is known
-template<class T, class LENGTH_TYPE = std::uint64_t>
-class run_end_encode : public detail::express_layout_desire<T>
-{
-    using base_type = detail::express_layout_desire<T>;
-public:
-    using base_type::base_type;
-    using length_type = LENGTH_TYPE;
-};
+            // variadic perfect forwarding constructor
+            template <class... Args>
+            express_layout_desire(Args&&... args)
+                : m_value(std::forward<Args>(args)...)
+            {
+            }
 
-namespace detail
-{
-    // might be changed later to also allowm for std::optional
-    template<class T>
-    concept is_nullable_like = sparrow::is_nullable_v<T>;
+            const T& get() const
+            {
+                return m_value;
+            }
 
-    struct dont_enforce_layout{};
-    struct enforce_dict_encoded_layout{};
-    struct enforce_run_end_encoded_layout{};
+            T& get()
+            {
+                return m_value;
+            }
 
-    template<class T>
-    concept is_dict_encode = sparrow::mpl::is_type_instance_of_v<T, dict_encode>;
+        private:
 
-    template<class T>
-    concept is_run_end_encode = sparrow::mpl::is_type_instance_of_v<T, run_end_encode>;
+            T m_value = T{};
+        };
+    }
 
-    template<class T>
-    concept is_express_layout_desire = is_dict_encode<T> || is_run_end_encode<T>;
+    // express the desire to use a dictionary encoding layout for
+    // whatever is inside. Note that what is inside **is not yet**
+    // encoded. This is done once the complete data which is to be
+    // dict encoded is known
+    template <class T, class KEY_TYPE = std::uint64_t>
+    class dict_encode : public detail::express_layout_desire<T>
+    {
+        using base_type = detail::express_layout_desire<T>;
 
-    
-    template<class T>
-    concept is_plain_value_type = !is_express_layout_desire<T> && !is_nullable_like<T>;
+    public:
 
-    template<class T>
-    using decayed_range_value_t = std::decay_t<std::ranges::range_value_t<T>>;
+        using base_type::base_type;
+        using key_type = KEY_TYPE;
+    };
 
-    template <class F, std::size_t... Is>
-    void for_each_index_impl(F&& f, std::index_sequence<Is...>)
-    {   
-        // Apply f to each index individually
-        (f(std::integral_constant<std::size_t, Is>{}), ...);
-    }
-    template <std::size_t SIZE, class F>
-    void for_each_index(F&& f)
+    // express the desire to use a run-length encoding layout for
+    // whatever is inside. Note that what is inside **is not yet**
+    // encoded. This is done once the complete data which is to be
+    // dict encoded is known
+    template <class T, class LENGTH_TYPE = std::uint64_t>
+    class run_end_encode : public detail::express_layout_desire<T>
     {
-        for_each_index_impl(std::forward<F>(f), std::make_index_sequence<SIZE>());
-    }
+        using base_type = detail::express_layout_desire<T>;
+
+    public:
 
-    template <class F, std::size_t... Is>
-    bool exitable_for_each_index_impl(F&& f, std::index_sequence<Is...>)
+        using base_type::base_type;
+        using length_type = LENGTH_TYPE;
+    };
+
+    namespace detail
     {
-        return (f(std::integral_constant<std::size_t, Is>{}) && ...);
-    }
+        // might be changed later to also allowm for std::optional
+        template <class T>
+        concept is_nullable_like = sparrow::is_nullable_v<T>;
 
-    template <std::size_t SIZE, class F>
-    bool exitable_for_each_index(F&& f)
-    {   
-        return exitable_for_each_index_impl(std::forward<F>(f), std::make_index_sequence<SIZE>());
-    }
+        struct dont_enforce_layout
+        {
+        };
 
+        struct enforce_dict_encoded_layout
+        {
+        };
 
-    template<class T, std::size_t N>
-    concept has_tuple_element =
-    requires(T t) {
-        typename std::tuple_element_t<N, std::remove_const_t<T>>;
-        { get<N>(t) } -> std::convertible_to<const std::tuple_element_t<N, T>&>;
-    };
+        struct enforce_run_end_encoded_layout
+        {
+        };
 
+        template <class T>
+        concept is_dict_encode = sparrow::mpl::is_type_instance_of_v<T, dict_encode>;
 
+        template <class T>
+        concept is_run_end_encode = sparrow::mpl::is_type_instance_of_v<T, run_end_encode>;
 
-    template <typename T, std::size_t... N>
-    constexpr bool check_tuple_elements(std::index_sequence<N...>) {
-        return (has_tuple_element<T, N> && ...);
-    }
+        template <class T>
+        concept is_express_layout_desire = is_dict_encode<T> || is_run_end_encode<T>;
 
-    template <typename T>
-    constexpr bool is_tuple_like() {
-        return check_tuple_elements<T>(std::make_index_sequence<std::tuple_size_v<T>>());
-    }
 
+        template <class T>
+        concept is_plain_value_type = !is_express_layout_desire<T> && !is_nullable_like<T>;
 
-    template <typename T>
-    concept variant_like = 
-        // Must not be a reference
-        !std::is_reference_v<T> && 
+        template <class T>
+        using decayed_range_value_t = std::decay_t<std::ranges::range_value_t<T>>;
 
-        // Must have an index() member function returning a size_t
-        requires(const T& v) {
-            { v.index() } -> std::convertible_to<std::size_t>;
-        } &&
+        template <class F, std::size_t... Is>
+        void for_each_index_impl(F&& f, std::index_sequence<Is...>)
+        {
+            // Apply f to each index individually
+            (f(std::integral_constant<std::size_t, Is>{}), ...);
+        }
 
-        // Must work with std::visit
-        requires(T v) {
-            std::visit([](auto&&) {}, v); // Use a generic lambda to test visitation
-        } &&
+        template <std::size_t SIZE, class F>
+        void for_each_index(F&& f)
+        {
+            for_each_index_impl(std::forward<F>(f), std::make_index_sequence<SIZE>());
+        }
 
-        // Must allow std::get with an index
-        requires(T v) {
-            { std::get<0>(v) }; // Access by index
-        } &&
+        template <class F, std::size_t... Is>
+        bool exitable_for_each_index_impl(F&& f, std::index_sequence<Is...>)
+        {
+            return (f(std::integral_constant<std::size_t, Is>{}) && ...);
+        }
 
-        // Must allow std::get with a type
-        requires(T v) {
-            { std::get<typename std::variant_alternative<0, T>::type>(v) }; // Access by type
+        template <std::size_t SIZE, class F>
+        bool exitable_for_each_index(F&& f)
+        {
+            return exitable_for_each_index_impl(std::forward<F>(f), std::make_index_sequence<SIZE>());
         }
-    ;
 
-    template <typename T>
-    concept tuple_like = !std::is_reference_v<T>
-        && requires(T t) {
-            typename std::tuple_size<T>::type;
-            requires std::derived_from<std::tuple_size<T>, std::integral_constant<std::size_t, std::tuple_size_v<T>>>;
+
+        template <class T, std::size_t N>
+        concept has_tuple_element = requires(T t) {
+            typename std::tuple_element_t<N, std::remove_const_t<T>>;
+            { get<N>(t) } -> std::convertible_to<const std::tuple_element_t<N, T>&>;
+        };
+
+        template <typename T, std::size_t... N>
+        constexpr bool check_tuple_elements(std::index_sequence<N...>)
+        {
+            return (has_tuple_element<T, N> && ...);
         }
-        && is_tuple_like<T>();
 
+        template <typename T>
+        constexpr bool is_tuple_like()
+        {
+            return check_tuple_elements<T>(std::make_index_sequence<std::tuple_size_v<T>>());
+        }
 
-    template <typename Tuple, size_t... Is>
-    constexpr bool all_elements_same_impl(std::index_sequence<Is...>) {
-        return sizeof...(Is) == 0 || ((std::is_same_v<
-            std::tuple_element_t<0, Tuple>, 
-            std::tuple_element_t<Is, Tuple>
-        >) && ...);
-    }
+        template <typename T>
+        concept variant_like =
+            // Must not be a reference
+            !std::is_reference_v<T> &&
+
+            // Must have an index() member function returning a size_t
+            requires(const T& v) {
+                { v.index() } -> std::convertible_to<std::size_t>;
+            } &&
+
+            // Must work with std::visit
+            requires(T v) {
+                std::visit([](auto&&) {}, v);  // Use a generic lambda to test visitation
+            } &&
+
+            // Must allow std::get with an index
+            requires(T v) {
+                { std::get<0>(v) };  // Access by index
+            } &&
+
+            // Must allow std::get with a type
+            requires(T v) {
+                { std::get<typename std::variant_alternative<0, T>::type>(v) };  // Access by type
+            };
+
+        template <typename T>
+        concept tuple_like = !std::is_reference_v<T> && requires(T t) {
+            typename std::tuple_size<T>::type;
+            requires std::derived_from<std::tuple_size<T>, std::integral_constant<std::size_t, std::tuple_size_v<T>>>;
+        } && is_tuple_like<T>();
 
-    template <typename T>
-    concept all_elements_same = tuple_like<T> && 
-        all_elements_same_impl<T>(
-            std::make_index_sequence<std::tuple_size_v<T>>{}
-        );
+        template <typename Tuple, size_t... Is>
+        constexpr bool all_elements_same_impl(std::index_sequence<Is...>)
+        {
+            return sizeof...(Is) == 0
+                   || ((std::is_same_v<std::tuple_element_t<0, Tuple>, std::tuple_element_t<Is, Tuple>>) && ...);
+        }
 
+        template <typename T>
+        concept all_elements_same = tuple_like<T>
+                                    && all_elements_same_impl<T>(std::make_index_sequence<std::tuple_size_v<T>>{
+                                    });
 
-    template<class T>
-    struct maybe_nullable_value_type
-    {
-        using type = T;
-    }; 
+        template <class T>
+        struct maybe_nullable_value_type
+        {
+            using type = T;
+        };
 
-    template<is_nullable_like T>
-    struct maybe_nullable_value_type<T>
-    {
-        using type = typename T::value_type;
-    };
+        template <is_nullable_like T>
+        struct maybe_nullable_value_type<T>
+        {
+            using type = typename T::value_type;
+        };
 
-    // shorthand for maybe_nullable_value_type<T>::type
-    template<class T>
-    using mnv_t = typename maybe_nullable_value_type<T>::type;
+        // shorthand for maybe_nullable_value_type<T>::type
+        template <class T>
+        using mnv_t = typename maybe_nullable_value_type<T>::type;
 
-    template<class T>
-    struct maybe_express_layout_desire_value_type
-    {
-        using type = T;
-    };
+        template <class T>
+        struct maybe_express_layout_desire_value_type
+        {
+            using type = T;
+        };
 
-    template<is_express_layout_desire T>
-    struct maybe_express_layout_desire_value_type<T>
-    {
-        using type = typename T::value_type;
-    };
-    // shorthand for maybe_express_layout_desire_value_type<T>::type
-    template<class T>
-    using meldv_t = typename maybe_express_layout_desire_value_type<T>::type;  
-
-
-    template<class T>
-    using layout_flag_t = std::conditional_t<
-        is_dict_encode<mnv_t<T>>, 
-        enforce_dict_encoded_layout,
-        std::conditional_t<
-            is_run_end_encode<mnv_t<T>>,
-            enforce_run_end_encoded_layout,
-            dont_enforce_layout
-        >
-    >;
-
-    template<class T>
-    using look_trough_t = meldv_t<mnv_t<meldv_t<T>>>;
-
-    // shorhand for look_trough_t<std::ranges::range_value_t<T>>
-    template<class T>
-    using ensured_range_value_t = look_trough_t<std::ranges::range_value_t<T>>;
-
-    // helper to get inner value type of smth like a vector of vector of T
-    // we also translate any nullable to the inner type
-    template<class T>
-    using nested_ensured_range_inner_value_t = ensured_range_value_t<ensured_range_value_t<T>>;
-
-    // a save way to return .size from
-    // a possibly nullable object or "express layout desire object"
-    template<class T>
-    std::size_t get_size_save(T&& t)
-    {
-        using decayed = std::decay_t<T>;
-        if constexpr(is_nullable_like<decayed>)
+        template <is_express_layout_desire T>
+        struct maybe_express_layout_desire_value_type<T>
+        {
+            using type = typename T::value_type;
+        };
+        // shorthand for maybe_express_layout_desire_value_type<T>::type
+        template <class T>
+        using meldv_t = typename maybe_express_layout_desire_value_type<T>::type;
+
+
+        template <class T>
+        using layout_flag_t = std::conditional_t<
+            is_dict_encode<mnv_t<T>>,
+            enforce_dict_encoded_layout,
+            std::conditional_t<is_run_end_encode<mnv_t<T>>, enforce_run_end_encoded_layout, dont_enforce_layout>>;
+
+        template <class T>
+        using look_trough_t = meldv_t<mnv_t<meldv_t<T>>>;
+
+        // shorhand for look_trough_t<std::ranges::range_value_t<T>>
+        template <class T>
+        using ensured_range_value_t = look_trough_t<std::ranges::range_value_t<T>>;
+
+        // helper to get inner value type of smth like a vector of vector of T
+        // we also translate any nullable to the inner type
+        template <class T>
+        using nested_ensured_range_inner_value_t = ensured_range_value_t<ensured_range_value_t<T>>;
+
+        // a save way to return .size from
+        // a possibly nullable object or "express layout desire object"
+        template <class T>
+        std::size_t get_size_save(T&& t)
         {
-            if (t.has_value())
+            using decayed = std::decay_t<T>;
+            if constexpr (is_nullable_like<decayed>)
+            {
+                if (t.has_value())
+                {
+                    return get_size_save(t.get());
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            else if constexpr (is_express_layout_desire<decayed>)
             {
                 return get_size_save(t.get());
             }
             else
             {
-                return 0;
+                return static_cast<std::size_t>(t.size());
             }
         }
-        else if constexpr(is_express_layout_desire<decayed>)
-        {
-            return get_size_save(t.get());
-        }
-        else
-        {
-            return static_cast<std::size_t>(t.size());
-        }
-    }
 
-    template<class T>
-    decltype(auto) ensure_value(T && t)
-    {
-        using decayed = std::decay_t<T>;
-        if constexpr(is_nullable_like<decayed> || is_express_layout_desire<decayed>)
+        template <class T>
+        decltype(auto) ensure_value(T&& t)
         {
-            return ensure_value(std::forward<T>(t).get());
-        }
-        else{
-            return std::forward<T>(t);
+            using decayed = std::decay_t<T>;
+            if constexpr (is_nullable_like<decayed> || is_express_layout_desire<decayed>)
+            {
+                return ensure_value(std::forward<T>(t).get());
+            }
+            else
+            {
+                return std::forward<T>(t);
+            }
         }
-    }
 
-    template<std::ranges::range T>
-    requires(is_nullable_like< std::ranges::range_value_t<T>>)
-    std::vector<std::size_t> where_null(T && t)
-    {
-        std::vector<std::size_t> result;
-        for (std::size_t i = 0; i < t.size(); ++i)
+        template <std::ranges::range T>
+            requires(is_nullable_like<std::ranges::range_value_t<T>>)
+        std::vector<std::size_t> where_null(T&& t)
         {
-            if (!t[i].has_value())
+            std::vector<std::size_t> result;
+            for (std::size_t i = 0; i < t.size(); ++i)
             {
-                result.push_back(i);
+                if (!t[i].has_value())
+                {
+                    result.push_back(i);
+                }
             }
+            return result;
         }
-        return result;
-    }
 
-    template<class T>
-    requires(
-        is_express_layout_desire< std::ranges::range_value_t<T>> &&
-        is_nullable_like< typename std::ranges::range_value_t<T>::value_type >
-    )
-    std::vector<std::size_t>  where_null(T && t)
-    {
-        std::vector<std::size_t> result;
-        for (std::size_t i = 0; i < t.size(); ++i)
+        template <class T>
+            requires(is_express_layout_desire<std::ranges::range_value_t<T>> && is_nullable_like<typename std::ranges::range_value_t<T>::value_type>)
+        std::vector<std::size_t> where_null(T&& t)
         {
-            if (!(t[i].get().has_value()))
+            std::vector<std::size_t> result;
+            for (std::size_t i = 0; i < t.size(); ++i)
             {
-                result.push_back(i);
+                if (!(t[i].get().has_value()))
+                {
+                    result.push_back(i);
+                }
             }
+            return result;
         }
-        return result;
-    }
-    
-    template<class T>
-    std::array<std::size_t,0> where_null(T && )
-    {
-        return {};
-    }
 
-    template<class T>
-    requires(is_plain_value_type<std::ranges::range_value_t<T>>)
-    decltype(auto) ensure_value_range(T && t)
-    {
-        return std::forward<T>(t);
-    }
+        template <class T>
+        std::array<std::size_t, 0> where_null(T&&)
+        {
+            return {};
+        }
 
-    template<class T>
-    requires(!is_plain_value_type<std::ranges::range_value_t<T>>)
-    decltype(auto) ensure_value_range(T && t)
-    {
-        return t | std::views::transform([](auto && v) { 
-            return ensure_value(std::forward<decltype(v)>(v));
-        });
-    }
+        template <class T>
+            requires(is_plain_value_type<std::ranges::range_value_t<T>>)
+        decltype(auto) ensure_value_range(T&& t)
+        {
+            return std::forward<T>(t);
+        }
+
+        template <class T>
+            requires(!is_plain_value_type<std::ranges::range_value_t<T>>)
+        decltype(auto) ensure_value_range(T&& t)
+        {
+            return t
+                   | std::views::transform(
+                       [](auto&& v)
+                       {
+                           return ensure_value(std::forward<decltype(v)>(v));
+                       }
+                   );
+        }
 
-} // namespace detail
+    }  // namespace detail
 
 
-} // namespace sparrow
\ No newline at end of file
+}  // namespace sparrow
\ No newline at end of file
diff --git a/include/sparrow/builder/nested_eq.hpp b/include/sparrow/builder/nested_eq.hpp
index 8bf5fa0a..38fdc6f1 100644
--- a/include/sparrow/builder/nested_eq.hpp
+++ b/include/sparrow/builder/nested_eq.hpp
@@ -19,29 +19,30 @@
 
 #include <sparrow/builder/builder_utils.hpp>
 #include <sparrow/utils/ranges.hpp>
+
 namespace sparrow
 {
 
-    namespace detail{
+    namespace detail
+    {
 
 
         // nested eq / nested hash
-        template<class T>
+        template <class T>
         struct nested_eq;
 
-
         // scalars
-        template<class T>
-        requires std::is_scalar_v<T>
+        template <class T>
+            requires std::is_scalar_v<T>
         struct nested_eq<T>
         {
             bool operator()(const T& a, const T& b) const
             {
                 return a == b;
             }
-        };  
+        };
 
-        template<is_express_layout_desire T>
+        template <is_express_layout_desire T>
         struct nested_eq<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -51,8 +52,8 @@ namespace sparrow
         };
 
         // nullables
-        template<class T>
-        requires is_nullable_like<T>
+        template <class T>
+            requires is_nullable_like<T>
         struct nested_eq<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -68,37 +69,40 @@ namespace sparrow
                 {
                     return false;
                 }
-                else{
-                // both are not null
+                else
+                {
+                    // both are not null
                     return nested_eq<typename T::value_type>{}(a.value(), b.value());
                 }
             }
         };
 
-        // tuple like      
-        template<class T>
-        requires tuple_like<T>
+        // tuple like
+        template <class T>
+            requires tuple_like<T>
         struct nested_eq<T>
         {
             bool operator()(const T& a, const T& b) const
             {
                 constexpr std::size_t N = std::tuple_size_v<T>;
-                return exitable_for_each_index<N>([&](auto i)
-                {
-                    constexpr std::size_t index = decltype(i)::value;
-                    using tuple_element_type = std::decay_t<std::tuple_element_t<decltype(i)::value, T>>;
-                
-                    const auto& a_val = std::get<index>(a);
-                    const auto& b_val = std::get<index>(b);
-
-                    return nested_eq<tuple_element_type>{}(a_val, b_val);
-                });
+                return exitable_for_each_index<N>(
+                    [&](auto i)
+                    {
+                        constexpr std::size_t index = decltype(i)::value;
+                        using tuple_element_type = std::decay_t<std::tuple_element_t<decltype(i)::value, T>>;
+
+                        const auto& a_val = std::get<index>(a);
+                        const auto& b_val = std::get<index>(b);
+
+                        return nested_eq<tuple_element_type>{}(a_val, b_val);
+                    }
+                );
             }
         };
 
         // ranges (and not tuple like)
-        template<class T>
-        requires(std::ranges::input_range<T> && !tuple_like<T>)
+        template <class T>
+            requires(std::ranges::input_range<T> && !tuple_like<T>)
         struct nested_eq<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -108,8 +112,8 @@ namespace sparrow
         };
 
         // variants
-        template<class T>
-        requires variant_like<T>
+        template <class T>
+            requires variant_like<T>
         struct nested_eq<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -118,19 +122,19 @@ namespace sparrow
                 {
                     return false;
                 }
-                return std::visit([&](const auto& a_val)
-                {
-                    using value_type = std::decay_t<decltype(a_val)>; 
-                    const auto & b_val = std::get<value_type>(b);
-                    return nested_eq<value_type>{}(a_val, b_val);
-                }, a);
+                return std::visit(
+                    [&](const auto& a_val)
+                    {
+                        using value_type = std::decay_t<decltype(a_val)>;
+                        const auto& b_val = std::get<value_type>(b);
+                        return nested_eq<value_type>{}(a_val, b_val);
+                    },
+                    a
+                );
             }
         };
 
-    } // namespace detail
-
-
-
+    }  // namespace detail
 
 
-} // namespace sparrow
\ No newline at end of file
+}  // namespace sparrow
\ No newline at end of file
diff --git a/include/sparrow/builder/nested_less.hpp b/include/sparrow/builder/nested_less.hpp
index b3116ce7..9dc7218e 100644
--- a/include/sparrow/builder/nested_less.hpp
+++ b/include/sparrow/builder/nested_less.hpp
@@ -19,29 +19,30 @@
 
 #include <sparrow/builder/builder_utils.hpp>
 #include <sparrow/utils/ranges.hpp>
+
 namespace sparrow
 {
 
-    namespace detail{
+    namespace detail
+    {
 
 
         // nested eq / nested hash
-        template<class T>
+        template <class T>
         struct nested_less;
 
-
         // scalars
-        template<class T>
-        requires std::is_scalar_v<T>
+        template <class T>
+            requires std::is_scalar_v<T>
         struct nested_less<T>
         {
             bool operator()(const T& a, const T& b) const
             {
                 return a < b;
             }
-        };  
+        };
 
-        template<is_express_layout_desire T>
+        template <is_express_layout_desire T>
         struct nested_less<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -51,8 +52,8 @@ namespace sparrow
         };
 
         // nullables
-        template<class T>
-        requires is_nullable_like<T>
+        template <class T>
+            requires is_nullable_like<T>
         struct nested_less<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -73,56 +74,59 @@ namespace sparrow
                 {
                     return false;
                 }
-                else{
-                // both are not null
+                else
+                {
+                    // both are not null
                     return nested_less<typename T::value_type>{}(a.value(), b.value());
                 }
             }
         };
 
-        // tuple like      
-        template<class T>
-        requires tuple_like<T>
+        // tuple like
+        template <class T>
+            requires tuple_like<T>
         struct nested_less<T>
         {
             bool operator()(const T& a, const T& b) const
             {
                 constexpr std::size_t N = std::tuple_size_v<T>;
                 bool is_less = false;
-                exitable_for_each_index<N>([&](auto i)
-                {
-                    constexpr std::size_t index = decltype(i)::value;
-                    using tuple_element_type = std::decay_t<std::tuple_element_t<decltype(i)::value, T>>;
-                
-                    const auto& a_val = std::get<index>(a);
-                    const auto& b_val = std::get<index>(b);
-
-                    // a < b
-                    if(nested_less<tuple_element_type>{}(a_val, b_val))
-                    {
-                        is_less = true; 
-                        return false;   // break
-                    }
-                    // a >= b
-                    else if(nested_less<tuple_element_type>{}(b_val, a_val))
+                exitable_for_each_index<N>(
+                    [&](auto i)
                     {
-                        is_less = false;
-                        return false;   // break
+                        constexpr std::size_t index = decltype(i)::value;
+                        using tuple_element_type = std::decay_t<std::tuple_element_t<decltype(i)::value, T>>;
+
+                        const auto& a_val = std::get<index>(a);
+                        const auto& b_val = std::get<index>(b);
+
+                        // a < b
+                        if (nested_less<tuple_element_type>{}(a_val, b_val))
+                        {
+                            is_less = true;
+                            return false;  // break
+                        }
+                        // a >= b
+                        else if (nested_less<tuple_element_type>{}(b_val, a_val))
+                        {
+                            is_less = false;
+                            return false;  // break
+                        }
+                        // a == b
+                        else
+                        {
+                            is_less = false;
+                            return true;  // continue
+                        }
                     }
-                    // a == b
-                    else
-                    {
-                        is_less = false;
-                        return true;    // continue
-                    }
-                });
+                );
                 return is_less;
             }
         };
 
         // ranges (and not tuple like)
-        template<class T>
-        requires(std::ranges::input_range<T> && !tuple_like<T>)
+        template <class T>
+            requires(std::ranges::input_range<T> && !tuple_like<T>)
         struct nested_less<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -133,8 +137,8 @@ namespace sparrow
         };
 
         // variants
-        template<class T>
-        requires variant_like<T>
+        template <class T>
+            requires variant_like<T>
         struct nested_less<T>
         {
             bool operator()(const T& a, const T& b) const
@@ -143,19 +147,19 @@ namespace sparrow
                 {
                     return a.index() < b.index();
                 }
-                return std::visit([&](const auto& a_val)
-                {
-                    using value_type = std::decay_t<decltype(a_val)>; 
-                    const auto & b_val = std::get<value_type>(b);
-                    return nested_less<value_type>{}(a_val, b_val);
-                }, a);
+                return std::visit(
+                    [&](const auto& a_val)
+                    {
+                        using value_type = std::decay_t<decltype(a_val)>;
+                        const auto& b_val = std::get<value_type>(b);
+                        return nested_less<value_type>{}(a_val, b_val);
+                    },
+                    a
+                );
             }
         };
 
-    } // namespace detail
-
-
-
+    }  // namespace detail
 
 
-} // namespace sparrow
\ No newline at end of file
+}  // namespace sparrow
\ No newline at end of file
diff --git a/include/sparrow/config/config.hpp b/include/sparrow/config/config.hpp
index 87698e34..6968505b 100644
--- a/include/sparrow/config/config.hpp
+++ b/include/sparrow/config/config.hpp
@@ -27,15 +27,15 @@
 #endif
 
 #if defined(_WIN32)
-#   if defined(SPARROW_STATIC_LIB)
-#       define SPARROW_API
-#   elif defined(SPARROW_EXPORTS)
-#       define SPARROW_API __declspec(dllexport)
-#   else
-#       define SPARROW_API __declspec(dllimport)
-#   endif
+#    if defined(SPARROW_STATIC_LIB)
+#        define SPARROW_API
+#    elif defined(SPARROW_EXPORTS)
+#        define SPARROW_API __declspec(dllexport)
+#    else
+#        define SPARROW_API __declspec(dllimport)
+#    endif
 #else
-#   define SPARROW_API __attribute__((visibility("default")))
+#    define SPARROW_API __attribute__((visibility("default")))
 #endif
 
 consteval bool is_apple_compiler()
diff --git a/include/sparrow/layout/array_access.hpp b/include/sparrow/layout/array_access.hpp
index f81e447f..2e7e75b0 100644
--- a/include/sparrow/layout/array_access.hpp
+++ b/include/sparrow/layout/array_access.hpp
@@ -18,18 +18,18 @@
 
 namespace sparrow::detail
 {
-    
+
     class array_access
     {
     public:
 
-        template<class ARRAY>
-        static const sparrow::arrow_proxy& get_arrow_proxy(const ARRAY& array) 
+        template <class ARRAY>
+        static const sparrow::arrow_proxy& get_arrow_proxy(const ARRAY& array)
         {
             return array.get_arrow_proxy();
         }
 
-        template<class ARRAY>
+        template <class ARRAY>
         static sparrow::arrow_proxy& get_arrow_proxy(ARRAY& array)
         {
             return array.get_arrow_proxy();
diff --git a/include/sparrow/layout/array_base.hpp b/include/sparrow/layout/array_base.hpp
index 29053b6b..65187883 100644
--- a/include/sparrow/layout/array_base.hpp
+++ b/include/sparrow/layout/array_base.hpp
@@ -22,9 +22,9 @@
 
 #include "sparrow/arrow_array_schema_proxy.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp"
+#include "sparrow/layout/array_access.hpp"
 #include "sparrow/layout/layout_iterator.hpp"
 #include "sparrow/utils/crtp_base.hpp"
-#include "sparrow/layout/array_access.hpp"
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/nullable.hpp"
 
@@ -217,8 +217,7 @@ namespace sparrow
         if (i >= size())
         {
             std::ostringstream oss117;
-            oss117 << "Index " << i << "is greater or equal to size of array ("
-                << size() << ")";
+            oss117 << "Index " << i << "is greater or equal to size of array (" << size() << ")";
             throw std::out_of_range(oss117.str());
         }
         return (*this)[i];
@@ -241,7 +240,7 @@ namespace sparrow
 
     /**
      * Returns a constant reference to the first element in the container.
-     * Calling `front` on an empty container causes undefined behavior. 
+     * Calling `front` on an empty container causes undefined behavior.
      */
     template <class D>
     auto array_crtp_base<D>::front() const -> const_reference
@@ -252,7 +251,7 @@ namespace sparrow
 
     /**
      * Returns a constant reference to the last element in the container.
-     * Calling `back` on an empty container causes undefined behavior. 
+     * Calling `back` on an empty container causes undefined behavior.
      */
     template <class D>
     auto array_crtp_base<D>::back() const -> const_reference
@@ -293,7 +292,7 @@ namespace sparrow
 
     /**
      * Returns a constant iterator to the element following the last
-     * element of the array. This method ensures that a constant iterator 
+     * element of the array. This method ensures that a constant iterator
      * is returned, even when called on a non-const array.
      */
     template <class D>
@@ -323,10 +322,11 @@ namespace sparrow
     {
         return crend();
     }
+
     /**
      * Returns a constant reverse iterator to the first element of the
      * reversed array. It corresponds to the last element of the non-
-     * reversed array. This method ensures that a constant reverse 
+     * reversed array. This method ensures that a constant reverse
      * iterator is returned, even when called on a non-const array.
      */
     template <class D>
@@ -347,7 +347,7 @@ namespace sparrow
     {
         return const_reverse_iterator(cbegin());
     }
-    
+
     /**
      * Returns the validity bitmap of the array (i.e. the "has_value" part of the
      * nullable elements) as a constant range.
diff --git a/include/sparrow/layout/array_bitmap_base.hpp b/include/sparrow/layout/array_bitmap_base.hpp
index 38654774..e006dab5 100644
--- a/include/sparrow/layout/array_bitmap_base.hpp
+++ b/include/sparrow/layout/array_bitmap_base.hpp
@@ -185,12 +185,10 @@ namespace sparrow
     template <class D, bool is_mutable>
     template <std::input_iterator InputIt>
         requires std::same_as<typename std::iterator_traits<InputIt>::value_type, bool>
-                 auto array_bitmap_base_impl<D, is_mutable>::insert_bitmap(
-                     const_bitmap_iterator pos,
-                     InputIt first,
-                     InputIt last
-                 ) -> bitmap_iterator
-                     requires is_mutable
+    auto
+    array_bitmap_base_impl<D, is_mutable>::insert_bitmap(const_bitmap_iterator pos, InputIt first, InputIt last)
+        -> bitmap_iterator
+        requires is_mutable
     {
         SPARROW_ASSERT_TRUE(this->bitmap_cbegin() <= pos)
         SPARROW_ASSERT_TRUE(pos <= this->bitmap_cend());
@@ -201,8 +199,8 @@ namespace sparrow
     }
 
     template <class D, bool is_mutable>
-    auto
-    array_bitmap_base_impl<D, is_mutable>::erase_bitmap(const_bitmap_iterator pos, size_type count) -> bitmap_iterator
+    auto array_bitmap_base_impl<D, is_mutable>::erase_bitmap(const_bitmap_iterator pos, size_type count)
+        -> bitmap_iterator
         requires is_mutable
     {
         SPARROW_ASSERT_TRUE(this->bitmap_cbegin() <= pos)
diff --git a/include/sparrow/layout/array_wrapper.hpp b/include/sparrow/layout/array_wrapper.hpp
index ccf8c691..d3f8e377 100644
--- a/include/sparrow/layout/array_wrapper.hpp
+++ b/include/sparrow/layout/array_wrapper.hpp
@@ -26,11 +26,10 @@ namespace sparrow
 {
 
     template <class T>
-    concept layout = requires(T& t)
-    {
+    concept layout = requires(T& t) {
         // inner_value_type
         typename T::inner_value_type;
-        
+
         t[std::size_t()];
         t.size();
         t.begin();
@@ -40,16 +39,16 @@ namespace sparrow
     };
 
     namespace detail
-    {   
-        // Helper struct to allow overloading on the type of ARRAY 
-        // to get the data_type for an array. This is needed since 
+    {
+        // Helper struct to allow overloading on the type of ARRAY
+        // to get the data_type for an array. This is needed since
         // some arrays (for instance run_length_encoded_array)
         // do not have a inner_value_type, therefore we specialize
         // this in their respecitve headers.
-        template<class ARRAY>
+        template <class ARRAY>
         struct get_data_type_from_array
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return arrow_traits<typename ARRAY::inner_value_type>::type_id;
             }
@@ -58,7 +57,7 @@ namespace sparrow
         template <class ARRAY>
         struct is_dictionary_encoded_array
         {
-            constexpr static bool get()
+            static constexpr bool get()
             {
                 return false;
             }
@@ -115,7 +114,7 @@ namespace sparrow
 
         T& get_wrapped();
         const T& get_wrapped() const;
-        
+
     private:
 
         using wrapper_ptr = array_wrapper::wrapper_ptr;
@@ -162,13 +161,12 @@ namespace sparrow
     {
         return get_arrow_proxy_impl();
     }
-  
+
     inline const arrow_proxy& array_wrapper::get_arrow_proxy() const
     {
         return get_arrow_proxy_impl();
     }
 
-
     inline array_wrapper::array_wrapper(enum data_type dt)
         : m_data_type(dt)
     {
@@ -225,14 +223,21 @@ namespace sparrow
         : array_wrapper(rhs)
         , m_storage(rhs.m_storage)
     {
-        p_array = std::visit([](auto&& arg)
-        {
-            using U = std::decay_t<decltype(arg)>;
-            if constexpr (std::is_same_v<U, T*>)
-                return arg;
-            else
-                return arg.get();
-        }, m_storage);
+        p_array = std::visit(
+            [](auto&& arg)
+            {
+                using U = std::decay_t<decltype(arg)>;
+                if constexpr (std::is_same_v<U, T*>)
+                {
+                    return arg;
+                }
+                else
+                {
+                    return arg.get();
+                }
+            },
+            m_storage
+        );
     }
 
     template <class T>
@@ -253,7 +258,6 @@ namespace sparrow
         return detail::array_access::get_arrow_proxy(*p_array);
     }
 
-
     template <class T>
     auto array_wrapper_impl<T>::clone_impl() const -> wrapper_ptr
     {
@@ -272,4 +276,3 @@ namespace sparrow
         return static_cast<const array_wrapper_impl<T>&>(ar).get_wrapped();
     }
 }
-
diff --git a/include/sparrow/layout/dictionary_encoded_array.hpp b/include/sparrow/layout/dictionary_encoded_array.hpp
index c31dbc21..08c7411e 100644
--- a/include/sparrow/layout/dictionary_encoded_array.hpp
+++ b/include/sparrow/layout/dictionary_encoded_array.hpp
@@ -28,7 +28,6 @@
 #include "sparrow/utils/functor_index_iterator.hpp"
 #include "sparrow/utils/memory.hpp"
 
-
 namespace sparrow
 {
     template <class Layout, bool is_const>
@@ -167,8 +166,8 @@ namespace sparrow
     private:
 
         template <validity_bitmap_input R = validity_bitmap>
-        static auto
-        create_proxy(keys_buffer_type&& keys, array&& values, R&& bitmaps = validity_bitmap{}) -> arrow_proxy;
+        static auto create_proxy(keys_buffer_type&& keys, array&& values, R&& bitmaps = validity_bitmap{})
+            -> arrow_proxy;
 
         using keys_layout = primitive_array<IT>;
         using values_layout = cloning_ptr<array_wrapper>;
diff --git a/include/sparrow/layout/dispatch.hpp b/include/sparrow/layout/dispatch.hpp
index c28fa62c..f84aa4cb 100644
--- a/include/sparrow/layout/dispatch.hpp
+++ b/include/sparrow/layout/dispatch.hpp
@@ -17,16 +17,16 @@
 #include <type_traits>
 
 #include "sparrow/layout/array_wrapper.hpp"
-#include "sparrow/layout/null_array.hpp"
+#include "sparrow/layout/decimal_array.hpp"
 #include "sparrow/layout/dictionary_encoded_array.hpp"
-#include "sparrow/layout/primitive_array.hpp"
+#include "sparrow/layout/list_layout/list_array.hpp"
 #include "sparrow/layout/nested_value_types.hpp"
+#include "sparrow/layout/null_array.hpp"
+#include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
-#include "sparrow/layout/list_layout/list_array.hpp"
 #include "sparrow/layout/struct_layout/struct_array.hpp"
-#include "sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp"
 #include "sparrow/layout/union_array.hpp"
-#include "sparrow/layout/decimal_array.hpp"
+#include "sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp"
 #include "sparrow/types/data_traits.hpp"
 
 namespace sparrow
@@ -39,90 +39,90 @@ namespace sparrow
     {
         if (ar.is_dictionary())
         {
-            switch(ar.data_type())
+            switch (ar.data_type())
             {
-            case data_type::UINT8:
-                return func(unwrap_array<dictionary_encoded_array<std::uint8_t>>(ar));
-            case data_type::INT8:
-                return func(unwrap_array<dictionary_encoded_array<std::int8_t>>(ar));
-            case data_type::UINT16:
-                return func(unwrap_array<dictionary_encoded_array<std::uint16_t>>(ar));
-            case data_type::INT16:
-                return func(unwrap_array<dictionary_encoded_array<std::int16_t>>(ar));
-            case data_type::UINT32:
-                return func(unwrap_array<dictionary_encoded_array<std::uint32_t>>(ar));
-            case data_type::INT32:
-                return func(unwrap_array<dictionary_encoded_array<std::int32_t>>(ar));
-            case data_type::UINT64:
-                return func(unwrap_array<dictionary_encoded_array<std::uint64_t>>(ar));
-            case data_type::INT64:
-                return func(unwrap_array<dictionary_encoded_array<std::int64_t>>(ar));
-            default:
-                throw std::runtime_error("data datype of dictionary encoded array must be an integer");
+                case data_type::UINT8:
+                    return func(unwrap_array<dictionary_encoded_array<std::uint8_t>>(ar));
+                case data_type::INT8:
+                    return func(unwrap_array<dictionary_encoded_array<std::int8_t>>(ar));
+                case data_type::UINT16:
+                    return func(unwrap_array<dictionary_encoded_array<std::uint16_t>>(ar));
+                case data_type::INT16:
+                    return func(unwrap_array<dictionary_encoded_array<std::int16_t>>(ar));
+                case data_type::UINT32:
+                    return func(unwrap_array<dictionary_encoded_array<std::uint32_t>>(ar));
+                case data_type::INT32:
+                    return func(unwrap_array<dictionary_encoded_array<std::int32_t>>(ar));
+                case data_type::UINT64:
+                    return func(unwrap_array<dictionary_encoded_array<std::uint64_t>>(ar));
+                case data_type::INT64:
+                    return func(unwrap_array<dictionary_encoded_array<std::int64_t>>(ar));
+                default:
+                    throw std::runtime_error("data datype of dictionary encoded array must be an integer");
             }
         }
         else
         {
-            switch(ar.data_type())
+            switch (ar.data_type())
             {
-            case data_type::NA:
-                return func(unwrap_array<null_array>(ar));;
-            case data_type::BOOL:
-                return func(unwrap_array<primitive_array<bool>>(ar));
-            case data_type::UINT8:
-                return func(unwrap_array<primitive_array<std::uint8_t>>(ar));
-            case data_type::INT8:
-                return func(unwrap_array<primitive_array<std::int8_t>>(ar));
-            case data_type::UINT16:
-                return func(unwrap_array<primitive_array<std::uint16_t>>(ar));
-            case data_type::INT16:
-                return func(unwrap_array<primitive_array<std::int16_t>>(ar));
-            case data_type::UINT32:
-                return func(unwrap_array<primitive_array<std::uint32_t>>(ar));
-            case data_type::INT32:
-                return func(unwrap_array<primitive_array<std::int32_t>>(ar));
-            case data_type::UINT64:
-                return func(unwrap_array<primitive_array<std::uint64_t>>(ar));
-            case data_type::INT64:
-                return func(unwrap_array<primitive_array<std::int64_t>>(ar));
-            case data_type::HALF_FLOAT:
-                return func(unwrap_array<primitive_array<float16_t>>(ar));
-            case data_type::FLOAT:
-                return func(unwrap_array<primitive_array<float32_t>>(ar));
-            case data_type::DOUBLE:
-                return func(unwrap_array<primitive_array<float64_t>>(ar));
-            case data_type::STRING:
-                return func(unwrap_array<string_array>(ar));
-            case data_type::RUN_ENCODED:
-                return func(unwrap_array<run_end_encoded_array>(ar));
-            case data_type::LIST:
-                return func(unwrap_array<list_array>(ar));
-            case data_type::LARGE_LIST:
-                return func(unwrap_array<big_list_array>(ar));
-            case data_type::LIST_VIEW:
-                return func(unwrap_array<list_view_array>(ar));
-            case data_type::LARGE_LIST_VIEW:
-                return func(unwrap_array<big_list_view_array>(ar));
-            case data_type::FIXED_SIZED_LIST:
-                return func(unwrap_array<fixed_sized_list_array>(ar));
-            case data_type::STRUCT:
-                return func(unwrap_array<struct_array>(ar));
-            case data_type::DENSE_UNION:
-                return func(unwrap_array<dense_union_array>(ar));
-            case data_type::SPARSE_UNION:
-                return func(unwrap_array<sparse_union_array>(ar));
-            case data_type::DECIMAL32:
-                return func(unwrap_array<decimal_32_array>(ar));
-            case data_type::DECIMAL64:
-                return func(unwrap_array<decimal_64_array>(ar));
-            case data_type::DECIMAL128:
-                return func(unwrap_array<decimal_128_array>(ar));
-            case data_type::DECIMAL256:
-                return func(unwrap_array<decimal_256_array>(ar));
-            default:
-                throw std::invalid_argument("array type not supported");
+                case data_type::NA:
+                    return func(unwrap_array<null_array>(ar));
+                    ;
+                case data_type::BOOL:
+                    return func(unwrap_array<primitive_array<bool>>(ar));
+                case data_type::UINT8:
+                    return func(unwrap_array<primitive_array<std::uint8_t>>(ar));
+                case data_type::INT8:
+                    return func(unwrap_array<primitive_array<std::int8_t>>(ar));
+                case data_type::UINT16:
+                    return func(unwrap_array<primitive_array<std::uint16_t>>(ar));
+                case data_type::INT16:
+                    return func(unwrap_array<primitive_array<std::int16_t>>(ar));
+                case data_type::UINT32:
+                    return func(unwrap_array<primitive_array<std::uint32_t>>(ar));
+                case data_type::INT32:
+                    return func(unwrap_array<primitive_array<std::int32_t>>(ar));
+                case data_type::UINT64:
+                    return func(unwrap_array<primitive_array<std::uint64_t>>(ar));
+                case data_type::INT64:
+                    return func(unwrap_array<primitive_array<std::int64_t>>(ar));
+                case data_type::HALF_FLOAT:
+                    return func(unwrap_array<primitive_array<float16_t>>(ar));
+                case data_type::FLOAT:
+                    return func(unwrap_array<primitive_array<float32_t>>(ar));
+                case data_type::DOUBLE:
+                    return func(unwrap_array<primitive_array<float64_t>>(ar));
+                case data_type::STRING:
+                    return func(unwrap_array<string_array>(ar));
+                case data_type::RUN_ENCODED:
+                    return func(unwrap_array<run_end_encoded_array>(ar));
+                case data_type::LIST:
+                    return func(unwrap_array<list_array>(ar));
+                case data_type::LARGE_LIST:
+                    return func(unwrap_array<big_list_array>(ar));
+                case data_type::LIST_VIEW:
+                    return func(unwrap_array<list_view_array>(ar));
+                case data_type::LARGE_LIST_VIEW:
+                    return func(unwrap_array<big_list_view_array>(ar));
+                case data_type::FIXED_SIZED_LIST:
+                    return func(unwrap_array<fixed_sized_list_array>(ar));
+                case data_type::STRUCT:
+                    return func(unwrap_array<struct_array>(ar));
+                case data_type::DENSE_UNION:
+                    return func(unwrap_array<dense_union_array>(ar));
+                case data_type::SPARSE_UNION:
+                    return func(unwrap_array<sparse_union_array>(ar));
+                case data_type::DECIMAL32:
+                    return func(unwrap_array<decimal_32_array>(ar));
+                case data_type::DECIMAL64:
+                    return func(unwrap_array<decimal_64_array>(ar));
+                case data_type::DECIMAL128:
+                    return func(unwrap_array<decimal_128_array>(ar));
+                case data_type::DECIMAL256:
+                    return func(unwrap_array<decimal_256_array>(ar));
+                default:
+                    throw std::invalid_argument("array type not supported");
             }
         }
     }
 }
-
diff --git a/include/sparrow/layout/layout_utils.hpp b/include/sparrow/layout/layout_utils.hpp
index 8dddff6f..ccf3049c 100644
--- a/include/sparrow/layout/layout_utils.hpp
+++ b/include/sparrow/layout/layout_utils.hpp
@@ -14,9 +14,9 @@
 
 #pragma once
 
-#include "sparrow/utils/ranges.hpp"
-#include "sparrow/utils/functor_index_iterator.hpp"
 #include "sparrow/buffer/u8_buffer.hpp"
+#include "sparrow/utils/functor_index_iterator.hpp"
+#include "sparrow/utils/ranges.hpp"
 
 namespace sparrow::detail
 {
@@ -24,7 +24,7 @@ namespace sparrow::detail
     //
     // This is usefull to create a iterator over the values of a layout.
     // This functor will be passed to the functor_index_iterator.
-    template<class LAYOUT_TYPE, class VALUE_TYPE>
+    template <class LAYOUT_TYPE, class VALUE_TYPE>
     class layout_value_functor
     {
     public:
@@ -47,12 +47,11 @@ namespace sparrow::detail
         layout_type* p_layout;
     };
 
-
     // Functor to get the optional-value of the layout at index i.
     //
     // This is usefull to create a iterator over the nullable-values of a layout.
     // This functor will be passed to the functor_index_iterator.
-    template<class LAYOUT_TYPE, class VALUE_TYPE>
+    template <class LAYOUT_TYPE, class VALUE_TYPE>
     class layout_bracket_functor
     {
     public:
@@ -75,16 +74,15 @@ namespace sparrow::detail
         layout_type* p_layout;
     };
 
-
-    template<layout_offset OFFSET_TYPE, std::ranges::range SIZES_RANGE>
-    requires(std::unsigned_integral<std::ranges::range_value_t<SIZES_RANGE>>)
-    sparrow::u8_buffer<OFFSET_TYPE> offset_buffer_from_sizes(SIZES_RANGE && sizes)
+    template <layout_offset OFFSET_TYPE, std::ranges::range SIZES_RANGE>
+        requires(std::unsigned_integral<std::ranges::range_value_t<SIZES_RANGE>>)
+    sparrow::u8_buffer<OFFSET_TYPE> offset_buffer_from_sizes(SIZES_RANGE&& sizes)
     {
-        sparrow::u8_buffer<OFFSET_TYPE> buffer( range_size(sizes) + 1);
+        sparrow::u8_buffer<OFFSET_TYPE> buffer(range_size(sizes) + 1);
 
         OFFSET_TYPE offset = 0;
         auto it = buffer.begin();
-        for(auto size : sizes)
+        for (auto size : sizes)
         {
             *it = offset;
             offset += static_cast<OFFSET_TYPE>(size);
@@ -94,4 +92,4 @@ namespace sparrow::detail
         return buffer;
     }
 
-} // namespace sparrow
+}  // namespace sparrow
diff --git a/include/sparrow/layout/list_layout/list_array.hpp b/include/sparrow/layout/list_layout/list_array.hpp
index d1fda9f9..ac29e0e7 100644
--- a/include/sparrow/layout/list_layout/list_array.hpp
+++ b/include/sparrow/layout/list_layout/list_array.hpp
@@ -15,11 +15,13 @@
 #pragma once
 
 #include <string>  // for std::stoull
-#include <type_traits> 
+#include <type_traits>
 
+#include "sparrow/array_api.hpp"
+#include "sparrow/array_factory.hpp"
 #include "sparrow/arrow_interface/arrow_array.hpp"
 #include "sparrow/arrow_interface/arrow_schema.hpp"
-#include "sparrow/array_factory.hpp"
+#include "sparrow/buffer/dynamic_bitset.hpp"
 #include "sparrow/layout/array_bitmap_base.hpp"
 #include "sparrow/layout/array_wrapper.hpp"
 #include "sparrow/layout/layout_utils.hpp"
@@ -29,9 +31,6 @@
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/memory.hpp"
 #include "sparrow/utils/nullable.hpp"
-#include "sparrow/array_api.hpp"
-#include "sparrow/buffer/dynamic_bitset.hpp"
-#include "sparrow/layout/layout_utils.hpp"
 
 namespace sparrow
 {
@@ -84,49 +83,49 @@ namespace sparrow
 
     namespace detail
     {
-        template<class T>
+        template <class T>
         struct get_data_type_from_array;
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::list_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::LIST;
             }
         };
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::big_list_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::LARGE_LIST;
             }
         };
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::list_view_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::LIST_VIEW;
             }
         };
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::big_list_view_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::LARGE_LIST_VIEW;
             }
         };
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::fixed_sized_list_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::FIXED_SIZED_LIST;
             }
@@ -183,7 +182,7 @@ namespace sparrow
     // - big-list-array
     // - list-view-array
     // - big-list-view-array
-    // - fixed-size-list-array 
+    // - fixed-size-list-array
     template <class DERIVED>
     class list_array_crtp_base : public array_bitmap_base<DERIVED>
     {
@@ -261,7 +260,7 @@ namespace sparrow
         using list_size_type = inner_types::list_size_type;
         using size_type = typename base_type::size_type;
         using offset_type = std::conditional_t<BIG, const std::int64_t, const std::int32_t>;
-        using offset_buffer_type  = u8_buffer<std::remove_const_t<offset_type>>;
+        using offset_buffer_type = u8_buffer<std::remove_const_t<offset_type>>;
 
         explicit list_array_impl(arrow_proxy proxy);
 
@@ -271,18 +270,24 @@ namespace sparrow
         list_array_impl(self_type&&) = default;
         list_array_impl& operator=(self_type&&) = default;
 
-        template<class ... ARGS>
-        requires(mpl::excludes_copy_and_move_ctor_v<list_array_impl<BIG>, ARGS...>)
-        explicit list_array_impl(ARGS && ... args): self_type(create_proxy(std::forward<ARGS>(args)...))
-        {}
+        template <class... ARGS>
+            requires(mpl::excludes_copy_and_move_ctor_v<list_array_impl<BIG>, ARGS...>)
+        explicit list_array_impl(ARGS&&... args)
+            : self_type(create_proxy(std::forward<ARGS>(args)...))
+        {
+        }
 
-        template<std::ranges::range SIZES_RANGE>
-        static auto offset_from_sizes(SIZES_RANGE && sizes) -> offset_buffer_type;
+        template <std::ranges::range SIZES_RANGE>
+        static auto offset_from_sizes(SIZES_RANGE&& sizes) -> offset_buffer_type;
 
     private:
 
-        template<validity_bitmap_input VB = validity_bitmap >
-        static arrow_proxy create_proxy(array && flat_values, offset_buffer_type && list_offsets,VB && validity_input = validity_bitmap{});
+        template <validity_bitmap_input VB = validity_bitmap>
+        static arrow_proxy create_proxy(
+            array&& flat_values,
+            offset_buffer_type&& list_offsets,
+            VB&& validity_input = validity_bitmap{}
+        );
 
         static constexpr std::size_t OFFSET_BUFFER_INDEX = 1;
         std::pair<offset_type, offset_type> offset_range(size_type i) const;
@@ -307,7 +312,7 @@ namespace sparrow
         using list_size_type = inner_types::list_size_type;
         using size_type = typename base_type::size_type;
         using offset_type = std::conditional_t<BIG, const std::int64_t, const std::int32_t>;
-        using offset_buffer_type  = u8_buffer<std::remove_const_t<offset_type>>;
+        using offset_buffer_type = u8_buffer<std::remove_const_t<offset_type>>;
         using size_buffer_type = u8_buffer<std::remove_const_t<list_size_type>>;
 
         explicit list_view_array_impl(arrow_proxy proxy);
@@ -318,15 +323,22 @@ namespace sparrow
         list_view_array_impl(self_type&&) = default;
         list_view_array_impl& operator=(self_type&&) = default;
 
-        template<class ...ARGS>
-        requires(mpl::excludes_copy_and_move_ctor_v<list_view_array_impl<BIG>, ARGS...>)
-        list_view_array_impl(ARGS&& ...args): self_type(create_proxy(std::forward<ARGS>(args)...))
-        {}
+        template <class... ARGS>
+            requires(mpl::excludes_copy_and_move_ctor_v<list_view_array_impl<BIG>, ARGS...>)
+        list_view_array_impl(ARGS&&... args)
+            : self_type(create_proxy(std::forward<ARGS>(args)...))
+        {
+        }
 
     private:
 
-        template<validity_bitmap_input VB = validity_bitmap >
-        static arrow_proxy create_proxy(array && flat_values, offset_buffer_type && list_offsets,size_buffer_type && list_sizes,VB && validity_input = validity_bitmap{});
+        template <validity_bitmap_input VB = validity_bitmap>
+        static arrow_proxy create_proxy(
+            array&& flat_values,
+            offset_buffer_type&& list_offsets,
+            size_buffer_type&& list_sizes,
+            VB&& validity_input = validity_bitmap{}
+        );
 
         static constexpr std::size_t OFFSET_BUFFER_INDEX = 1;
         static constexpr std::size_t SIZES_BUFFER_INDEX = 2;
@@ -362,14 +374,18 @@ namespace sparrow
         fixed_sized_list_array(self_type&&) = default;
         fixed_sized_list_array& operator=(self_type&&) = default;
 
-        template<class ...ARGS>
-        requires(mpl::excludes_copy_and_move_ctor_v<fixed_sized_list_array, ARGS...>)
-        fixed_sized_list_array(ARGS&& ...args): self_type(create_proxy(std::forward<ARGS>(args)...))
-        {}
+        template <class... ARGS>
+            requires(mpl::excludes_copy_and_move_ctor_v<fixed_sized_list_array, ARGS...>)
+        fixed_sized_list_array(ARGS&&... args)
+            : self_type(create_proxy(std::forward<ARGS>(args)...))
+        {
+        }
 
     private:
-        template<validity_bitmap_input R = validity_bitmap>
-        static arrow_proxy create_proxy(std::uint64_t list_size, array && flat_values, R && validity_input = validity_bitmap{});
+
+        template <validity_bitmap_input R = validity_bitmap>
+        static arrow_proxy
+        create_proxy(std::uint64_t list_size, array&& flat_values, R&& validity_input = validity_bitmap{});
 
         static uint64_t list_size_from_format(const std::string_view format);
         std::pair<offset_type, offset_type> offset_range(size_type i) const;
@@ -491,15 +507,17 @@ namespace sparrow
     }
 
     template <bool BIG>
-    template<std::ranges::range SIZES_RANGE>
-    auto list_array_impl<BIG>::offset_from_sizes(SIZES_RANGE && sizes) -> offset_buffer_type
+    template <std::ranges::range SIZES_RANGE>
+    auto list_array_impl<BIG>::offset_from_sizes(SIZES_RANGE&& sizes) -> offset_buffer_type
     {
-        return detail::offset_buffer_from_sizes<std::remove_const_t<offset_type>>(std::forward<SIZES_RANGE>(sizes));
+        return detail::offset_buffer_from_sizes<std::remove_const_t<offset_type>>(std::forward<SIZES_RANGE>(sizes
+        ));
     }
 
     template <bool BIG>
-    template<validity_bitmap_input VB >
-    arrow_proxy list_array_impl<BIG>::create_proxy(array && flat_values, offset_buffer_type && list_offsets,VB && validity_input)
+    template <validity_bitmap_input VB>
+    arrow_proxy
+    list_array_impl<BIG>::create_proxy(array&& flat_values, offset_buffer_type&& list_offsets, VB&& validity_input)
     {
         const auto size = list_offsets.size() - 1;
         validity_bitmap vbitmap = ensure_validity_bitmap(size, std::forward<VB>(validity_input));
@@ -509,13 +527,13 @@ namespace sparrow
         const auto null_count = vbitmap.null_count();
 
         ArrowSchema schema = make_arrow_schema(
-            BIG ? std::string("+L") : std::string("+l"), // format
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
-            1, // n_children
-            new ArrowSchema*[1]{new ArrowSchema(std::move(flat_schema))}, // children
-            nullptr // dictionary
+            BIG ? std::string("+L") : std::string("+l"),                   // format
+            std::nullopt,                                                  // name
+            std::nullopt,                                                  // metadata
+            std::nullopt,                                                  // flags,
+            1,                                                             // n_children
+            new ArrowSchema*[1]{new ArrowSchema(std::move(flat_schema))},  // children
+            nullptr                                                        // dictionary
 
         );
         std::vector<buffer<std::uint8_t>> arr_buffs = {
@@ -524,13 +542,13 @@ namespace sparrow
         };
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            1, // n_children
-            new ArrowArray*[1]{new ArrowArray(std::move(flat_arr))}, // children
-            nullptr // dictionary
+            1,                                                        // n_children
+            new ArrowArray*[1]{new ArrowArray(std::move(flat_arr))},  // children
+            nullptr                                                   // dictionary
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
@@ -563,7 +581,7 @@ namespace sparrow
     auto list_array_impl<BIG>::make_list_offsets() -> offset_type*
     {
         return reinterpret_cast<offset_type*>(
-              this->get_arrow_proxy().buffers()[OFFSET_BUFFER_INDEX].data() + this->get_arrow_proxy().offset()
+            this->get_arrow_proxy().buffers()[OFFSET_BUFFER_INDEX].data() + this->get_arrow_proxy().offset()
         );
     }
 
@@ -580,16 +598,16 @@ namespace sparrow
     }
 
     template <bool BIG>
-    template<validity_bitmap_input VB >
+    template <validity_bitmap_input VB>
     arrow_proxy list_view_array_impl<BIG>::create_proxy(
-        array && flat_values, 
-        offset_buffer_type && list_offsets,
-        size_buffer_type && list_sizes,
-        VB && validity_input
+        array&& flat_values,
+        offset_buffer_type&& list_offsets,
+        size_buffer_type&& list_sizes,
+        VB&& validity_input
     )
     {
-        SPARROW_ASSERT(list_offsets.size() == list_sizes.size() , "sizes and offset must have the same size");
-        
+        SPARROW_ASSERT(list_offsets.size() == list_sizes.size(), "sizes and offset must have the same size");
+
         const auto size = list_sizes.size();
         validity_bitmap vbitmap = ensure_validity_bitmap(size, std::forward<VB>(validity_input));
 
@@ -598,13 +616,13 @@ namespace sparrow
         const auto null_count = vbitmap.null_count();
 
         ArrowSchema schema = make_arrow_schema(
-            BIG ? std::string("+vL") : std::string("+vl"), // format
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
-            1, // n_children
-            new ArrowSchema*[1]{new ArrowSchema(std::move(flat_schema))}, // children
-            nullptr // dictionary
+            BIG ? std::string("+vL") : std::string("+vl"),                 // format
+            std::nullopt,                                                  // name
+            std::nullopt,                                                  // metadata
+            std::nullopt,                                                  // flags,
+            1,                                                             // n_children
+            new ArrowSchema*[1]{new ArrowSchema(std::move(flat_schema))},  // children
+            nullptr                                                        // dictionary
 
         );
         std::vector<buffer<std::uint8_t>> arr_buffs = {
@@ -614,13 +632,13 @@ namespace sparrow
         };
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            1, // n_children
-            new ArrowArray*[1]{new ArrowArray(std::move(flat_arr))}, // children
-            nullptr // dictionary
+            1,                                                        // n_children
+            new ArrowArray*[1]{new ArrowArray(std::move(flat_arr))},  // children
+            nullptr                                                   // dictionary
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
@@ -646,8 +664,8 @@ namespace sparrow
     }
 
     template <bool BIG>
-    inline auto
-    list_view_array_impl<BIG>::offset_range(size_type i) const -> std::pair<offset_type, offset_type>
+    inline auto list_view_array_impl<BIG>::offset_range(size_type i) const
+        -> std::pair<offset_type, offset_type>
     {
         const auto offset = p_list_offsets[i];
         return std::make_pair(offset, offset + p_list_sizes[i]);
@@ -657,7 +675,7 @@ namespace sparrow
     auto list_view_array_impl<BIG>::make_list_offsets() -> offset_type*
     {
         return reinterpret_cast<offset_type*>(
-              this->get_arrow_proxy().buffers()[OFFSET_BUFFER_INDEX].data() + this->get_arrow_proxy().offset()
+            this->get_arrow_proxy().buffers()[OFFSET_BUFFER_INDEX].data() + this->get_arrow_proxy().offset()
         );
     }
 
@@ -665,7 +683,7 @@ namespace sparrow
     auto list_view_array_impl<BIG>::make_list_sizes() -> offset_type*
     {
         return reinterpret_cast<offset_type*>(
-              this->get_arrow_proxy().buffers()[SIZES_BUFFER_INDEX].data() + this->get_arrow_proxy().offset()
+            this->get_arrow_proxy().buffers()[SIZES_BUFFER_INDEX].data() + this->get_arrow_proxy().offset()
         );
     }
 
@@ -697,11 +715,9 @@ namespace sparrow
         return std::make_pair(offset, offset + m_list_size);
     }
 
-    template<validity_bitmap_input R>
-    inline arrow_proxy fixed_sized_list_array::create_proxy(
-        std::uint64_t list_size, array && flat_values,
-        R && validity_input 
-    )
+    template <validity_bitmap_input R>
+    inline arrow_proxy
+    fixed_sized_list_array::create_proxy(std::uint64_t list_size, array&& flat_values, R&& validity_input)
     {
         const auto size = flat_values.size() / static_cast<std::size_t>(list_size);
         auto vbitmap = ensure_validity_bitmap(size, std::forward<R>(validity_input));
@@ -713,24 +729,24 @@ namespace sparrow
         std::string format = "+w:" + std::to_string(list_size);
         ArrowSchema schema = make_arrow_schema(
             format,
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
-            1, // n_children
-            new ArrowSchema*[1]{new ArrowSchema(std::move(flat_schema))}, // children
-            nullptr // dictionary
+            std::nullopt,                                                  // name
+            std::nullopt,                                                  // metadata
+            std::nullopt,                                                  // flags,
+            1,                                                             // n_children
+            new ArrowSchema*[1]{new ArrowSchema(std::move(flat_schema))},  // children
+            nullptr                                                        // dictionary
 
         );
         std::vector<buffer<std::uint8_t>> arr_buffs = {vbitmap.extract_storage()};
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            1, // n_children
-            new ArrowArray*[1]{new ArrowArray(std::move(flat_arr))}, // children
-            nullptr // dictionary
+            1,                                                        // n_children
+            new ArrowArray*[1]{new ArrowArray(std::move(flat_arr))},  // children
+            nullptr                                                   // dictionary
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
diff --git a/include/sparrow/layout/list_layout/list_value.hpp b/include/sparrow/layout/list_layout/list_value.hpp
index 2ada3ac9..08babcf5 100644
--- a/include/sparrow/layout/list_layout/list_value.hpp
+++ b/include/sparrow/layout/list_layout/list_value.hpp
@@ -44,4 +44,3 @@ namespace sparrow
     SPARROW_API
     bool operator==(const list_value& lhs, const list_value& rhs);
 }
-
diff --git a/include/sparrow/layout/nested_value_types.hpp b/include/sparrow/layout/nested_value_types.hpp
index ce6275fc..4eaa535e 100644
--- a/include/sparrow/layout/nested_value_types.hpp
+++ b/include/sparrow/layout/nested_value_types.hpp
@@ -16,7 +16,7 @@
 
 // we bundle all nested value types in this file
 // otherwise one has to include **all** nested value types
-// wherever the nested value type variant is used 
+// wherever the nested value type variant is used
 // (otherwise there will be incomplete type errors)
 #include "sparrow/layout/list_layout/list_value.hpp"
 #include "sparrow/layout/struct_layout/struct_value.hpp"
diff --git a/include/sparrow/layout/null_array.hpp b/include/sparrow/layout/null_array.hpp
index 239c96ae..5c508adb 100644
--- a/include/sparrow/layout/null_array.hpp
+++ b/include/sparrow/layout/null_array.hpp
@@ -17,11 +17,11 @@
 #include <cstddef>
 #include <ranges>
 
+#include "sparrow/layout/array_access.hpp"
 #include "sparrow/layout/array_base.hpp"
 #include "sparrow/utils/contracts.hpp"
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/nullable.hpp"
-#include "sparrow/layout/array_access.hpp"
 
 namespace sparrow
 {
diff --git a/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp b/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp
index 4f528325..4e172035 100644
--- a/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp
+++ b/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp
@@ -14,13 +14,13 @@
 
 #pragma once
 
+#include "sparrow/array_api.hpp"
+#include "sparrow/array_factory.hpp"
 #include "sparrow/config/config.hpp"
+#include "sparrow/layout/array_access.hpp"
 #include "sparrow/layout/array_wrapper.hpp"
-#include "sparrow/array_factory.hpp"
-#include "sparrow/utils/memory.hpp"
 #include "sparrow/layout/run_end_encoded_layout/run_end_encoded_iterator.hpp"
-#include "sparrow/layout/array_access.hpp"
-#include "sparrow/array_api.hpp"
+#include "sparrow/utils/memory.hpp"
 
 namespace sparrow
 {
@@ -34,20 +34,20 @@ namespace sparrow
 
     namespace detail
     {
-        template<class T>
+        template <class T>
         struct get_data_type_from_array;
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::run_end_encoded_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::RUN_ENCODED;
             }
         };
     }
 
-    class run_end_encoded_array 
+    class run_end_encoded_array
     {
     public:
 
@@ -56,19 +56,19 @@ namespace sparrow
         using inner_value_type = array_traits::inner_value_type;
         using iterator = run_encoded_array_iterator<false>;
         using const_iterator = run_encoded_array_iterator<true>;
-        
-        SPARROW_API explicit run_end_encoded_array(arrow_proxy proxy);
 
-        template <class ... Args>
-        requires(mpl::excludes_copy_and_move_ctor_v<run_end_encoded_array, Args...>)
-        explicit run_end_encoded_array(Args&& ... args)
-            : run_end_encoded_array(create_proxy(std::forward<Args>(args) ...))
-        {}
+        SPARROW_API explicit run_end_encoded_array(arrow_proxy proxy);
 
+        template <class... Args>
+            requires(mpl::excludes_copy_and_move_ctor_v<run_end_encoded_array, Args...>)
+        explicit run_end_encoded_array(Args&&... args)
+            : run_end_encoded_array(create_proxy(std::forward<Args>(args)...))
+        {
+        }
 
         SPARROW_API run_end_encoded_array(const self_type&);
         SPARROW_API self_type& operator=(const self_type&);
-        
+
         SPARROW_API run_end_encoded_array(self_type&&) = default;
         SPARROW_API self_type& operator=(self_type&&) = default;
 
@@ -88,14 +88,12 @@ namespace sparrow
 
     private:
 
-        SPARROW_API static auto create_proxy(
-            array && acc_lengths,
-            array && encoded_values
-        ) -> arrow_proxy;
+        SPARROW_API static auto create_proxy(array&& acc_lengths, array&& encoded_values) -> arrow_proxy;
 
-        using acc_length_ptr_variant_type = std::variant< const std::uint16_t*, const std::uint32_t*,const std::uint64_t*> ;
+        using acc_length_ptr_variant_type = std::variant<const std::uint16_t*, const std::uint32_t*, const std::uint64_t*>;
 
-        SPARROW_API static std::pair<std::int64_t, std::int64_t> extract_length_and_null_count( const array&, const array&);
+        SPARROW_API static std::pair<std::int64_t, std::int64_t>
+        extract_length_and_null_count(const array&, const array&);
         SPARROW_API static acc_length_ptr_variant_type get_acc_lengths_ptr(const array_wrapper& ar);
         SPARROW_API std::uint64_t get_run_length(std::uint64_t run_index) const;
 
@@ -104,7 +102,7 @@ namespace sparrow
 
         arrow_proxy m_proxy;
         std::uint64_t m_encoded_length;
-        
+
         cloning_ptr<array_wrapper> p_acc_lengths_array;
         cloning_ptr<array_wrapper> p_encoded_values_array;
         acc_length_ptr_variant_type m_acc_lengths;
@@ -122,7 +120,7 @@ namespace sparrow
      * run_end_encoded_array implementation *
      ****************************************/
 
-    inline run_end_encoded_array::run_end_encoded_array(arrow_proxy proxy) 
+    inline run_end_encoded_array::run_end_encoded_array(arrow_proxy proxy)
         : m_proxy(std::move(proxy))
         , m_encoded_length(m_proxy.children()[0].length())
         , p_acc_lengths_array(array_factory(m_proxy.children()[0].view()))
@@ -156,24 +154,25 @@ namespace sparrow
 
     inline auto run_end_encoded_array::get_run_length(std::uint64_t run_index) const -> std::uint64_t
     {
-
-        auto ret =  std::visit(
+        auto ret = std::visit(
             [run_index](auto&& acc_lengths_ptr) -> std::uint64_t
             {
-                if(run_index == 0)
-                {   
+                if (run_index == 0)
+                {
                     return static_cast<std::uint64_t>(acc_lengths_ptr[run_index]);
                 }
                 else
                 {
-                    return static_cast<std::uint64_t>(acc_lengths_ptr[run_index] - acc_lengths_ptr[run_index - 1]);
+                    return static_cast<std::uint64_t>(
+                        acc_lengths_ptr[run_index] - acc_lengths_ptr[run_index - 1]
+                    );
                 }
             },
             m_acc_lengths
         );
         return ret;
     }
-    
+
     inline arrow_proxy& run_end_encoded_array::get_arrow_proxy()
     {
         return m_proxy;
@@ -223,4 +222,4 @@ namespace sparrow
     {
         return std::ranges::equal(lhs, rhs);
     }
-} // namespace sparrow
+}  // namespace sparrow
diff --git a/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_iterator.hpp b/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_iterator.hpp
index 8faafb85..bc485ff8 100644
--- a/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_iterator.hpp
+++ b/include/sparrow/layout/run_end_encoded_layout/run_end_encoded_iterator.hpp
@@ -14,10 +14,10 @@
 
 #pragma once
 
-#include "sparrow/config/config.hpp"
-#include "sparrow/layout/array_wrapper.hpp"
 #include "sparrow/array_factory.hpp"
+#include "sparrow/config/config.hpp"
 #include "sparrow/layout/array_helper.hpp"
+#include "sparrow/layout/array_wrapper.hpp"
 #include "sparrow/layout/layout_utils.hpp"
 #include "sparrow/layout/nested_value_types.hpp"
 #include "sparrow/utils/iterator.hpp"
@@ -30,68 +30,73 @@ namespace sparrow
     class run_end_encoded_array;
 
     // this iteratas over the **actual** values of the run encoded array
-    // Ie nullabes values, not values !!! 
-    template<bool CONST>
+    // Ie nullabes values, not values !!!
+    template <bool CONST>
     class run_encoded_array_iterator : public iterator_base<
-        run_encoded_array_iterator<CONST>,
-        array_traits::const_reference,
-        std::forward_iterator_tag,
-        array_traits::const_reference
-    >
-    {   
-
+                                           run_encoded_array_iterator<CONST>,
+                                           array_traits::const_reference,
+                                           std::forward_iterator_tag,
+                                           array_traits::const_reference>
+    {
     private:
-        using array_ptr_type = std::conditional_t<CONST, const run_end_encoded_array *, run_end_encoded_array*>;
+
+        using array_ptr_type = std::conditional_t<CONST, const run_end_encoded_array*, run_end_encoded_array*>;
+
     public:
+
         run_encoded_array_iterator() = default;
         run_encoded_array_iterator(array_ptr_type array_ptr, std::uint64_t index, std::uint64_t run_end_index);
+
     private:
 
         bool equal(const run_encoded_array_iterator& rhs) const;
         void increment();
         array_traits::const_reference dereference() const;
         array_ptr_type p_array = nullptr;
-        array_wrapper * p_encoded_values_array = nullptr;
-        std::uint64_t m_index = 0 ;          // the current index / the index the user sees
+        array_wrapper* p_encoded_values_array = nullptr;
+        std::uint64_t m_index = 0;          // the current index / the index the user sees
         std::uint64_t m_run_end_index = 0;  // the current index in the run ends array
         std::uint64_t m_runs_left = 0;      // the number of runs left in the current run
 
         friend class iterator_access;
     };
-    
-    template<bool CONST>
-    run_encoded_array_iterator<CONST>::run_encoded_array_iterator(array_ptr_type array_ptr, std::uint64_t index, std::uint64_t run_end_index)
-        : 
-        p_array(array_ptr),
-        p_encoded_values_array(array_ptr->p_encoded_values_array.get()),
-        m_index(index), 
-        m_run_end_index(run_end_index),
-        m_runs_left(array_ptr->get_run_length(index))
+
+    template <bool CONST>
+    run_encoded_array_iterator<CONST>::run_encoded_array_iterator(
+        array_ptr_type array_ptr,
+        std::uint64_t index,
+        std::uint64_t run_end_index
+    )
+        : p_array(array_ptr)
+        , p_encoded_values_array(array_ptr->p_encoded_values_array.get())
+        , m_index(index)
+        , m_run_end_index(run_end_index)
+        , m_runs_left(array_ptr->get_run_length(index))
     {
     }
 
-    template<bool CONST>
+    template <bool CONST>
     bool run_encoded_array_iterator<CONST>::equal(const run_encoded_array_iterator& rhs) const
     {
         return m_index == rhs.m_index;
     }
 
-    template<bool CONST>
+    template <bool CONST>
     void run_encoded_array_iterator<CONST>::increment()
     {
         ++m_index;
         --m_runs_left;
-        if(m_runs_left == 0 && m_index < p_array->size())
+        if (m_runs_left == 0 && m_index < p_array->size())
         {
             ++m_run_end_index;
             m_runs_left = p_array->get_run_length(m_run_end_index);
         }
     }
 
-    template<bool CONST>
+    template <bool CONST>
     typename array_traits::const_reference run_encoded_array_iterator<CONST>::dereference() const
     {
         return array_element(*p_encoded_values_array, static_cast<std::size_t>(m_run_end_index));
     }
 
-} // namespace sparrow
+}  // namespace sparrow
diff --git a/include/sparrow/layout/struct_layout/struct_array.hpp b/include/sparrow/layout/struct_layout/struct_array.hpp
index 97067e5c..08b7761b 100644
--- a/include/sparrow/layout/struct_layout/struct_array.hpp
+++ b/include/sparrow/layout/struct_layout/struct_array.hpp
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include "sparrow/array_api.hpp"
 #include "sparrow/array_factory.hpp"
 #include "sparrow/arrow_array_schema_proxy.hpp"
 #include "sparrow/layout/array_bitmap_base.hpp"
@@ -24,7 +25,6 @@
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/memory.hpp"
 #include "sparrow/utils/nullable.hpp"
-#include "sparrow/array_api.hpp"
 
 namespace sparrow
 {
@@ -75,12 +75,12 @@ namespace sparrow
 
         explicit struct_array(arrow_proxy proxy);
 
-
-        template <class ... Args>
-        requires(mpl::excludes_copy_and_move_ctor_v<struct_array, Args...>)
-        explicit struct_array(Args&& ... args)
-            : struct_array(create_proxy(std::forward<Args>(args) ...))
-        {}
+        template <class... Args>
+            requires(mpl::excludes_copy_and_move_ctor_v<struct_array, Args...>)
+        explicit struct_array(Args&&... args)
+            : struct_array(create_proxy(std::forward<Args>(args)...))
+        {
+        }
 
         struct_array(const struct_array&);
         struct_array& operator=(const struct_array&);
@@ -94,10 +94,8 @@ namespace sparrow
     private:
 
         template <validity_bitmap_input VB = validity_bitmap>
-        static auto create_proxy(
-            std::vector<array> && children,
-            VB && bitmaps = validity_bitmap{}
-        ) -> arrow_proxy;
+        static auto create_proxy(std::vector<array>&& children, VB&& bitmaps = validity_bitmap{})
+            -> arrow_proxy;
 
         using children_type = std::vector<cloning_ptr<array_wrapper>>;
 
@@ -144,20 +142,17 @@ namespace sparrow
     }
 
     template <validity_bitmap_input VB>
-    auto struct_array::create_proxy(
-        std::vector<array> && children,
-        VB && validity_input
-    ) -> arrow_proxy
+    auto struct_array::create_proxy(std::vector<array>&& children, VB&& validity_input) -> arrow_proxy
     {
         const auto n_children = children.size();
         ArrowSchema** child_schemas = new ArrowSchema*[n_children];
         ArrowArray** child_arrays = new ArrowArray*[n_children];
 
         const auto size = children[0].size();
-        
-        for(std::size_t i=0; i<n_children; ++i)
+
+        for (std::size_t i = 0; i < n_children; ++i)
         {
-            auto & child = children[i];
+            auto& child = children[i];
             SPARROW_ASSERT_TRUE(child.size() == size);
             auto [flat_arr, flat_schema] = extract_arrow_structures(std::move(child));
             child_arrays[i] = new ArrowArray(std::move(flat_arr));
@@ -166,29 +161,27 @@ namespace sparrow
 
         validity_bitmap vbitmap = ensure_validity_bitmap(size, std::forward<VB>(validity_input));
         const auto null_count = vbitmap.null_count();
-        
+
         ArrowSchema schema = make_arrow_schema(
-            std::string("+s"), // format
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
+            std::string("+s"),  // format
+            std::nullopt,       // name
+            std::nullopt,       // metadata
+            std::nullopt,       // flags,
             static_cast<int64_t>(n_children),
-            child_schemas, // children
-            nullptr // dictionary
+            child_schemas,  // children
+            nullptr         // dictionary
         );
 
-        std::vector<buffer<std::uint8_t>> arr_buffs = {
-            std::move(vbitmap).extract_storage()
-        };
+        std::vector<buffer<std::uint8_t>> arr_buffs = {std::move(vbitmap).extract_storage()};
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<std::int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            static_cast<std::size_t>(n_children), // n_children
-            child_arrays, // children
-            nullptr // dictionary
+            static_cast<std::size_t>(n_children),  // n_children
+            child_arrays,                          // children
+            nullptr                                // dictionary
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
diff --git a/include/sparrow/layout/struct_layout/struct_value.hpp b/include/sparrow/layout/struct_layout/struct_value.hpp
index c2b2486d..4b89ea55 100644
--- a/include/sparrow/layout/struct_layout/struct_value.hpp
+++ b/include/sparrow/layout/struct_layout/struct_value.hpp
@@ -37,7 +37,7 @@ namespace sparrow
         const_reference operator[](size_type i) const;
 
     private:
-    
+
         const std::vector<child_ptr>* p_children = nullptr;
         size_type m_index = 0u;
     };
@@ -45,4 +45,3 @@ namespace sparrow
     SPARROW_API
     bool operator==(const struct_value& lhs, const struct_value& rhs);
 }
-
diff --git a/include/sparrow/layout/union_array.hpp b/include/sparrow/layout/union_array.hpp
index 0bd32b97..b897394f 100644
--- a/include/sparrow/layout/union_array.hpp
+++ b/include/sparrow/layout/union_array.hpp
@@ -14,40 +14,41 @@
 
 #pragma once
 
+#include "sparrow/array_api.hpp"
+#include "sparrow/array_factory.hpp"
 #include "sparrow/config/config.hpp"
+#include "sparrow/layout/array_access.hpp"
+#include "sparrow/layout/array_helper.hpp"
 #include "sparrow/layout/array_wrapper.hpp"
-#include "sparrow/array_factory.hpp"
 #include "sparrow/layout/layout_utils.hpp"
 #include "sparrow/layout/nested_value_types.hpp"
-#include "sparrow/utils/memory.hpp"
-#include "sparrow/layout/array_helper.hpp"
 #include "sparrow/utils/crtp_base.hpp"
 #include "sparrow/utils/functor_index_iterator.hpp"
-#include "sparrow/layout/array_access.hpp"
-#include "sparrow/array_api.hpp"
+#include "sparrow/utils/memory.hpp"
 
 namespace sparrow
-{   
+{
     class dense_union_array;
     class sparse_union_array;
 
     namespace detail
     {
-        template<class T>
+        template <class T>
         struct get_data_type_from_array;
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::dense_union_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::DENSE_UNION;
             }
         };
-        template<>
+
+        template <>
         struct get_data_type_from_array<sparrow::sparse_union_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::SPARSE_UNION;
             }
@@ -67,10 +68,10 @@ namespace sparrow
     constexpr bool is_sparse_union_array_v = std::same_as<T, sparse_union_array>;
 
     // helper crtp-base to have sparse and dense and dense union share most of their code
-    template<class DERIVED>
+    template <class DERIVED>
     class union_array_crtp_base : public crtp_base<DERIVED>
     {
-    public: 
+    public:
 
         using self_type = union_array_crtp_base<DERIVED>;
         using derived_type = DERIVED;
@@ -81,7 +82,7 @@ namespace sparrow
         using iterator = functor_index_iterator<functor_type>;
         using const_iterator = functor_index_iterator<const_functor_type>;
 
-        using type_id_buffer_type  = u8_buffer<std::uint8_t>;
+        using type_id_buffer_type = u8_buffer<std::uint8_t>;
 
         value_type operator[](std::size_t i) const;
         value_type operator[](std::size_t i);
@@ -104,7 +105,7 @@ namespace sparrow
         static type_id_map type_id_map_from_child_to_type_id(R&& child_index_to_type_id);
 
         template <std::ranges::input_range R>
-        requires(std::convertible_to<std::ranges::range_value_t<R>, std::uint8_t>)
+            requires(std::convertible_to<std::ranges::range_value_t<R>, std::uint8_t>)
         static std::string make_format_string(bool dense, std::size_t n, R&& child_index_to_type_id);
 
         using children_type = std::vector<cloning_ptr<array_wrapper>>;
@@ -122,14 +123,14 @@ namespace sparrow
         [[nodiscard]] const arrow_proxy& get_arrow_proxy() const;
 
         arrow_proxy m_proxy;
-        const std::uint8_t * p_type_ids;
+        const std::uint8_t* p_type_ids;
         children_type m_children;
 
         // map from type-id to child-index
         std::array<std::uint8_t, 256> m_type_id_map;
 
         friend class detail::array_access;
-    };  
+    };
 
     template <class D>
     bool operator==(const union_array_crtp_base<D>& lhs, const union_array_crtp_base<D>& rhs);
@@ -139,14 +140,15 @@ namespace sparrow
     public:
 
         using base_type = union_array_crtp_base<dense_union_array>;
-        using offset_buffer_type  = u8_buffer<std::uint32_t>;
-        using type_id_buffer_type  = typename base_type::type_id_buffer_type;
+        using offset_buffer_type = u8_buffer<std::uint32_t>;
+        using type_id_buffer_type = typename base_type::type_id_buffer_type;
 
-        template <class ... Args>
-        requires(mpl::excludes_copy_and_move_ctor_v<dense_union_array, Args...>)
-        explicit dense_union_array(Args&& ... args)
-            : dense_union_array(create_proxy(std::forward<Args>(args) ...))
-        {}
+        template <class... Args>
+            requires(mpl::excludes_copy_and_move_ctor_v<dense_union_array, Args...>)
+        explicit dense_union_array(Args&&... args)
+            : dense_union_array(create_proxy(std::forward<Args>(args)...))
+        {
+        }
 
         explicit dense_union_array(arrow_proxy proxy);
 
@@ -158,49 +160,47 @@ namespace sparrow
 
     private:
 
-        template <
-            std::ranges::input_range TYPE_MAPPING  = std::vector<std::uint8_t>
-        >
-        requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
+        template <std::ranges::input_range TYPE_MAPPING = std::vector<std::uint8_t>>
+            requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
         static auto create_proxy(
-            std::vector<array> && children,
-            type_id_buffer_type && element_type,    
-            offset_buffer_type && offsets,
-            TYPE_MAPPING && type_mapping = TYPE_MAPPING{}
+            std::vector<array>&& children,
+            type_id_buffer_type&& element_type,
+            offset_buffer_type&& offsets,
+            TYPE_MAPPING&& type_mapping = TYPE_MAPPING{}
         ) -> arrow_proxy;
 
         std::size_t element_offset(std::size_t i) const;
-        const std::int32_t *  p_offsets;
+        const std::int32_t* p_offsets;
         friend class union_array_crtp_base<dense_union_array>;
     };
 
     class sparse_union_array : public union_array_crtp_base<sparse_union_array>
     {
     public:
-        
+
         using base_type = union_array_crtp_base<sparse_union_array>;
-        using type_id_buffer_type  = typename base_type::type_id_buffer_type;
+        using type_id_buffer_type = typename base_type::type_id_buffer_type;
 
-        template <class ... Args>
-        requires(mpl::excludes_copy_and_move_ctor_v<sparse_union_array, Args...>)
-        explicit sparse_union_array(Args&& ... args)
-            : sparse_union_array(create_proxy(std::forward<Args>(args) ...))
-        {}
+        template <class... Args>
+            requires(mpl::excludes_copy_and_move_ctor_v<sparse_union_array, Args...>)
+        explicit sparse_union_array(Args&&... args)
+            : sparse_union_array(create_proxy(std::forward<Args>(args)...))
+        {
+        }
 
         explicit sparse_union_array(arrow_proxy proxy);
 
-        template <
-            std::ranges::input_range TYPE_MAPPING  = std::vector<std::uint8_t>
-        >
-        requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
+        template <std::ranges::input_range TYPE_MAPPING = std::vector<std::uint8_t>>
+            requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
         static auto create_proxy(
-            std::vector<array> && children,
-            type_id_buffer_type && element_type,
-            TYPE_MAPPING && type_mapping = TYPE_MAPPING{}
+            std::vector<array>&& children,
+            type_id_buffer_type&& element_type,
+            TYPE_MAPPING&& type_mapping = TYPE_MAPPING{}
         ) -> arrow_proxy;
 
 
     private:
+
         std::size_t element_offset(std::size_t i) const;
         friend class union_array_crtp_base<sparse_union_array>;
     };
@@ -210,34 +210,39 @@ namespace sparrow
     {
         type_id_map ret;
         // remove +du: / +su: prefix
-        format_string.remove_prefix(4); 
- 
-        constexpr std::string_view delim { "," };
-        std::size_t child_index = 0;    
-        std::ranges::for_each(format_string | std::views::split(delim), [&](const auto& s) { 
-            const auto as_int = std::atoi(std::string(s.begin(), s.end()).c_str());
-            ret[static_cast<std::size_t>(as_int)] = static_cast<std::uint8_t>(child_index);
-            ++child_index;
-        });
+        format_string.remove_prefix(4);
+
+        constexpr std::string_view delim{","};
+        std::size_t child_index = 0;
+        std::ranges::for_each(
+            format_string | std::views::split(delim),
+            [&](const auto& s)
+            {
+                const auto as_int = std::atoi(std::string(s.begin(), s.end()).c_str());
+                ret[static_cast<std::size_t>(as_int)] = static_cast<std::uint8_t>(child_index);
+                ++child_index;
+            }
+        );
         return ret;
     }
 
     template <class DERIVED>
     template <std::ranges::input_range R>
-    auto union_array_crtp_base<DERIVED>::type_id_map_from_child_to_type_id(R&& child_index_to_type_id) ->type_id_map
+    auto union_array_crtp_base<DERIVED>::type_id_map_from_child_to_type_id(R&& child_index_to_type_id)
+        -> type_id_map
     {
         const std::size_t n = std::ranges::size(child_index_to_type_id);
         std::array<std::uint8_t, 256> ret;
-        if(n == 0)
+        if (n == 0)
         {
-            for(std::size_t i = 0; i < 256; ++i)
+            for (std::size_t i = 0; i < 256; ++i)
             {
                 ret[i] = static_cast<std::uint8_t>(i);
             }
         }
         else
         {
-            for(std::size_t i = 0; i < n; ++i)
+            for (std::size_t i = 0; i < n; ++i)
             {
                 ret[child_index_to_type_id[i]] = static_cast<std::uint8_t>(i);
             }
@@ -247,16 +252,16 @@ namespace sparrow
 
     template <class DERIVED>
     template <std::ranges::input_range R>
-    requires(std::convertible_to<std::ranges::range_value_t<R>, std::uint8_t>)
+        requires(std::convertible_to<std::ranges::range_value_t<R>, std::uint8_t>)
     std::string union_array_crtp_base<DERIVED>::make_format_string(bool dense, const std::size_t n, R&& range)
-    {   
+    {
         const auto range_size = std::ranges::size(range);
-        if(range_size == n || range_size == 0)
-        {   
+        if (range_size == n || range_size == 0)
+        {
             std::string ret = dense ? "+ud:" : "+us:";
-            if(range_size == 0)
+            if (range_size == 0)
             {
-                for(std::size_t i = 0; i < n; ++i)
+                for (std::size_t i = 0; i < n; ++i)
                 {
                     ret += std::to_string(i) + ",";
                 }
@@ -269,7 +274,7 @@ namespace sparrow
                 }
             }
             ret.pop_back();
-            return ret;       
+            return ret;
         }
         else
         {
@@ -277,7 +282,6 @@ namespace sparrow
         }
     }
 
-
     /****************************************
      * union_array_crtp_base implementation *
      ****************************************/
@@ -297,7 +301,7 @@ namespace sparrow
     template <class DERIVED>
     union_array_crtp_base<DERIVED>::union_array_crtp_base(arrow_proxy proxy)
         : m_proxy(std::move(proxy))
-        , p_type_ids(reinterpret_cast<std::uint8_t*>(m_proxy.buffers()[0/*index of type-ids*/].data()))
+        , p_type_ids(reinterpret_cast<std::uint8_t*>(m_proxy.buffers()[0 /*index of type-ids*/].data()))
         , m_children(make_children(m_proxy))
         , m_type_id_map(parse_type_id_map(m_proxy.format()))
     {
@@ -315,7 +319,7 @@ namespace sparrow
         if (this != &rhs)
         {
             m_proxy = rhs.m_proxy;
-            p_type_ids = reinterpret_cast<std::uint8_t*>(m_proxy.buffers()[0/*index of type-ids*/].data());
+            p_type_ids = reinterpret_cast<std::uint8_t*>(m_proxy.buffers()[0 /*index of type-ids*/].data());
             m_children = make_children(m_proxy);
             m_type_id_map = parse_type_id_map(m_proxy.format());
         }
@@ -324,7 +328,7 @@ namespace sparrow
 
     template <class DERIVED>
     auto union_array_crtp_base<DERIVED>::operator[](std::size_t i) const -> value_type
-    {   
+    {
         const auto type_id = static_cast<std::size_t>(p_type_ids[i]);
         const auto child_index = m_type_id_map[type_id];
         const auto offset = this->derived_cast().element_offset(i);
@@ -333,7 +337,7 @@ namespace sparrow
 
     template <class DERIVED>
     auto union_array_crtp_base<DERIVED>::operator[](std::size_t i) -> value_type
-    {   
+    {
         return static_cast<const derived_type&>(*this)[i];
     }
 
@@ -356,25 +360,25 @@ namespace sparrow
     }
 
     template <class DERIVED>
-    auto union_array_crtp_base<DERIVED>::begin() const -> const_iterator    
+    auto union_array_crtp_base<DERIVED>::begin() const -> const_iterator
     {
         return cbegin();
     }
 
     template <class DERIVED>
-    auto union_array_crtp_base<DERIVED>::end() const -> const_iterator   
+    auto union_array_crtp_base<DERIVED>::end() const -> const_iterator
     {
         return cend();
     }
 
     template <class DERIVED>
-    auto union_array_crtp_base<DERIVED>::cbegin() const -> const_iterator   
+    auto union_array_crtp_base<DERIVED>::cbegin() const -> const_iterator
     {
         return const_iterator(const_functor_type{&(this->derived_cast())}, 0);
     }
 
     template <class DERIVED>
-    auto union_array_crtp_base<DERIVED>::cend() const  -> const_iterator
+    auto union_array_crtp_base<DERIVED>::cend() const -> const_iterator
     {
         return const_iterator(const_functor_type{&(this->derived_cast())}, this->size());
     }
@@ -400,13 +404,13 @@ namespace sparrow
      * dense_union_array implementation *
      ************************************/
 
-    #ifdef __GNUC__
-    #    pragma GCC diagnostic push
-    #    pragma GCC diagnostic ignored "-Wcast-align"
-    #endif
+#ifdef __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wcast-align"
+#endif
     inline dense_union_array::dense_union_array(arrow_proxy proxy)
         : base_type(std::move(proxy))
-        , p_offsets(reinterpret_cast<std::int32_t*>(m_proxy.buffers()[1/*index of offsets*/].data()))
+        , p_offsets(reinterpret_cast<std::int32_t*>(m_proxy.buffers()[1 /*index of offsets*/].data()))
     {
     }
 
@@ -417,23 +421,21 @@ namespace sparrow
 
     inline dense_union_array& dense_union_array::operator=(const dense_union_array& rhs)
     {
-        if (this !=&rhs)
+        if (this != &rhs)
         {
             base_type::operator=(rhs);
-            p_offsets = reinterpret_cast<std::int32_t*>(m_proxy.buffers()[1/*index of offsets*/].data());
+            p_offsets = reinterpret_cast<std::int32_t*>(m_proxy.buffers()[1 /*index of offsets*/].data());
         }
         return *this;
     }
 
-    template <
-        std::ranges::input_range TYPE_MAPPING
-    >
-    requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
+    template <std::ranges::input_range TYPE_MAPPING>
+        requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
     auto dense_union_array::create_proxy(
-        std::vector<array> && children,
-        type_id_buffer_type && element_type,    
-        offset_buffer_type && offsets,
-        TYPE_MAPPING && child_index_to_type_id
+        std::vector<array>&& children,
+        type_id_buffer_type&& element_type,
+        offset_buffer_type&& offsets,
+        TYPE_MAPPING&& child_index_to_type_id
     ) -> arrow_proxy
     {
         const auto n_children = children.size();
@@ -446,7 +448,7 @@ namespace sparrow
 
         // count nulls (expensive!)
         int64_t null_count = 0;
-        for(std::size_t i = 0; i < size; ++i)
+        for (std::size_t i = 0; i < size; ++i)
         {
             // child_id from type_id
             const auto type_id = static_cast<std::uint8_t>(element_type[i]);
@@ -459,24 +461,28 @@ namespace sparrow
             }
         }
 
-        for(std::size_t i=0; i<n_children; ++i)
+        for (std::size_t i = 0; i < n_children; ++i)
         {
-            auto & child = children[i];
+            auto& child = children[i];
             auto [flat_arr, flat_schema] = extract_arrow_structures(std::move(child));
             child_arrays[i] = new ArrowArray(std::move(flat_arr));
             child_schemas[i] = new ArrowSchema(std::move(flat_schema));
         }
 
-        std::string format = make_format_string(true /*dense union*/, n_children, std::forward<TYPE_MAPPING>(child_index_to_type_id));
-        
+        std::string format = make_format_string(
+            true /*dense union*/,
+            n_children,
+            std::forward<TYPE_MAPPING>(child_index_to_type_id)
+        );
+
         ArrowSchema schema = make_arrow_schema(
             format,
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
+            std::nullopt,  // name
+            std::nullopt,  // metadata
+            std::nullopt,  // flags,
             static_cast<int64_t>(n_children),
-            child_schemas, // children
-            nullptr // dictionary
+            child_schemas,  // children
+            nullptr         // dictionary
         );
 
         std::vector<buffer<std::uint8_t>> arr_buffs = {
@@ -485,20 +491,20 @@ namespace sparrow
         };
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<std::int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            static_cast<std::size_t>(n_children), // n_children
-            child_arrays, // children
-            nullptr // dictionary
+            static_cast<std::size_t>(n_children),  // n_children
+            child_arrays,                          // children
+            nullptr                                // dictionary
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
 
-    #ifdef __GNUC__
-    #    pragma GCC diagnostic pop
-    #endif
+#ifdef __GNUC__
+#    pragma GCC diagnostic pop
+#endif
 
     inline std::size_t dense_union_array::element_offset(std::size_t i) const
     {
@@ -514,14 +520,12 @@ namespace sparrow
     {
     }
 
-    template <
-        std::ranges::input_range TYPE_MAPPING
-    >
-    requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
+    template <std::ranges::input_range TYPE_MAPPING>
+        requires(std::convertible_to<std::ranges::range_value_t<TYPE_MAPPING>, std::uint8_t>)
     auto sparse_union_array::create_proxy(
-        std::vector<array> && children,
-        type_id_buffer_type && element_type,
-        TYPE_MAPPING && child_index_to_type_id
+        std::vector<array>&& children,
+        type_id_buffer_type&& element_type,
+        TYPE_MAPPING&& child_index_to_type_id
     ) -> arrow_proxy
     {
         const auto n_children = children.size();
@@ -534,7 +538,7 @@ namespace sparrow
 
         // count nulls (expensive!)
         int64_t null_count = 0;
-        for(std::size_t i = 0; i < size; ++i)
+        for (std::size_t i = 0; i < size; ++i)
         {
             // child_id from type_id
             const auto type_id = static_cast<std::uint8_t>(element_type[i]);
@@ -546,38 +550,40 @@ namespace sparrow
             }
         }
 
-        for(std::size_t i=0; i<n_children; ++i)
+        for (std::size_t i = 0; i < n_children; ++i)
         {
-            auto & child = children[i];
+            auto& child = children[i];
             auto [flat_arr, flat_schema] = extract_arrow_structures(std::move(child));
             child_arrays[i] = new ArrowArray(std::move(flat_arr));
             child_schemas[i] = new ArrowSchema(std::move(flat_schema));
         }
 
-        std::string format = make_format_string(false /*is dense union*/, n_children, std::forward<TYPE_MAPPING>(child_index_to_type_id));
+        std::string format = make_format_string(
+            false /*is dense union*/,
+            n_children,
+            std::forward<TYPE_MAPPING>(child_index_to_type_id)
+        );
 
         ArrowSchema schema = make_arrow_schema(
             format,
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
+            std::nullopt,  // name
+            std::nullopt,  // metadata
+            std::nullopt,  // flags,
             static_cast<int64_t>(n_children),
-            child_schemas, // children
-            nullptr // dictionary
+            child_schemas,  // children
+            nullptr         // dictionary
         );
 
-        std::vector<buffer<std::uint8_t>> arr_buffs = {
-            std::move(element_type).extract_storage()
-        };
+        std::vector<buffer<std::uint8_t>> arr_buffs = {std::move(element_type).extract_storage()};
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<std::int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            static_cast<std::size_t>(n_children), // n_children
-            child_arrays, // children
-            nullptr // dictionary
+            static_cast<std::size_t>(n_children),  // n_children
+            child_arrays,                          // children
+            nullptr                                // dictionary
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
diff --git a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp
index 2e18f15d..83f6e6e2 100644
--- a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp
+++ b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp
@@ -300,7 +300,8 @@ namespace sparrow
 
     template <std::ranges::sized_range T, class CR, layout_offset OT>
     template <std::ranges::range SIZES_RANGE>
-    auto variable_size_binary_array_impl<T, CR, OT>::offset_from_sizes(SIZES_RANGE&& sizes) -> offset_buffer_type
+    auto variable_size_binary_array_impl<T, CR, OT>::offset_from_sizes(SIZES_RANGE&& sizes)
+        -> offset_buffer_type
     {
         return detail::offset_buffer_from_sizes<std::remove_const_t<offset_type>>(std::forward<SIZES_RANGE>(sizes
         ));
@@ -376,19 +377,19 @@ namespace sparrow
     {
         // split into values and is_non_null ranges
         const auto values = range
-                      | std::views::transform(
-                          [](const auto& v)
-                          {
-                              return v.get();
-                          }
-                      );
+                            | std::views::transform(
+                                [](const auto& v)
+                                {
+                                    return v.get();
+                                }
+                            );
         const auto is_non_null = range
-                           | std::views::transform(
-                               [](const auto& v)
-                               {
-                                   return v.has_value();
-                               }
-                           );
+                                 | std::views::transform(
+                                     [](const auto& v)
+                                     {
+                                         return v.has_value();
+                                     }
+                                 );
         return self_type::create_proxy(values, is_non_null);
     }
 
diff --git a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_iterator.hpp b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_iterator.hpp
index 6980b9f8..934b0273 100644
--- a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_iterator.hpp
+++ b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_iterator.hpp
@@ -114,8 +114,8 @@ namespace sparrow
     }
 
     template <class Layout, iterator_types Iterator_types>
-    auto variable_size_binary_value_iterator<Layout, Iterator_types>::distance_to(const self_type& rhs
-    ) const -> difference_type
+    auto variable_size_binary_value_iterator<Layout, Iterator_types>::distance_to(const self_type& rhs) const
+        -> difference_type
     {
         return rhs.m_index - m_index;
     }
diff --git a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_reference.hpp b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_reference.hpp
index 6ca1914e..48afcbb4 100644
--- a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_reference.hpp
+++ b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_reference.hpp
@@ -225,4 +225,3 @@ namespace sparrow
         return static_cast<size_type>(offset(index));
     }
 }
-
diff --git a/include/sparrow/layout/variable_size_binary_view_array.hpp b/include/sparrow/layout/variable_size_binary_view_array.hpp
index a39c201e..75b26e06 100644
--- a/include/sparrow/layout/variable_size_binary_view_array.hpp
+++ b/include/sparrow/layout/variable_size_binary_view_array.hpp
@@ -17,18 +17,17 @@
 #include <cstddef>
 #include <ranges>
 
+#include "sparrow/arrow_array_schema_proxy.hpp"
 #include "sparrow/arrow_interface/arrow_array.hpp"
 #include "sparrow/arrow_interface/arrow_schema.hpp"
-#include "sparrow/utils/functor_index_iterator.hpp"
-#include "sparrow/arrow_interface/arrow_schema.hpp"
-#include "sparrow/arrow_array_schema_proxy.hpp"
+#include "sparrow/buffer/dynamic_bitset.hpp"
+#include "sparrow/buffer/u8_buffer.hpp"
+#include "sparrow/layout/array_access.hpp"
 #include "sparrow/layout/array_bitmap_base.hpp"
 #include "sparrow/layout/layout_utils.hpp"
+#include "sparrow/utils/functor_index_iterator.hpp"
 #include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/nullable.hpp"
-#include "sparrow/layout/array_access.hpp"
-#include "sparrow/buffer/dynamic_bitset.hpp"
-#include "sparrow/buffer/u8_buffer.hpp"
 #include "sparrow/utils/ranges.hpp"
 
 namespace sparrow
@@ -42,21 +41,22 @@ namespace sparrow
 
     namespace detail
     {
-        template<class T>
+        template <class T>
         struct get_data_type_from_array;
 
-        template<>
+        template <>
         struct get_data_type_from_array<sparrow::string_view_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::STRING_VIEW;
             }
         };
-        template<>
+
+        template <>
         struct get_data_type_from_array<sparrow::binary_view_array>
         {
-            constexpr static sparrow::data_type get()
+            static constexpr sparrow::data_type get()
             {
                 return sparrow::data_type::BINARY_VIEW;
             }
@@ -70,7 +70,7 @@ namespace sparrow
         using inner_value_type = T;
         using inner_reference = T;
         using inner_const_reference = inner_reference;
-    
+
         using value_iterator = functor_index_iterator<detail::layout_value_functor<array_type, inner_value_type>>;
         using const_value_iterator = functor_index_iterator<
             detail::layout_value_functor<const array_type, inner_reference>>;
@@ -94,7 +94,8 @@ namespace sparrow
     constexpr bool is_variable_size_binary_view_array = is_variable_size_binary_view_array_impl<T>::value;
 
     template <class T>
-    class variable_size_binary_view_array_impl final : public mutable_array_bitmap_base<variable_size_binary_view_array_impl<T>>
+    class variable_size_binary_view_array_impl final
+        : public mutable_array_bitmap_base<variable_size_binary_view_array_impl<T>>
     {
     public:
 
@@ -130,17 +131,17 @@ namespace sparrow
 
         explicit variable_size_binary_view_array_impl(arrow_proxy);
 
-        template <class ... Args>
-        requires(mpl::excludes_copy_and_move_ctor_v<variable_size_binary_view_array_impl<T>, Args...>)
-        explicit variable_size_binary_view_array_impl(Args&& ... args)
-            : variable_size_binary_view_array_impl(create_proxy(std::forward<Args>(args) ...))
+        template <class... Args>
+            requires(mpl::excludes_copy_and_move_ctor_v<variable_size_binary_view_array_impl<T>, Args...>)
+        explicit variable_size_binary_view_array_impl(Args&&... args)
+            : variable_size_binary_view_array_impl(create_proxy(std::forward<Args>(args)...))
         {
         }
 
     private:
 
-        template<std::ranges::input_range R, validity_bitmap_input VB = validity_bitmap >
-        requires std::convertible_to<std::ranges::range_value_t<R>, T>
+        template <std::ranges::input_range R, validity_bitmap_input VB = validity_bitmap>
+            requires std::convertible_to<std::ranges::range_value_t<R>, T>
         static arrow_proxy create_proxy(R&& range, VB&& bitmap_input = validity_bitmap{});
 
         inner_reference value(size_type i);
@@ -161,11 +162,10 @@ namespace sparrow
         static constexpr std::ptrdiff_t BUFFER_INDEX_OFFSET = 8;
         static constexpr std::ptrdiff_t BUFFER_OFFSET_OFFSET = 12;
         static constexpr std::size_t FIRST_VAR_DATA_BUFFER_INDEX = 2;
-        
+
 
         friend base_type;
         friend base_type::base_type;
-
     };
 
     template <class T>
@@ -175,32 +175,32 @@ namespace sparrow
     }
 
     template <class T>
-    template<std::ranges::input_range R, validity_bitmap_input VB >
-    requires std::convertible_to<std::ranges::range_value_t<R>, T>
-    arrow_proxy variable_size_binary_view_array_impl<T>::create_proxy(
-        R && range,
-        VB && validity_input
-    )
-    {    
-   
-        #ifdef __GNUC__
-        #    pragma GCC diagnostic push
-        #    pragma GCC diagnostic ignored "-Wcast-align"
-        #endif
+    template <std::ranges::input_range R, validity_bitmap_input VB>
+        requires std::convertible_to<std::ranges::range_value_t<R>, T>
+    arrow_proxy variable_size_binary_view_array_impl<T>::create_proxy(R&& range, VB&& validity_input)
+    {
+#ifdef __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wcast-align"
+#endif
 
         const auto size = range_size(range);
         validity_bitmap vbitmap = ensure_validity_bitmap(size, std::forward<VB>(validity_input));
         const auto null_count = vbitmap.null_count();
 
         buffer<uint8_t> length_buffer(size * DATA_BUFFER_SIZE);
-          
+
         std::size_t long_string_storage_size = 0;
         std::size_t i = 0;
-        for(auto && val : range)
-        {   
-            auto val_casted = val | std::ranges::views::transform([](const auto& v) { 
-                return static_cast<std::uint8_t>(v);
-            });
+        for (auto&& val : range)
+        {
+            auto val_casted = val
+                              | std::ranges::views::transform(
+                                  [](const auto& v)
+                                  {
+                                      return static_cast<std::uint8_t>(v);
+                                  }
+                              );
 
             const auto length = val.size();
             auto length_ptr = length_buffer.data() + (i * DATA_BUFFER_SIZE);
@@ -208,7 +208,7 @@ namespace sparrow
             // write length
             *reinterpret_cast<std::int32_t*>(length_ptr) = static_cast<std::int32_t>(length);
 
-            if(length <= SHORT_STRING_SIZE)
+            if (length <= SHORT_STRING_SIZE)
             {
                 // write data itself
                 std::ranges::copy(val_casted, length_ptr + SHORT_STRING_OFFSET);
@@ -220,49 +220,60 @@ namespace sparrow
                 std::ranges::copy(prefix_sub_range, length_ptr + PREFIX_OFFSET);
 
                 // write the buffer index
-                *reinterpret_cast<std::int32_t*>(length_ptr +  BUFFER_INDEX_OFFSET) = static_cast<std::int32_t>(FIRST_VAR_DATA_BUFFER_INDEX);
+                *reinterpret_cast<std::int32_t*>(
+                    length_ptr + BUFFER_INDEX_OFFSET
+                ) = static_cast<std::int32_t>(FIRST_VAR_DATA_BUFFER_INDEX);
 
                 // write the buffer offset
-                *reinterpret_cast<std::int32_t*>(length_ptr + BUFFER_OFFSET_OFFSET) = static_cast<std::int32_t>(long_string_storage_size);
- 
+                *reinterpret_cast<std::int32_t*>(
+                    length_ptr + BUFFER_OFFSET_OFFSET
+                ) = static_cast<std::int32_t>(long_string_storage_size);
+
                 // count the size of the long string storage
                 long_string_storage_size += length;
             }
             ++i;
-        } 
+        }
 
         // write the long string storage
         buffer<uint8_t> long_string_storage(long_string_storage_size);
         std::size_t long_string_storage_offset = 0;
-        for(auto && val : range)
+        for (auto&& val : range)
         {
             const auto length = val.size();
-            if(length > SHORT_STRING_SIZE)
+            if (length > SHORT_STRING_SIZE)
             {
-                auto val_casted = val | std::ranges::views::transform([](const auto& v) { 
-                    return static_cast<std::uint8_t>(v);
-                });
+                auto val_casted = val
+                                  | std::ranges::views::transform(
+                                      [](const auto& v)
+                                      {
+                                          return static_cast<std::uint8_t>(v);
+                                      }
+                                  );
 
                 std::ranges::copy(val_casted, long_string_storage.data() + long_string_storage_offset);
                 long_string_storage_offset += length;
             }
         }
 
-        // For binary or utf-8 view arrays, an extra buffer is appended which stores 
-        // the lengths of each variadic data buffer as int64_t. 
+        // For binary or utf-8 view arrays, an extra buffer is appended which stores
+        // the lengths of each variadic data buffer as int64_t.
         // This buffer is necessary since these buffer lengths are not trivially
         // extractable from other data in an array of binary or utf-8 view type.
-        u8_buffer<int64_t> buffer_sizes(static_cast<std::size_t>(1), static_cast<int64_t>(long_string_storage_size));
+        u8_buffer<int64_t> buffer_sizes(
+            static_cast<std::size_t>(1),
+            static_cast<int64_t>(long_string_storage_size)
+        );
 
         // create arrow schema and array
         ArrowSchema schema = make_arrow_schema(
             std::is_same<T, std::string_view>::value ? std::string_view("vu") : std::string_view("vz"),
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags
-            0, // n_children
-            nullptr, // children
-            nullptr // dictionary
+            std::nullopt,  // name
+            std::nullopt,  // metadata
+            std::nullopt,  // flags
+            0,             // n_children
+            nullptr,       // children
+            nullptr        // dictionary
         );
 
         std::vector<buffer<uint8_t>> buffers{
@@ -274,21 +285,20 @@ namespace sparrow
 
         // create arrow array
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(size), // length
+            static_cast<std::int64_t>(size),  // length
             static_cast<int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(buffers),
-            0, // n_children
-            nullptr, // children
-            nullptr // dictionary
+            0,        // n_children
+            nullptr,  // children
+            nullptr   // dictionary
         );
-        
-        return arrow_proxy{std::move(arr), std::move(schema)};
 
-        #ifdef __GNUC__
-        #    pragma GCC diagnostic pop
-        #endif
+        return arrow_proxy{std::move(arr), std::move(schema)};
 
+#ifdef __GNUC__
+#    pragma GCC diagnostic pop
+#endif
     }
 
     template <class T>
@@ -300,39 +310,44 @@ namespace sparrow
     template <class T>
     auto variable_size_binary_view_array_impl<T>::value(size_type i) const -> inner_const_reference
     {
-        #ifdef __GNUC__
-        #    pragma GCC diagnostic push
-        #    pragma GCC diagnostic ignored "-Wcast-align"
-        #endif
+#ifdef __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wcast-align"
+#endif
 
         SPARROW_ASSERT_TRUE(i < this->size());
 
         constexpr std::size_t element_size = 16;
-        auto data_ptr = this->get_arrow_proxy().buffers()[LENGTH_BUFFER_INDEX].template data<uint8_t>() + (i * element_size);
+        auto data_ptr = this->get_arrow_proxy().buffers()[LENGTH_BUFFER_INDEX].template data<uint8_t>()
+                        + (i * element_size);
 
         auto length = static_cast<std::size_t>(*reinterpret_cast<const std::int32_t*>(data_ptr));
         using char_or_byte = typename inner_const_reference::value_type;
 
-        if(length <= 12)
+        if (length <= 12)
         {
             constexpr std::ptrdiff_t data_offset = 4;
             auto ptr = reinterpret_cast<const char_or_byte*>(data_ptr);
-            const auto ret =  inner_const_reference(ptr + data_offset, length);
+            const auto ret = inner_const_reference(ptr + data_offset, length);
             return ret;
         }
         else
         {
             constexpr std::ptrdiff_t buffer_index_offset = 8;
             constexpr std::ptrdiff_t buffer_offset_offset = 12;
-            auto buffer_index = static_cast<std::size_t>(*reinterpret_cast<const std::int32_t*>(data_ptr + buffer_index_offset));
-            auto buffer_offset = static_cast<std::size_t>(*reinterpret_cast<const std::int32_t*>(data_ptr + buffer_offset_offset));
+            auto buffer_index = static_cast<std::size_t>(
+                *reinterpret_cast<const std::int32_t*>(data_ptr + buffer_index_offset)
+            );
+            auto buffer_offset = static_cast<std::size_t>(
+                *reinterpret_cast<const std::int32_t*>(data_ptr + buffer_offset_offset)
+            );
             auto buffer = this->get_arrow_proxy().buffers()[buffer_index].template data<const char_or_byte>();
-            return inner_const_reference(buffer + buffer_offset,  length);
+            return inner_const_reference(buffer + buffer_offset, length);
         }
 
-        #ifdef __GNUC__
-        #    pragma GCC diagnostic pop
-        #endif
+#ifdef __GNUC__
+#    pragma GCC diagnostic pop
+#endif
     }
 
     template <class T>
@@ -344,18 +359,13 @@ namespace sparrow
     template <class T>
     auto variable_size_binary_view_array_impl<T>::value_end() -> value_iterator
     {
-        return value_iterator(
-            detail::layout_value_functor<self_type, inner_value_type>(this), this->size()
-        );
+        return value_iterator(detail::layout_value_functor<self_type, inner_value_type>(this), this->size());
     }
 
     template <class T>
     auto variable_size_binary_view_array_impl<T>::value_cbegin() const -> const_value_iterator
     {
-        return const_value_iterator(
-            detail::layout_value_functor<const self_type, inner_value_type>(this),
-            0
-        );
+        return const_value_iterator(detail::layout_value_functor<const self_type, inner_value_type>(this), 0);
     }
 
     template <class T>
diff --git a/include/sparrow/record_batch.hpp b/include/sparrow/record_batch.hpp
index c6f3e75e..0835079c 100644
--- a/include/sparrow/record_batch.hpp
+++ b/include/sparrow/record_batch.hpp
@@ -96,7 +96,8 @@ namespace sparrow
 
         /**
          * @returns the name mapped to the column at the given index.
-         * @param index The index of the column in the \ref record_batch. The index must be less than the number of columns.
+         * @param index The index of the column in the \ref record_batch. The index must be less than the
+         * number of columns.
          */
         SPARROW_API const name_type& get_column_name(size_type index) const;
 
diff --git a/include/sparrow/types/data_traits.hpp b/include/sparrow/types/data_traits.hpp
index 25341162..07681ae8 100644
--- a/include/sparrow/types/data_traits.hpp
+++ b/include/sparrow/types/data_traits.hpp
@@ -45,7 +45,6 @@ namespace sparrow
         static constexpr data_type type_id = data_type_from_size<T>();
     };
 
-
     template <>
     struct arrow_traits<std::string>
     {
@@ -117,8 +116,7 @@ namespace sparrow
         using value_type = decimal<int256_t>;
         using const_reference = decimal<int256_t>;
     };
-    
-    
+
     namespace detail
     {
         template <class T>
@@ -140,24 +138,17 @@ namespace sparrow
             mpl::rename<all_base_types_t, std::variant>;
         // std::variant can not hold references, we need to write something based on variant and
         // reference_wrapper
-        //using inner_const_reference = /* std::variant<null_type, const bool&, const suint8_t&, ....> */
+        // using inner_const_reference = /* std::variant<null_type, const bool&, const suint8_t&, ....> */
         /*    mpl::rename<
                 mpl::transform<
                     detail::array_inner_const_reference_t,
                     all_base_types_t>,
                 std::variant>;*/
         using value_type = /* nullable_variant<nullable<null_type>, nullable<bool>, nullable<uint8_t>, ...> */
-            mpl::rename<
-                mpl::transform<
-                    detail::array_value_type_t,
-                    all_base_types_t>,
-                nullable_variant>;
-        using const_reference = /* nullable_variant<nullable<null_type>, nullable<const bool&>, nullable<const uint8_t&>, ...> */
-            mpl::rename<
-                mpl::transform<
-                    detail::array_const_reference_t,
-                    all_base_types_t>,
-                nullable_variant>; 
+            mpl::rename<mpl::transform<detail::array_value_type_t, all_base_types_t>, nullable_variant>;
+        using const_reference = /* nullable_variant<nullable<null_type>, nullable<const bool&>, nullable<const
+                                   uint8_t&>, ...> */
+            mpl::rename<mpl::transform<detail::array_const_reference_t, all_base_types_t>, nullable_variant>;
     };
 
     namespace predicate
diff --git a/include/sparrow/utils/bit.hpp b/include/sparrow/utils/bit.hpp
index d494363a..876bcd00 100644
--- a/include/sparrow/utils/bit.hpp
+++ b/include/sparrow/utils/bit.hpp
@@ -36,7 +36,7 @@ namespace sparrow
         std::ranges::reverse(value_representation);
         return std::bit_cast<T>(value_representation);
     }
-    
+
     template <std::endian input_value_endianess>
     constexpr auto to_native_endian(std::integral auto value) noexcept
     {
diff --git a/include/sparrow/utils/crtp_base.hpp b/include/sparrow/utils/crtp_base.hpp
index 0ac21d44..49ea7f5e 100644
--- a/include/sparrow/utils/crtp_base.hpp
+++ b/include/sparrow/utils/crtp_base.hpp
@@ -24,7 +24,7 @@ namespace sparrow
      *
      * @tparam D The derived type.
      */
-    template<class D>
+    template <class D>
     class crtp_base
     {
     protected:
@@ -35,13 +35,13 @@ namespace sparrow
         const derived_type& derived_cast() const;
     };
 
-    template<class D>
+    template <class D>
     auto crtp_base<D>::derived_cast() -> derived_type&
     {
         return static_cast<derived_type&>(*this);
     }
 
-    template<class D>
+    template <class D>
     auto crtp_base<D>::derived_cast() const -> const derived_type&
     {
         return static_cast<const derived_type&>(*this);
diff --git a/include/sparrow/utils/functor_index_iterator.hpp b/include/sparrow/utils/functor_index_iterator.hpp
index 9be14f94..710aaf65 100644
--- a/include/sparrow/utils/functor_index_iterator.hpp
+++ b/include/sparrow/utils/functor_index_iterator.hpp
@@ -14,18 +14,18 @@
 
 #pragma once
 
-#include "sparrow/utils/iterator.hpp"
 #include "sparrow/utils/contracts.hpp"
+#include "sparrow/utils/iterator.hpp"
 
 namespace sparrow
 {
-    template<class FUNCTOR>
+    template <class FUNCTOR>
     class functor_index_iterator : public iterator_base<
-        functor_index_iterator<FUNCTOR>,   // Derived
-        std::invoke_result_t<FUNCTOR, std::size_t>,  // Element
-        std::random_access_iterator_tag,
-        std::invoke_result_t<FUNCTOR, std::size_t>  // Reference
-    >
+                                       functor_index_iterator<FUNCTOR>,             // Derived
+                                       std::invoke_result_t<FUNCTOR, std::size_t>,  // Element
+                                       std::random_access_iterator_tag,
+                                       std::invoke_result_t<FUNCTOR, std::size_t>  // Reference
+                                       >
     {
     public:
 
@@ -35,13 +35,13 @@ namespace sparrow
         using size_type = std::size_t;
 
         constexpr functor_index_iterator() = default;
-        
+
         constexpr functor_index_iterator(FUNCTOR functor, size_type index)
             : m_functor(std::move(functor))
             , m_index(index)
         {
         }
-     
+
     private:
 
         result_type dereference() const
@@ -71,7 +71,7 @@ namespace sparrow
                 m_index -= static_cast<size_type>(-n);
             }
         }
-        
+
         difference_type distance_to(const self_type& rhs) const
         {
             return static_cast<difference_type>(rhs.m_index) - static_cast<difference_type>(m_index);
@@ -93,4 +93,3 @@ namespace sparrow
         friend class iterator_access;
     };
 }
-
diff --git a/include/sparrow/utils/iterator.hpp b/include/sparrow/utils/iterator.hpp
index 2d2a971d..ab3e8f9f 100644
--- a/include/sparrow/utils/iterator.hpp
+++ b/include/sparrow/utils/iterator.hpp
@@ -21,7 +21,7 @@
 #include <utility>
 
 namespace sparrow
-{   
+{
 
     namespace detail
     {
diff --git a/include/sparrow/utils/large_int.hpp b/include/sparrow/utils/large_int.hpp
index a1b6bde4..e4ec7083 100644
--- a/include/sparrow/utils/large_int.hpp
+++ b/include/sparrow/utils/large_int.hpp
@@ -3,19 +3,19 @@
 #ifndef SPARROW_USE_LARGE_INT_PLACEHOLDERS
 
 // disabe warnings -Wold-style-cast sign-conversion for clang and gcc
-#if defined(__clang__) || defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wold-style-cast"
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#pragma GCC diagnostic ignored "-Wshadow"
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
-#include <sparrow/details/3rdparty/large_integers/int128_t.hpp>
-#include <sparrow/details/3rdparty/large_integers/int256_t.hpp>
-
-#if defined(__clang__) || defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
+#    if defined(__clang__) || defined(__GNUC__)
+#        pragma GCC diagnostic push
+#        pragma GCC diagnostic ignored "-Wold-style-cast"
+#        pragma GCC diagnostic ignored "-Wsign-conversion"
+#        pragma GCC diagnostic ignored "-Wshadow"
+#        pragma GCC diagnostic ignored "-Wsign-conversion"
+#    endif
+#    include <sparrow/details/3rdparty/large_integers/int128_t.hpp>
+#    include <sparrow/details/3rdparty/large_integers/int256_t.hpp>
+
+#    if defined(__clang__) || defined(__GNUC__)
+#        pragma GCC diagnostic pop
+#    endif
 
 #endif
 
@@ -23,52 +23,57 @@
 
 namespace sparrow
 {
-    
 
-    #ifdef SPARROW_USE_LARGE_INT_PLACEHOLDERS
-    constexpr bool large_int_placeholders = true;
 
+#ifdef SPARROW_USE_LARGE_INT_PLACEHOLDERS
+    constexpr bool large_int_placeholders = true;
 
     struct int128_t
     {
         int128_t() = default;
 
         std::uint64_t words[2];
-        bool operator == (const int128_t& other) const
+
+        bool operator==(const int128_t& other) const
         {
             return words[0] == other.words[0] && words[1] == other.words[1];
         }
-        bool operator != (const int128_t& other) const
+
+        bool operator!=(const int128_t& other) const
         {
             return !(*this == other);
         }
     };
+
     struct int256_t
     {
         int256_t() = default;
         std::uint64_t words[4];
-        bool operator == (const int256_t& other) const
+
+        bool operator==(const int256_t& other) const
         {
-            return words[0] == other.words[0] && words[1] == other.words[1] && words[2] == other.words[2] && words[3] == other.words[3];
+            return words[0] == other.words[0] && words[1] == other.words[1] && words[2] == other.words[2]
+                   && words[3] == other.words[3];
         }
-        bool operator != (const int256_t& other) const
+
+        bool operator!=(const int256_t& other) const
         {
             return !(*this == other);
         }
     };
-    template<class T>
+    template <class T>
     constexpr bool is_int_placeholder_v = std::is_same_v<T, int128_t> || std::is_same_v<T, int256_t>;
 
-    #else 
-    
-    template<class T>
+#else
+
+    template <class T>
     constexpr bool is_int_placeholder_v = false;
     constexpr bool large_int_placeholders = false;
     using int128_t = primesum::int128_t;
     using int256_t = primesum::int256_t;
 
-    template<class T>
-    requires (std::is_same_v<T, int128_t> || std::is_same_v<T, int256_t>)
+    template <class T>
+        requires(std::is_same_v<T, int128_t> || std::is_same_v<T, int256_t>)
     inline std::ostream& operator<<(std::ostream& stream, T n)
     {
         std::string str;
@@ -93,5 +98,5 @@ namespace sparrow
 
         return stream;
     }
-    #endif
-} // namespace sparrow
\ No newline at end of file
+#endif
+}  // namespace sparrow
\ No newline at end of file
diff --git a/include/sparrow/utils/memory.hpp b/include/sparrow/utils/memory.hpp
index dbfa9bf6..cfcd6e6d 100644
--- a/include/sparrow/utils/memory.hpp
+++ b/include/sparrow/utils/memory.hpp
@@ -36,6 +36,7 @@ namespace sparrow
     class value_ptr
     {
         using internal_pointer = std::unique_ptr<T>;
+
     public:
 
         using self_type = value_ptr<T>;
@@ -81,7 +82,7 @@ namespace sparrow
 
         internal_pointer value_;
     };
-   
+
     namespace detail
     {
         template <class T>
@@ -107,17 +108,17 @@ namespace sparrow
      */
     template <class T>
     concept clonable = std::derived_from<T, std::decay_t<decltype(*std::declval<T*>()->clone())>>
-                    && detail::is_unique_ptr_v<decltype(std::declval<T*>()->clone())>;
+                       && detail::is_unique_ptr_v<decltype(std::declval<T*>()->clone())>;
 
     /**
      * Smart pointer behaving like a copiable std::unique_ptr.
-     * 
+     *
      * `cloning_ptr` owns and manages another object through a pointer, like
-     * `std::unique_ptr`. The difference with `std::unique_ptr` is that 
+     * `std::unique_ptr`. The difference with `std::unique_ptr` is that
      * `cloning_ptr`calls the `clone` method of the managed object upon copy.
      * `Therefore, `cloning_ptr` is meant to be used with hierarchies of
      * classes which provide a `clone` method which returns a unique pointer.
-     * 
+     *
      * @tparam T The type of the object managed by the `cloning_ptr`. It must
      * satisfy the `clonable` concept.
      */
@@ -125,6 +126,7 @@ namespace sparrow
     class cloning_ptr
     {
         using internal_pointer = std::unique_ptr<T>;
+
     public:
 
         using self_type = cloning_ptr<T>;
@@ -141,14 +143,14 @@ namespace sparrow
 
         constexpr cloning_ptr(const self_type& rhs) noexcept;
         constexpr cloning_ptr(self_type&& rhs) noexcept = default;
-        
+
 
         template <clonable U>
-        requires std::convertible_to<U*, T*>
+            requires std::convertible_to<U*, T*>
         constexpr cloning_ptr(const cloning_ptr<U>& rhs) noexcept;
 
         template <clonable U>
-        requires std::convertible_to<U*, T*>
+            requires std::convertible_to<U*, T*>
         constexpr cloning_ptr(cloning_ptr<U>&& rhs) noexcept;
 
         constexpr self_type& operator=(const self_type&) noexcept;
@@ -156,11 +158,11 @@ namespace sparrow
         constexpr self_type& operator=(std::nullptr_t) noexcept;
 
         template <clonable U>
-        requires std::convertible_to<U*, T*>
+            requires std::convertible_to<U*, T*>
         constexpr self_type& operator=(const cloning_ptr<U>& rhs) noexcept;
 
         template <clonable U>
-        requires std::convertible_to<U*, T*>
+            requires std::convertible_to<U*, T*>
         constexpr self_type& operator=(cloning_ptr<U>&& rhs) noexcept;
 
         // Modifiers
@@ -175,9 +177,8 @@ namespace sparrow
 
         constexpr explicit operator bool() const noexcept;
 
-        constexpr std::add_lvalue_reference_t<T>
-        operator*() const noexcept(noexcept(*std::declval<pointer>()));
-        
+        constexpr std::add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*std::declval<pointer>()));
+
         constexpr pointer operator->() const noexcept;
 
     private:
@@ -192,30 +193,20 @@ namespace sparrow
     void swap(cloning_ptr<T>& lhs, cloning_ptr<T>& rhs) noexcept;
 
     template <class T1, class T2>
-    requires std::equality_comparable_with<
-        typename cloning_ptr<T1>::pointer,
-        typename cloning_ptr<T2>::pointer>
-    constexpr
-    bool operator==(const cloning_ptr<T1>& lhs, const cloning_ptr<T2>& rhs) noexcept;
+        requires std::equality_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
+    constexpr bool operator==(const cloning_ptr<T1>& lhs, const cloning_ptr<T2>& rhs) noexcept;
 
     template <class T1, class T2>
-    requires std::three_way_comparable_with<
-        typename cloning_ptr<T1>::pointer,
-        typename cloning_ptr<T2>::pointer>
-    constexpr
-    std::compare_three_way_result_t<
-        typename cloning_ptr<T1>::pointer,
-        typename cloning_ptr<T2>::pointer>
+        requires std::three_way_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
+    constexpr std::compare_three_way_result_t<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
     operator<=>(const cloning_ptr<T1>& lhs, const cloning_ptr<T2>& rhs) noexcept;
 
     template <class T>
-    constexpr
-    bool operator==(const cloning_ptr<T>& lhs, std::nullptr_t) noexcept;
+    constexpr bool operator==(const cloning_ptr<T>& lhs, std::nullptr_t) noexcept;
 
     template <class T>
-    requires std::three_way_comparable<typename cloning_ptr<T>::pointer>
-    constexpr
-    std::compare_three_way_result_t<typename cloning_ptr<T>::pointer>
+        requires std::three_way_comparable<typename cloning_ptr<T>::pointer>
+    constexpr std::compare_three_way_result_t<typename cloning_ptr<T>::pointer>
     operator<=>(const cloning_ptr<T>& lhs, std::nullptr_t) noexcept;
 
     template <class T, class... Args>
@@ -358,15 +349,15 @@ namespace sparrow
 
     template <clonable T>
     template <clonable U>
-    requires std::convertible_to<U*, T*>
+        requires std::convertible_to<U*, T*>
     constexpr cloning_ptr<T>::cloning_ptr(const cloning_ptr<U>& rhs) noexcept
         : m_data(rhs ? rhs->clone() : nullptr)
     {
     }
-    
+
     template <clonable T>
     template <clonable U>
-    requires std::convertible_to<U*, T*>
+        requires std::convertible_to<U*, T*>
     constexpr cloning_ptr<T>::cloning_ptr(cloning_ptr<U>&& rhs) noexcept
         : m_data(rhs.release())
     {
@@ -388,7 +379,7 @@ namespace sparrow
 
     template <clonable T>
     template <clonable U>
-    requires std::convertible_to<U*, T*>
+        requires std::convertible_to<U*, T*>
     constexpr auto cloning_ptr<T>::operator=(const cloning_ptr<U>& rhs) noexcept -> self_type&
     {
         m_data = rhs ? rhs->clone() : nullptr;
@@ -397,7 +388,7 @@ namespace sparrow
 
     template <clonable T>
     template <clonable U>
-    requires std::convertible_to<U*, T*>
+        requires std::convertible_to<U*, T*>
     constexpr auto cloning_ptr<T>::operator=(cloning_ptr<U>&& rhs) noexcept -> self_type&
     {
         reset(rhs.release());
@@ -436,18 +427,18 @@ namespace sparrow
     }
 
     template <clonable T>
-    constexpr std::add_lvalue_reference_t<T>
-    cloning_ptr<T>::operator*() const noexcept(noexcept(*std::declval<pointer>()))
+    constexpr std::add_lvalue_reference_t<T> cloning_ptr<T>::operator*() const
+        noexcept(noexcept(*std::declval<pointer>()))
     {
         return *get();
     }
-    
+
     template <clonable T>
     constexpr auto cloning_ptr<T>::operator->() const noexcept -> pointer
     {
         return get();
     }
-    
+
     template <clonable T>
     constexpr auto cloning_ptr<T>::ptr_impl() noexcept -> internal_pointer&
     {
@@ -471,39 +462,29 @@ namespace sparrow
     }
 
     template <class T1, class T2>
-    requires std::equality_comparable_with<
-        typename cloning_ptr<T1>::pointer,
-        typename cloning_ptr<T2>::pointer>
-    constexpr
-    bool operator==(const cloning_ptr<T1>& lhs, const cloning_ptr<T2>& rhs) noexcept
+        requires std::equality_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
+    constexpr bool operator==(const cloning_ptr<T1>& lhs, const cloning_ptr<T2>& rhs) noexcept
     {
         return lhs.get() == rhs.get();
     }
 
     template <class T1, class T2>
-    requires std::three_way_comparable_with<
-        typename cloning_ptr<T1>::pointer,
-        typename cloning_ptr<T2>::pointer>
-    constexpr
-    std::compare_three_way_result_t<
-        typename cloning_ptr<T1>::pointer,
-        typename cloning_ptr<T2>::pointer>
+        requires std::three_way_comparable_with<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
+    constexpr std::compare_three_way_result_t<typename cloning_ptr<T1>::pointer, typename cloning_ptr<T2>::pointer>
     operator<=>(const cloning_ptr<T1>& lhs, const cloning_ptr<T2>& rhs) noexcept
     {
         return lhs.get() <=> rhs.get();
     }
 
     template <class T>
-    constexpr
-    bool operator==(const cloning_ptr<T>& lhs, std::nullptr_t) noexcept
+    constexpr bool operator==(const cloning_ptr<T>& lhs, std::nullptr_t) noexcept
     {
         return !lhs;
     }
 
     template <class T>
-    requires std::three_way_comparable<typename cloning_ptr<T>::pointer>
-    constexpr
-    std::compare_three_way_result_t<typename cloning_ptr<T>::pointer>
+        requires std::three_way_comparable<typename cloning_ptr<T>::pointer>
+    constexpr std::compare_three_way_result_t<typename cloning_ptr<T>::pointer>
     operator<=>(const cloning_ptr<T>& lhs, std::nullptr_t) noexcept
     {
         using pointer = typename cloning_ptr<T>::pointer;
diff --git a/include/sparrow/utils/mp_utils.hpp b/include/sparrow/utils/mp_utils.hpp
index 579e0f59..8355d62a 100644
--- a/include/sparrow/utils/mp_utils.hpp
+++ b/include/sparrow/utils/mp_utils.hpp
@@ -479,26 +479,27 @@ namespace sparrow::mpl
     template <typename T, typename Y, template <typename> typename Qualifier>
     concept T_matches_qualifier_if_Y_is = Qualifier<T>::value || !Qualifier<Y>::value;
 
-
     // helper class to exclude copy and move constructors beeing routed
     // to a constructor with variadic arguments / perfect forwarding
-    template<class CLS, class ... ARGS>
+    template <class CLS, class... ARGS>
     struct excludes_copy_and_move_ctor
-    {   
-       constexpr static bool value = true;
+    {
+        static constexpr bool value = true;
     };
-    template<class CLS>
+
+    template <class CLS>
     struct excludes_copy_and_move_ctor<CLS>
     {
-        constexpr static bool value = true;  
+        static constexpr bool value = true;
     };
-    template<class CLS, class T>
+
+    template <class CLS, class T>
     struct excludes_copy_and_move_ctor<CLS, T>
     {
-        constexpr static bool value = !std::is_same_v<CLS, std::remove_cvref_t<T>>;
+        static constexpr bool value = !std::is_same_v<CLS, std::remove_cvref_t<T>>;
     };
 
-    template<class CLS, class ... ARGS>
+    template <class CLS, class... ARGS>
     constexpr bool excludes_copy_and_move_ctor_v = excludes_copy_and_move_ctor<CLS, ARGS...>::value;
 
     /**
@@ -513,12 +514,12 @@ namespace sparrow::mpl
      */
     template <typename I, typename T>
     concept iterator_of_type = std::input_iterator<I>
-    
+
                                && std::same_as<typename std::iterator_traits<I>::value_type, T>;
 
 
-    // todo...make smth better based on sizeof and is pod 
-    template<class T>
+    // todo...make smth better based on sizeof and is pod
+    template <class T>
     concept char_like = std::same_as<T, char> || std::same_as<T, std::byte> || std::same_as<T, std::uint8_t>;
 
 }
diff --git a/include/sparrow/utils/nullable.hpp b/include/sparrow/utils/nullable.hpp
index 2d908600..cdd1c3dd 100644
--- a/include/sparrow/utils/nullable.hpp
+++ b/include/sparrow/utils/nullable.hpp
@@ -23,7 +23,7 @@
 #include "sparrow/utils/mp_utils.hpp"
 
 #if defined(SPARROW_CONSTEXPR)
-#error "SPARROW_CONSTEXPR already defined"
+#    error "SPARROW_CONSTEXPR already defined"
 #endif
 
 // clang workaround: clang instantiates the constructor in SFINAE context,
@@ -31,9 +31,9 @@
 // are not libc++. This leads to wrong compilation errors. Making the constructor
 // not constexpr prevents the compiler from instantiating it.
 #if defined(__clang__) && not defined(_LIBCPP_VERSION)
-#   define SPARROW_CONSTEXPR
+#    define SPARROW_CONSTEXPR
 #else
-#   define SPARROW_CONSTEXPR constexpr
+#    define SPARROW_CONSTEXPR constexpr
 #endif
 
 namespace sparrow
@@ -42,30 +42,34 @@ namespace sparrow
     class nullable;
 
     template <class T>
-    struct is_nullable : std::false_type {};
+    struct is_nullable : std::false_type
+    {
+    };
 
     template <class T, mpl::boolean_like B>
-    struct is_nullable<nullable<T, B>> : std::true_type {};
+    struct is_nullable<nullable<T, B>> : std::true_type
+    {
+    };
 
     template <class T>
     inline constexpr bool is_nullable_v = is_nullable<T>::value;
 
-    template<class N, class T>
+    template <class N, class T>
     concept is_nullable_of = is_nullable_v<N> && std::same_as<typename N::value_type, T>;
 
-    template<class N, class T>
-    concept is_nullable_of_convertible_to = is_nullable_v<N> &&  std::convertible_to<typename N::value_type, T>;
+    template <class N, class T>
+    concept is_nullable_of_convertible_to = is_nullable_v<N> && std::convertible_to<typename N::value_type, T>;
 
     /*
-    * Matches a range of nullables objects.
-    *
-    * A range is considered a range of nullables if it is a range and its value type is a nullable.
-    *
-    * @tparam RangeOfNullables The range to check.
-    */
-    template<class RangeOfNullables>
-    concept range_of_nullables = std::ranges::range<RangeOfNullables> && is_nullable<std::ranges::range_value_t<RangeOfNullables>>::value;
-
+     * Matches a range of nullables objects.
+     *
+     * A range is considered a range of nullables if it is a range and its value type is a nullable.
+     *
+     * @tparam RangeOfNullables The range to check.
+     */
+    template <class RangeOfNullables>
+    concept range_of_nullables = std::ranges::range<RangeOfNullables>
+                                 && is_nullable<std::ranges::range_value_t<RangeOfNullables>>::value;
 
     /*
      * Default traits for the nullable class. These traits should be specialized
@@ -135,7 +139,9 @@ namespace sparrow
         // a is a nullable would lead to an ambiguous call
         // where both operator=(nullable&&) and operator=(nullval_t)
         // are valid.
-        constexpr explicit nullval_t(int) {}
+        constexpr explicit nullval_t(int)
+        {
+        }
     };
 
     inline constexpr nullval_t nullval(0);
@@ -146,65 +152,60 @@ namespace sparrow
          * Concepts used to disambiguate the nullable class constructors.
          */
         template <class T, class TArgs, class U, class UArgs>
-        concept both_constructible_from_cref =
-            std::constructible_from<T, mpl::add_const_lvalue_reference_t<TArgs>> and
-            std::constructible_from<U, mpl::add_const_lvalue_reference_t<UArgs>>;
+        concept both_constructible_from_cref = std::constructible_from<T, mpl::add_const_lvalue_reference_t<TArgs>>
+                                               and std::constructible_from<U, mpl::add_const_lvalue_reference_t<UArgs>>;
 
         template <class To1, class From1, class To2, class From2>
-        concept both_convertible_from_cref =
-            std::convertible_to<mpl::add_const_lvalue_reference_t<From1>, To1> and
-            std::convertible_to<mpl::add_const_lvalue_reference_t<From2>, To2>;
+        concept both_convertible_from_cref = std::convertible_to<mpl::add_const_lvalue_reference_t<From1>, To1>
+                                             and std::convertible_to<mpl::add_const_lvalue_reference_t<From2>, To2>;
 
         template <class T, class... Args>
-        concept constructible_from_one =
-            (std::constructible_from<T, Args> || ...);
+        concept constructible_from_one = (std::constructible_from<T, Args> || ...);
 
         template <class T, class... Args>
-        concept convertible_from_one =
-            (std::convertible_to<Args, T> || ...);
+        concept convertible_from_one = (std::convertible_to<Args, T> || ...);
 
         template <class T, class... Args>
-        concept initializable_from_one =
-            constructible_from_one<T, Args...> ||
-            convertible_from_one<T, Args...>;
+        concept initializable_from_one = constructible_from_one<T, Args...> || convertible_from_one<T, Args...>;
 
         template <class T, class Arg>
-        concept initializable_from_refs =
-            initializable_from_one<T, Arg&, const Arg&, Arg&&, const Arg&&>;
+        concept initializable_from_refs = initializable_from_one<T, Arg&, const Arg&, Arg&&, const Arg&&>;
 
         // We prefer std::is_assignable_v to std::assignable_from<To, From> because
         // std::assignable_from requires the existence of an implicit conversion
         // from From to To
         template <class To, class... Args>
-        concept assignable_from_one =
-            (std::is_assignable_v<std::add_lvalue_reference<To>, Args> && ...);
+        concept assignable_from_one = (std::is_assignable_v<std::add_lvalue_reference<To>, Args> && ...);
 
         template <class T, class Arg>
-        concept assignable_from_refs =
-            assignable_from_one<T, Arg&, const Arg&, Arg&&, const Arg&&>;
+        concept assignable_from_refs = assignable_from_one<T, Arg&, const Arg&, Arg&&, const Arg&&>;
 
         template <class T, class U>
         using conditional_ref_t = std::conditional_t<std::is_reference_v<T>, const std::decay_t<U>&, std::decay_t<U>&&>;
 
         template <class T, class Targs, class U, class UArgs>
-        concept both_constructible_from_cond_ref =
-            std::constructible_from<T, conditional_ref_t<T, Targs>> and
-            std::constructible_from<U, conditional_ref_t<U, UArgs>>;
+        concept both_constructible_from_cond_ref = std::constructible_from<T, conditional_ref_t<T, Targs>>
+                                                   and std::constructible_from<U, conditional_ref_t<U, UArgs>>;
 
         template <class To1, class From1, class To2, class From2>
-        concept both_convertible_from_cond_ref =
-            std::convertible_to<conditional_ref_t<To1, From1>, To1> and
-            std::convertible_to<conditional_ref_t<To2, From2>, To2>;
+        concept both_convertible_from_cond_ref = std::convertible_to<conditional_ref_t<To1, From1>, To1>
+                                                 and std::convertible_to<conditional_ref_t<To2, From2>, To2>;
 
         template <class To1, class From1, class To2, class From2>
-        concept both_assignable_from_cref =
-            std::is_assignable_v<std::add_lvalue_reference_t<To1>, mpl::add_const_lvalue_reference_t<From1>> and
-            std::is_assignable_v<std::add_lvalue_reference_t<To2>, mpl::add_const_lvalue_reference_t<From2>>;
+        concept both_assignable_from_cref = std::is_assignable_v<
+                                                std::add_lvalue_reference_t<To1>,
+                                                mpl::add_const_lvalue_reference_t<From1>>
+                                            and std::is_assignable_v<
+                                                std::add_lvalue_reference_t<To2>,
+                                                mpl::add_const_lvalue_reference_t<From2>>;
 
         template <class To1, class From1, class To2, class From2>
-        concept both_assignable_from_cond_ref =
-            std::is_assignable_v<std::add_lvalue_reference_t<To1>, conditional_ref_t<To1, From1>> and
-            std::is_assignable_v<std::add_lvalue_reference_t<To2>, conditional_ref_t<To2, From2>>;
+        concept both_assignable_from_cond_ref = std::is_assignable_v<
+                                                    std::add_lvalue_reference_t<To1>,
+                                                    conditional_ref_t<To1, From1>>
+                                                and std::is_assignable_v<
+                                                    std::add_lvalue_reference_t<To2>,
+                                                    conditional_ref_t<To2, From2>>;
 
         template <class T>
         static constexpr bool is_nullable_v = mpl::is_type_instance_of_v<T, nullable>;
@@ -236,7 +237,7 @@ namespace sparrow
      * private:
      *     std::vector<T> m_values;
      *     std::vector<bool> m_flags;
-     * 
+     *
      * public:
      *
      *     using reference = nullable<double&, bool&>;
@@ -287,28 +288,25 @@ namespace sparrow
         using flag_const_reference = typename flag_traits::const_reference;
         using flag_rvalue_reference = typename flag_traits::rvalue_reference;
         using flag_const_rvalue_reference = typename flag_traits::const_rvalue_reference;
-        
+
         template <std::default_initializable U = T, std::default_initializable BB = B>
         constexpr nullable() noexcept
             : m_value()
             , m_null_flag(false)
         {
         }
-        
+
         template <std::default_initializable U = T, std::default_initializable BB = B>
         constexpr nullable(nullval_t) noexcept
             : m_value()
             , m_null_flag(false)
         {
         }
-        
+
         template <class U>
-        requires (
-            not std::same_as<self_type, std::decay_t<U>> and
-            std::constructible_from<T, U&&>
-        )
-        explicit (not std::convertible_to<U&&, T>)
-        constexpr nullable(U&& value) noexcept(noexcept(T(std::declval<U>())))
+            requires(not std::same_as<self_type, std::decay_t<U>> and std::constructible_from<T, U &&>)
+        explicit(not std::convertible_to<U&&, T>) constexpr nullable(U&& value
+        ) noexcept(noexcept(T(std::declval<U>())))
             : m_value(std::forward<U>(value))
             , m_null_flag(true)
         {
@@ -317,12 +315,10 @@ namespace sparrow
         constexpr nullable(const self_type&) = default;
 
         template <class TO, mpl::boolean_like BO>
-        requires (
-            impl::both_constructible_from_cref<T, TO, B, BO> and
-            not impl::initializable_from_refs<T, nullable<TO, BO>>
-        )
-        explicit(not impl::both_convertible_from_cref<T, TO, B, BO>)
-        SPARROW_CONSTEXPR nullable(const nullable<TO, BO>& rhs)
+            requires(impl::both_constructible_from_cref<T, TO, B, BO>
+                     and not impl::initializable_from_refs<T, nullable<TO, BO>>)
+        explicit(not impl::both_convertible_from_cref<T, TO, B, BO>) SPARROW_CONSTEXPR
+            nullable(const nullable<TO, BO>& rhs)
             : m_value(rhs.get())
             , m_null_flag(rhs.null_flag())
         {
@@ -330,12 +326,9 @@ namespace sparrow
 
 #ifdef __clang__
         template <class TO, mpl::boolean_like BO>
-        requires (
-            impl::both_constructible_from_cref<T, TO, B, BO> and
-            std::same_as<std::decay_t<T>, bool>
-        )
-        explicit(not impl::both_convertible_from_cref<T, TO, B, BO>)
-        SPARROW_CONSTEXPR nullable(const nullable<TO, BO>& rhs)
+            requires(impl::both_constructible_from_cref<T, TO, B, BO> and std::same_as<std::decay_t<T>, bool>)
+        explicit(not impl::both_convertible_from_cref<T, TO, B, BO>) SPARROW_CONSTEXPR
+            nullable(const nullable<TO, BO>& rhs)
             : m_value(rhs.get())
             , m_null_flag(rhs.null_flag())
         {
@@ -345,12 +338,10 @@ namespace sparrow
         constexpr nullable(self_type&&) noexcept = default;
 
         template <class TO, mpl::boolean_like BO>
-        requires (
-            impl::both_constructible_from_cond_ref<T, TO, B, BO> and
-            not impl::initializable_from_refs<T, nullable<TO, BO>>
-        )
-        explicit(not impl::both_convertible_from_cond_ref<T, TO, B, BO>)
-        SPARROW_CONSTEXPR nullable(nullable<TO, BO>&& rhs)
+            requires(impl::both_constructible_from_cond_ref<T, TO, B, BO>
+                     and not impl::initializable_from_refs<T, nullable<TO, BO>>)
+        explicit(not impl::both_convertible_from_cond_ref<T, TO, B, BO>) SPARROW_CONSTEXPR
+            nullable(nullable<TO, BO>&& rhs)
             : m_value(std::move(rhs).get())
             , m_null_flag(std::move(rhs).null_flag())
         {
@@ -358,18 +349,16 @@ namespace sparrow
 
 #ifdef __clang__
         template <class TO, mpl::boolean_like BO>
-        requires (
-            impl::both_constructible_from_cond_ref<T, TO, B, BO> and
-            std::same_as<std::decay_t<T>, bool>
-        )
-        explicit(not impl::both_convertible_from_cond_ref<T, TO, B, BO>)
-        SPARROW_CONSTEXPR nullable(nullable<TO, BO>&& rhs)
+            requires(impl::both_constructible_from_cond_ref<T, TO, B, BO>
+                     and std::same_as<std::decay_t<T>, bool>)
+        explicit(not impl::both_convertible_from_cond_ref<T, TO, B, BO>) SPARROW_CONSTEXPR
+            nullable(nullable<TO, BO>&& rhs)
             : m_value(std::move(rhs).get())
             , m_null_flag(std::move(rhs).null_flag())
         {
         }
 #endif
-  
+
         constexpr nullable(value_type&& value, flag_type&& null_flag)
             : m_value(std::move(value))
             , m_null_flag(std::move(null_flag))
@@ -401,10 +390,7 @@ namespace sparrow
         }
 
         template <class TO>
-        requires(
-            not std::same_as<self_type, TO> and
-            std::assignable_from<std::add_lvalue_reference_t<T>, TO>
-        )
+            requires(not std::same_as<self_type, TO> and std::assignable_from<std::add_lvalue_reference_t<T>, TO>)
         constexpr self_type& operator=(TO&& rhs)
         {
             m_value = std::forward<TO>(rhs);
@@ -420,11 +406,7 @@ namespace sparrow
         }
 
         template <class TO, mpl::boolean_like BO>
-        requires(
-            impl::both_assignable_from_cref<T, TO, B, BO> and
-            not impl::initializable_from_refs<T, nullable<TO, BO>> and
-            not impl::assignable_from_refs<T, nullable<TO, BO>>
-        )
+            requires(impl::both_assignable_from_cref<T, TO, B, BO> and not impl::initializable_from_refs<T, nullable<TO, BO>> and not impl::assignable_from_refs<T, nullable<TO, BO>>)
         constexpr self_type& operator=(const nullable<TO, BO>& rhs)
         {
             m_value = rhs.get();
@@ -440,11 +422,7 @@ namespace sparrow
         }
 
         template <class TO, mpl::boolean_like BO>
-        requires(
-            impl::both_assignable_from_cond_ref<T, TO, B, BO> and
-            not impl::initializable_from_refs<T, nullable<TO, BO>> and
-            not impl::assignable_from_refs<T, nullable<TO, BO>>
-        )
+            requires(impl::both_assignable_from_cond_ref<T, TO, B, BO> and not impl::initializable_from_refs<T, nullable<TO, BO>> and not impl::assignable_from_refs<T, nullable<TO, BO>>)
         constexpr self_type& operator=(nullable<TO, BO>&& rhs)
         {
             m_value = std::move(rhs).get();
@@ -456,22 +434,22 @@ namespace sparrow
         constexpr bool has_value() const noexcept;
 
         constexpr flag_reference null_flag() & noexcept;
-        constexpr flag_const_reference null_flag() const & noexcept;
+        constexpr flag_const_reference null_flag() const& noexcept;
         constexpr flag_rvalue_reference null_flag() && noexcept;
-        constexpr flag_const_rvalue_reference null_flag() const && noexcept;
+        constexpr flag_const_rvalue_reference null_flag() const&& noexcept;
 
         constexpr reference get() & noexcept;
-        constexpr const_reference get() const & noexcept;
+        constexpr const_reference get() const& noexcept;
         constexpr rvalue_reference get() && noexcept;
-        constexpr const_rvalue_reference get() const && noexcept;
-        
+        constexpr const_rvalue_reference get() const&& noexcept;
+
         constexpr reference value() &;
-        constexpr const_reference value() const &;
+        constexpr const_reference value() const&;
         constexpr rvalue_reference value() &&;
-        constexpr const_rvalue_reference value() const &&;
+        constexpr const_rvalue_reference value() const&&;
 
         template <class U>
-        constexpr value_type value_or(U&& default_value) const &;
+        constexpr value_type value_or(U&& default_value) const&;
 
         template <class U>
         constexpr value_type value_or(U&& default_value) &&;
@@ -498,12 +476,12 @@ namespace sparrow
 
     template <class T, mpl::boolean_like B>
     constexpr std::strong_ordering operator<=>(const nullable<T, B>& lhs, nullval_t) noexcept;
-    
+
     template <class T, class B, class U>
     constexpr bool operator==(const nullable<T, B>& lhs, const U& rhs) noexcept;
 
     template <class T, class B, class U>
-    requires (!impl::is_nullable_v<U> && std::three_way_comparable_with<U, T>)
+        requires(!impl::is_nullable_v<U> && std::three_way_comparable_with<U, T>)
     constexpr std::compare_three_way_result_t<T, U>
     operator<=>(const nullable<T, B>& lhs, const U& rhs) noexcept;
 
@@ -518,14 +496,14 @@ namespace sparrow
     // to their argument, making the deduction impossible.
     template <class T, mpl::boolean_like B = bool>
     constexpr nullable<T, B> make_nullable(T&& value, B&& flag = true);
-    
+
     /**
      * variant of nullable, exposing has_value for convenience
      *
      * @tparam T the list of nullable in the variant
      */
     template <class... T>
-        requires (is_nullable_v<T> && ...)
+        requires(is_nullable_v<T> && ...)
     class nullable_variant : public std::variant<T...>
     {
     public:
@@ -548,16 +526,13 @@ namespace std
 {
     namespace mpl = sparrow::mpl;
 
-    // Specialization of basic_common_reference for nullable proxies so 
+    // Specialization of basic_common_reference for nullable proxies so
     // we can use ranges algorithm on iterators returning nullable
-    template <class T, mpl::boolean_like TB, class U, mpl::boolean_like UB,
-             template <class> class TQual, template <class> class UQual>
+    template <class T, mpl::boolean_like TB, class U, mpl::boolean_like UB, template <class> class TQual, template <class> class UQual>
     struct basic_common_reference<sparrow::nullable<T, TB>, sparrow::nullable<U, UB>, TQual, UQual>
     {
-        using type = sparrow::nullable<
-            std::common_reference_t<TQual<T>, UQual<U>>,
-            std::common_reference_t<TQual<TB>, UQual<UB>>
-        >;
+        using type = sparrow::
+            nullable<std::common_reference_t<TQual<T>, UQual<U>>, std::common_reference_t<TQual<TB>, UQual<UB>>>;
     };
 }
 
@@ -584,13 +559,13 @@ namespace sparrow
     {
         return m_null_flag;
     }
-    
+
     template <class T, mpl::boolean_like B>
-    constexpr auto nullable<T, B>::null_flag() const & noexcept -> flag_const_reference
+    constexpr auto nullable<T, B>::null_flag() const& noexcept -> flag_const_reference
     {
         return m_null_flag;
     }
-    
+
     template <class T, mpl::boolean_like B>
     constexpr auto nullable<T, B>::null_flag() && noexcept -> flag_rvalue_reference
     {
@@ -603,9 +578,9 @@ namespace sparrow
             return flag_rvalue_reference(m_null_flag);
         }
     }
-    
+
     template <class T, mpl::boolean_like B>
-    constexpr auto nullable<T, B>::null_flag() const && noexcept -> flag_const_rvalue_reference
+    constexpr auto nullable<T, B>::null_flag() const&& noexcept -> flag_const_rvalue_reference
     {
         if constexpr (std::is_reference_v<B>)
         {
@@ -624,11 +599,11 @@ namespace sparrow
     }
 
     template <class T, mpl::boolean_like B>
-    constexpr auto nullable<T, B>::get() const & noexcept -> const_reference
+    constexpr auto nullable<T, B>::get() const& noexcept -> const_reference
     {
         return m_value;
     }
-    
+
     template <class T, mpl::boolean_like B>
     constexpr auto nullable<T, B>::get() && noexcept -> rvalue_reference
     {
@@ -643,7 +618,7 @@ namespace sparrow
     }
 
     template <class T, mpl::boolean_like B>
-    constexpr auto nullable<T, B>::get() const && noexcept -> const_rvalue_reference
+    constexpr auto nullable<T, B>::get() const&& noexcept -> const_rvalue_reference
     {
         if constexpr (std::is_reference_v<T>)
         {
@@ -663,12 +638,12 @@ namespace sparrow
     }
 
     template <class T, mpl::boolean_like B>
-    constexpr auto nullable<T, B>::value() const & -> const_reference
+    constexpr auto nullable<T, B>::value() const& -> const_reference
     {
         throw_if_null();
         return get();
     }
-    
+
     template <class T, mpl::boolean_like B>
     constexpr auto nullable<T, B>::value() && -> rvalue_reference
     {
@@ -677,7 +652,7 @@ namespace sparrow
     }
 
     template <class T, mpl::boolean_like B>
-    constexpr auto nullable<T, B>::value() const && -> const_rvalue_reference
+    constexpr auto nullable<T, B>::value() const&& -> const_rvalue_reference
     {
         throw_if_null();
         return std::move(*this).get();
@@ -685,16 +660,16 @@ namespace sparrow
 
     template <class T, mpl::boolean_like B>
     template <class U>
-    constexpr auto nullable<T, B>::value_or(U&& default_value) const & -> value_type
+    constexpr auto nullable<T, B>::value_or(U&& default_value) const& -> value_type
     {
-        return *this ? get() : value_type(std::forward<U>(default_value)); 
+        return *this ? get() : value_type(std::forward<U>(default_value));
     }
 
     template <class T, mpl::boolean_like B>
     template <class U>
     constexpr auto nullable<T, B>::value_or(U&& default_value) && -> value_type
     {
-        return *this ? get() : value_type(std::forward<U>(default_value)); 
+        return *this ? get() : value_type(std::forward<U>(default_value));
     }
 
     template <class T, mpl::boolean_like B>
@@ -710,7 +685,7 @@ namespace sparrow
     {
         m_null_flag = false;
     }
-    
+
     template <class T, mpl::boolean_like B>
     void nullable<T, B>::throw_if_null() const
     {
@@ -737,7 +712,7 @@ namespace sparrow
     {
         return lhs <=> false;
     }
-    
+
     template <class T, class B, class U>
     constexpr bool operator==(const nullable<T, B>& lhs, const U& rhs) noexcept
     {
@@ -745,9 +720,8 @@ namespace sparrow
     }
 
     template <class T, class B, class U>
-    requires (!impl::is_nullable_v<U> && std::three_way_comparable_with<U, T>)
-    constexpr std::compare_three_way_result_t<T, U>
-    operator<=>(const nullable<T, B>& lhs, const U& rhs) noexcept
+        requires(!impl::is_nullable_v<U> && std::three_way_comparable_with<U, T>)
+    constexpr std::compare_three_way_result_t<T, U> operator<=>(const nullable<T, B>& lhs, const U& rhs) noexcept
     {
         return lhs ? lhs.get() <=> rhs : std::strong_ordering::less;
     }
@@ -776,37 +750,40 @@ namespace sparrow
      ***********************************/
 
     template <class... T>
-    requires (is_nullable_v<T> && ...)
-    constexpr nullable_variant<T...>&
-    nullable_variant<T...>::operator=(const nullable_variant& rhs)
+        requires(is_nullable_v<T> && ...)
+    constexpr nullable_variant<T...>& nullable_variant<T...>::operator=(const nullable_variant& rhs)
     {
         base_type::operator=(rhs);
         return *this;
     }
 
     template <class... T>
-    requires (is_nullable_v<T> && ...)
-    constexpr nullable_variant<T...>&
-    nullable_variant<T...>::operator=(nullable_variant&& rhs)
+        requires(is_nullable_v<T> && ...)
+    constexpr nullable_variant<T...>& nullable_variant<T...>::operator=(nullable_variant&& rhs)
     {
         base_type::operator=(std::move(rhs));
         return *this;
     }
-    
+
     template <class... T>
-    requires (is_nullable_v<T> && ...)
+        requires(is_nullable_v<T> && ...)
     constexpr nullable_variant<T...>::operator bool() const
     {
         return has_value();
     }
 
     template <class... T>
-    requires (is_nullable_v<T> && ...)
+        requires(is_nullable_v<T> && ...)
     constexpr bool nullable_variant<T...>::has_value() const
     {
-        return std::visit([](const auto& v) { return v.has_value(); }, *this);
+        return std::visit(
+            [](const auto& v)
+            {
+                return v.has_value();
+            },
+            *this
+        );
     }
 }
 
 #undef SPARROW_CONSTEXPR
-
diff --git a/include/sparrow/utils/offsets.hpp b/include/sparrow/utils/offsets.hpp
index 41a4bfd0..64e6d133 100644
--- a/include/sparrow/utils/offsets.hpp
+++ b/include/sparrow/utils/offsets.hpp
@@ -15,22 +15,28 @@
 #include <numeric>
 #include <ranges>
 
-#include "sparrow/types/data_type.hpp"
 #include "sparrow/buffer/buffer.hpp"
+#include "sparrow/types/data_type.hpp"
 
 #pragma once
 
 namespace sparrow
 {
-    template<layout_offset OT, std::ranges::sized_range R>
-    requires std::ranges::sized_range<std::ranges::range_value_t<R>>
+    template <layout_offset OT, std::ranges::sized_range R>
+        requires std::ranges::sized_range<std::ranges::range_value_t<R>>
     buffer<OT> make_offset_buffer(const R& range)
     {
         const size_t range_size = std::ranges::size(range);
         buffer<OT> offsets(range_size + 1, 0);
-        std::transform(range.cbegin(), range.cend(), offsets.begin() + 1, [](const auto& elem) {
-            return static_cast<OT>(elem.size());
-        });
+        std::transform(
+            range.cbegin(),
+            range.cend(),
+            offsets.begin() + 1,
+            [](const auto& elem)
+            {
+                return static_cast<OT>(elem.size());
+            }
+        );
         std::partial_sum(offsets.begin(), offsets.end(), offsets.begin());
         return offsets;
     }
diff --git a/include/sparrow/utils/ranges.hpp b/include/sparrow/utils/ranges.hpp
index 4d90dcb9..9961b10b 100644
--- a/include/sparrow/utils/ranges.hpp
+++ b/include/sparrow/utils/ranges.hpp
@@ -16,17 +16,17 @@
 #include <ranges>
 
 namespace sparrow
-{   
-    template<std::ranges::input_range R>
-    requires(std::ranges::sized_range<R>)
-    std::size_t range_size(R && r)
+{
+    template <std::ranges::input_range R>
+        requires(std::ranges::sized_range<R>)
+    std::size_t range_size(R&& r)
     {
         return static_cast<std::size_t>(std::ranges::size(r));
     }
 
-    template<std::ranges::input_range R>
-    requires(!std::ranges::sized_range<R>)
-    std::size_t range_size(R && r)
+    template <std::ranges::input_range R>
+        requires(!std::ranges::sized_range<R>)
+    std::size_t range_size(R&& r)
     {
         return static_cast<std::size_t>(std::ranges::distance(r));
     }
diff --git a/src/array_factory.cpp b/src/array_factory.cpp
index f6f77132..0b01acd9 100644
--- a/src/array_factory.cpp
+++ b/src/array_factory.cpp
@@ -12,18 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <memory>
 #include "sparrow/array_factory.hpp"
-#include "sparrow/layout/list_layout/list_array.hpp"
-#include "sparrow/layout/struct_layout/struct_array.hpp"
+
+#include <memory>
+
+#include "sparrow/layout/decimal_array.hpp"
 #include "sparrow/layout/dictionary_encoded_array.hpp"
-#include "sparrow/layout/primitive_array.hpp"
+#include "sparrow/layout/list_layout/list_array.hpp"
 #include "sparrow/layout/null_array.hpp"
-#include "sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp"
+#include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
+#include "sparrow/layout/struct_layout/struct_array.hpp"
 #include "sparrow/layout/union_array.hpp"
-#include "sparrow/layout/decimal_array.hpp"
-
+#include "sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp"
 
 namespace sparrow
 {
@@ -32,7 +33,7 @@ namespace sparrow
         template <class T>
         cloning_ptr<array_wrapper> make_wrapper_ptr(arrow_proxy proxy)
         {
-            return cloning_ptr<array_wrapper>{new array_wrapper_impl<T>(T(std::move(proxy))) };
+            return cloning_ptr<array_wrapper>{new array_wrapper_impl<T>(T(std::move(proxy)))};
         }
     }
 
@@ -42,94 +43,96 @@ namespace sparrow
 
         if (proxy.dictionary())
         {
-            switch(dt)
+            switch (dt)
             {
-            case data_type::INT8:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::int8_t>>(std::move(proxy));
-            case data_type::UINT8:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint8_t>>(std::move(proxy));
-            case data_type::INT16:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::int16_t>>(std::move(proxy));
-            case data_type::UINT16:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint16_t>>(std::move(proxy));
-            case data_type::INT32:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::int32_t>>(std::move(proxy));
-            case data_type::UINT32:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint32_t>>(std::move(proxy));
-            case data_type::INT64:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::int64_t>>(std::move(proxy));
-            case data_type::UINT64:
-                return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint64_t>>(std::move(proxy));
-            default:
-                throw std::runtime_error("data datype of dictionary encoded array must be an integer");
+                case data_type::INT8:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::int8_t>>(std::move(proxy));
+                case data_type::UINT8:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint8_t>>(std::move(proxy));
+                case data_type::INT16:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::int16_t>>(std::move(proxy));
+                case data_type::UINT16:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint16_t>>(std::move(proxy));
+                case data_type::INT32:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::int32_t>>(std::move(proxy));
+                case data_type::UINT32:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint32_t>>(std::move(proxy));
+                case data_type::INT64:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::int64_t>>(std::move(proxy));
+                case data_type::UINT64:
+                    return detail::make_wrapper_ptr<dictionary_encoded_array<std::uint64_t>>(std::move(proxy));
+                default:
+                    throw std::runtime_error("data datype of dictionary encoded array must be an integer");
             }
         }
         else
         {
-            switch(dt)
+            switch (dt)
             {
-            case data_type::NA:
-                return detail::make_wrapper_ptr<null_array>(std::move(proxy));
-            case data_type::BOOL:
-                return detail::make_wrapper_ptr<primitive_array<bool>>(std::move(proxy));
-            case data_type::INT8:
-                return detail::make_wrapper_ptr<primitive_array<std::int8_t>>(std::move(proxy));
-            case data_type::UINT8:
-                return detail::make_wrapper_ptr<primitive_array<std::uint8_t>>(std::move(proxy));
-            case data_type::INT16:
-                return detail::make_wrapper_ptr<primitive_array<std::int16_t>>(std::move(proxy));
-            case data_type::UINT16:
-                return detail::make_wrapper_ptr<primitive_array<std::uint16_t>>(std::move(proxy));
-            case data_type::INT32:
-                return detail::make_wrapper_ptr<primitive_array<std::int32_t>>(std::move(proxy));
-            case data_type::UINT32:
-                return detail::make_wrapper_ptr<primitive_array<std::uint32_t>>(std::move(proxy));
-            case data_type::INT64:
-                return detail::make_wrapper_ptr<primitive_array<std::int64_t>>(std::move(proxy));
-            case data_type::UINT64:
-                return detail::make_wrapper_ptr<primitive_array<std::uint64_t>>(std::move(proxy));
-            case data_type::HALF_FLOAT:
-                return detail::make_wrapper_ptr<primitive_array<float16_t>>(std::move(proxy));
-            case data_type::FLOAT:
-                return detail::make_wrapper_ptr<primitive_array<float>>(std::move(proxy));
-            case data_type::DOUBLE:
-                return detail::make_wrapper_ptr<primitive_array<double>>(std::move(proxy));
-            case data_type::LIST:{
-                return detail::make_wrapper_ptr<list_array>(std::move(proxy));
-            }
-            case data_type::LARGE_LIST:{
-                return detail::make_wrapper_ptr<big_list_array>(std::move(proxy));
-            }
-            case data_type::LIST_VIEW:
-                return detail::make_wrapper_ptr<list_view_array>(std::move(proxy));
-            case data_type::LARGE_LIST_VIEW:
-                return detail::make_wrapper_ptr<big_list_view_array>(std::move(proxy));
-            case data_type::FIXED_SIZED_LIST:
-                return detail::make_wrapper_ptr<fixed_sized_list_array>(std::move(proxy));
-            case data_type::STRUCT:
-                return detail::make_wrapper_ptr<struct_array>(std::move(proxy));
-            case data_type::STRING:
-                return detail::make_wrapper_ptr<string_array>(std::move(proxy)); 
-            case data_type::RUN_ENCODED:
-                return detail::make_wrapper_ptr<run_end_encoded_array>(std::move(proxy));
-            case data_type::DENSE_UNION:
-                return detail::make_wrapper_ptr<dense_union_array>(std::move(proxy));
-            case data_type::SPARSE_UNION:
-                return detail::make_wrapper_ptr<sparse_union_array>(std::move(proxy));
-            case data_type::TIMESTAMP:
-            case data_type::MAP:
-            case data_type::DECIMAL32:
-                return detail::make_wrapper_ptr<decimal_32_array>(std::move(proxy));
-            case data_type::DECIMAL64:
-                return detail::make_wrapper_ptr<decimal_64_array>(std::move(proxy));
-            case data_type::DECIMAL128:
-                return detail::make_wrapper_ptr<decimal_128_array>(std::move(proxy));
-            case data_type::DECIMAL256:
-                return detail::make_wrapper_ptr<decimal_256_array>(std::move(proxy));
-            case data_type::FIXED_WIDTH_BINARY:
-                throw std::runtime_error("not yet supported data type");
-            default:
-                throw std::runtime_error("not supported data type");
+                case data_type::NA:
+                    return detail::make_wrapper_ptr<null_array>(std::move(proxy));
+                case data_type::BOOL:
+                    return detail::make_wrapper_ptr<primitive_array<bool>>(std::move(proxy));
+                case data_type::INT8:
+                    return detail::make_wrapper_ptr<primitive_array<std::int8_t>>(std::move(proxy));
+                case data_type::UINT8:
+                    return detail::make_wrapper_ptr<primitive_array<std::uint8_t>>(std::move(proxy));
+                case data_type::INT16:
+                    return detail::make_wrapper_ptr<primitive_array<std::int16_t>>(std::move(proxy));
+                case data_type::UINT16:
+                    return detail::make_wrapper_ptr<primitive_array<std::uint16_t>>(std::move(proxy));
+                case data_type::INT32:
+                    return detail::make_wrapper_ptr<primitive_array<std::int32_t>>(std::move(proxy));
+                case data_type::UINT32:
+                    return detail::make_wrapper_ptr<primitive_array<std::uint32_t>>(std::move(proxy));
+                case data_type::INT64:
+                    return detail::make_wrapper_ptr<primitive_array<std::int64_t>>(std::move(proxy));
+                case data_type::UINT64:
+                    return detail::make_wrapper_ptr<primitive_array<std::uint64_t>>(std::move(proxy));
+                case data_type::HALF_FLOAT:
+                    return detail::make_wrapper_ptr<primitive_array<float16_t>>(std::move(proxy));
+                case data_type::FLOAT:
+                    return detail::make_wrapper_ptr<primitive_array<float>>(std::move(proxy));
+                case data_type::DOUBLE:
+                    return detail::make_wrapper_ptr<primitive_array<double>>(std::move(proxy));
+                case data_type::LIST:
+                {
+                    return detail::make_wrapper_ptr<list_array>(std::move(proxy));
+                }
+                case data_type::LARGE_LIST:
+                {
+                    return detail::make_wrapper_ptr<big_list_array>(std::move(proxy));
+                }
+                case data_type::LIST_VIEW:
+                    return detail::make_wrapper_ptr<list_view_array>(std::move(proxy));
+                case data_type::LARGE_LIST_VIEW:
+                    return detail::make_wrapper_ptr<big_list_view_array>(std::move(proxy));
+                case data_type::FIXED_SIZED_LIST:
+                    return detail::make_wrapper_ptr<fixed_sized_list_array>(std::move(proxy));
+                case data_type::STRUCT:
+                    return detail::make_wrapper_ptr<struct_array>(std::move(proxy));
+                case data_type::STRING:
+                    return detail::make_wrapper_ptr<string_array>(std::move(proxy));
+                case data_type::RUN_ENCODED:
+                    return detail::make_wrapper_ptr<run_end_encoded_array>(std::move(proxy));
+                case data_type::DENSE_UNION:
+                    return detail::make_wrapper_ptr<dense_union_array>(std::move(proxy));
+                case data_type::SPARSE_UNION:
+                    return detail::make_wrapper_ptr<sparse_union_array>(std::move(proxy));
+                case data_type::TIMESTAMP:
+                case data_type::MAP:
+                case data_type::DECIMAL32:
+                    return detail::make_wrapper_ptr<decimal_32_array>(std::move(proxy));
+                case data_type::DECIMAL64:
+                    return detail::make_wrapper_ptr<decimal_64_array>(std::move(proxy));
+                case data_type::DECIMAL128:
+                    return detail::make_wrapper_ptr<decimal_128_array>(std::move(proxy));
+                case data_type::DECIMAL256:
+                    return detail::make_wrapper_ptr<decimal_256_array>(std::move(proxy));
+                case data_type::FIXED_WIDTH_BINARY:
+                    throw std::runtime_error("not yet supported data type");
+                default:
+                    throw std::runtime_error("not supported data type");
             }
         }
     }
diff --git a/src/array_helper.cpp b/src/array_helper.cpp
index ff7157a8..c4575feb 100644
--- a/src/array_helper.cpp
+++ b/src/array_helper.cpp
@@ -13,32 +13,55 @@
 // limitations under the License.
 
 #include "sparrow/layout/array_helper.hpp"
+
 #include "sparrow/layout/dispatch.hpp"
 
 namespace sparrow
 {
     std::size_t array_size(const array_wrapper& ar)
     {
-        return visit([](const auto& impl) { return impl.size(); }, ar);
+        return visit(
+            [](const auto& impl)
+            {
+                return impl.size();
+            },
+            ar
+        );
     }
 
     bool array_has_value(const array_wrapper& ar, std::size_t index)
     {
-        return visit([index](const auto& impl) { return impl[index].has_value(); }, ar);
+        return visit(
+            [index](const auto& impl)
+            {
+                return impl[index].has_value();
+            },
+            ar
+        );
     }
 
     array_traits::const_reference array_element(const array_wrapper& ar, std::size_t index)
     {
         using return_type = array_traits::const_reference;
-        return visit([index](const auto& impl) -> return_type { return return_type(impl[index]); }, ar);
+        return visit(
+            [index](const auto& impl) -> return_type
+            {
+                return return_type(impl[index]);
+            },
+            ar
+        );
     }
 
     array_traits::inner_value_type array_default_element_value(const array_wrapper& ar)
     {
         using return_type = array_traits::inner_value_type;
-        return visit([](const auto& impl) -> return_type {
-            using value_type = typename std::decay_t<decltype(impl)>::inner_value_type;
-            return value_type();
-        }, ar);
+        return visit(
+            [](const auto& impl) -> return_type
+            {
+                using value_type = typename std::decay_t<decltype(impl)>::inner_value_type;
+                return value_type();
+            },
+            ar
+        );
     }
 }
diff --git a/src/arrow_array_schema_proxy.cpp b/src/arrow_array_schema_proxy.cpp
index 37606626..5b89bc53 100644
--- a/src/arrow_array_schema_proxy.cpp
+++ b/src/arrow_array_schema_proxy.cpp
@@ -678,14 +678,13 @@ namespace sparrow
 
     void arrow_proxy::update_null_count()
     {
-        if(has_bitmap(data_type()))
+        if (has_bitmap(data_type()))
         {
             const auto& validity_buffer = buffers().front();
             const dynamic_bitset_view<const std::uint8_t> bitmap(validity_buffer.data(), length() + offset());
             const auto null_count = bitmap.null_count();
             set_null_count(static_cast<int64_t>(null_count));
         }
-        
     }
 
     bool arrow_proxy::is_arrow_array_valid() const
diff --git a/src/arrow_interface/arrow_array.cpp b/src/arrow_interface/arrow_array.cpp
index 74301a71..e5a10476 100644
--- a/src/arrow_interface/arrow_array.cpp
+++ b/src/arrow_interface/arrow_array.cpp
@@ -40,15 +40,12 @@ namespace sparrow
         SPARROW_ASSERT_TRUE(array->release == std::addressof(empty_release_arrow_array));
     }
 
-
-    template<class T>
-    auto static_const_ptr_cast(const void *ptr)
+    template <class T>
+    auto static_const_ptr_cast(const void* ptr)
     {
         return const_cast<T*>(static_cast<const T*>(ptr));
     }
 
-
-
     // get the bit width for fixed width binary from format
     std::size_t num_bytes_for_fixed_sized_binary(const char* format)
     {
@@ -57,43 +54,43 @@ namespace sparrow
 
         // check if format+2 is a number
 
-        if(!all_digits(std::string_view(format + 2)))
+        if (!all_digits(std::string_view(format + 2)))
         {
             throw std::runtime_error("Invalid format for fixed width binary");
         }
         const auto width = std::atoi(format + 2);
-        if(width <= 0)
+        if (width <= 0)
         {
             throw std::runtime_error("Invalid format for fixed width binary");
         }
         return static_cast<std::size_t>(width);
     }
-    
 
     std::vector<sparrow::buffer_view<uint8_t>>
     get_arrow_array_buffers(const ArrowArray& array, const ArrowSchema& schema)
-    {   
+    {
         using buffer_view_type = sparrow::buffer_view<uint8_t>;
         const auto size = static_cast<size_t>(array.length + array.offset);
         auto make_valid_buffer = [&]()
         {
             const auto buffer_size = static_cast<size_t>(size + 7) / 8;
             auto typed_buffer_ptr = static_const_ptr_cast<uint8_t>(array.buffers[0]);
-            return typed_buffer_ptr != nullptr ? buffer_view_type(typed_buffer_ptr, buffer_size) : buffer_view_type(nullptr, 0);
+            return typed_buffer_ptr != nullptr ? buffer_view_type(typed_buffer_ptr, buffer_size)
+                                               : buffer_view_type(nullptr, 0);
         };
-        auto make_buffer =  [&](auto index, auto size)
+        auto make_buffer = [&](auto index, auto size)
         {
             auto buffer_ptr = static_const_ptr_cast<uint8_t>(array.buffers[index]);
             return buffer_view_type(buffer_ptr, size);
         };
 
-        switch(format_to_data_type(schema.format))
-        {   
+        switch (format_to_data_type(schema.format))
+        {
             case data_type::NA:
             case data_type::RUN_ENCODED:
             case data_type::MAP:
                 return {};
-            case data_type::BOOL:   
+            case data_type::BOOL:
                 return {make_valid_buffer(), make_buffer(1, (size + 7) / 8)};
             case data_type::UINT8:
             case data_type::INT8:
@@ -112,7 +109,11 @@ namespace sparrow
                 return {make_valid_buffer(), make_buffer(1, size * 8)};
             case data_type::STRING:
             case data_type::BINARY:
-                return {make_valid_buffer(),make_buffer(1, (size + 1) * 4), make_buffer(2, static_const_ptr_cast<int32_t>(array.buffers[1])[size])};
+                return {
+                    make_valid_buffer(),
+                    make_buffer(1, (size + 1) * 4),
+                    make_buffer(2, static_const_ptr_cast<int32_t>(array.buffers[1])[size])
+                };
             case data_type::LIST:
                 return {make_valid_buffer(), make_buffer(1, (size + 1) * 4)};
             case data_type::LARGE_LIST:
@@ -123,11 +124,11 @@ namespace sparrow
                 return {make_valid_buffer(), make_buffer(1, size * 8), make_buffer(2, size * 8)};
             case data_type::FIXED_SIZED_LIST:
             case data_type::STRUCT:
-                return  {make_valid_buffer()};
+                return {make_valid_buffer()};
             case data_type::SPARSE_UNION:
                 return {make_buffer(0, size)};
             case data_type::DENSE_UNION:
-                return {make_buffer(0, size), make_buffer(1, size*4)};
+                return {make_buffer(0, size), make_buffer(1, size * 4)};
             case data_type::TIMESTAMP:
                 return {make_valid_buffer(), make_buffer(1, size * 8)};
             case data_type::DECIMAL32:
@@ -135,24 +136,27 @@ namespace sparrow
             case data_type::DECIMAL64:
                 return {make_valid_buffer(), make_buffer(1, size * 8)};
             case data_type::DECIMAL128:
-                return {make_valid_buffer(), make_buffer(1, size * 16)}; 
+                return {make_valid_buffer(), make_buffer(1, size * 16)};
             case data_type::DECIMAL256:
-                return {make_valid_buffer(), make_buffer(1, size * 32)}; 
+                return {make_valid_buffer(), make_buffer(1, size * 32)};
             case data_type::FIXED_WIDTH_BINARY:
-                return {make_valid_buffer(), make_buffer(1, size *  num_bytes_for_fixed_sized_binary(schema.format))};
+                return {
+                    make_valid_buffer(),
+                    make_buffer(1, size * num_bytes_for_fixed_sized_binary(schema.format))
+                };
             case data_type::STRING_VIEW:
             case data_type::BINARY_VIEW:
                 const auto buffer_count = static_cast<size_t>(array.n_buffers);
                 const auto num_extra_data_buffers = buffer_count - 3;
                 std::vector<buffer_view_type> buffers(buffer_count);
-                int64_t * var_buffer_sizes = static_const_ptr_cast<int64_t>(array.buffers[buffer_count - 1]);
+                int64_t* var_buffer_sizes = static_const_ptr_cast<int64_t>(array.buffers[buffer_count - 1]);
                 buffers[0] = make_valid_buffer();
                 buffers[1] = make_buffer(1, size * 16);
                 for (size_t i = 0; i < num_extra_data_buffers; ++i)
                 {
                     buffers[i + 2] = make_buffer(i + 2, var_buffer_sizes[i]);
                 }
-                buffers.back() = make_buffer(buffer_count -1 , size * 4);
+                buffers.back() = make_buffer(buffer_count - 1, size * 4);
                 return buffers;
         }
         // To avoid stupid warning "control reaches end of non-void function"
diff --git a/src/arrow_interface/arrow_schema.cpp b/src/arrow_interface/arrow_schema.cpp
index dcf587c5..7ec5d91b 100644
--- a/src/arrow_interface/arrow_schema.cpp
+++ b/src/arrow_interface/arrow_schema.cpp
@@ -16,7 +16,6 @@
 
 #include "sparrow/arrow_interface/arrow_array_schema_utils.hpp"
 
-
 namespace sparrow
 {
     void release_arrow_schema(ArrowSchema* schema)
diff --git a/src/dummy32bit.cpp b/src/dummy32bit.cpp
index b7b590c6..6b3cf9f3 100644
--- a/src/dummy32bit.cpp
+++ b/src/dummy32bit.cpp
@@ -1,4 +1,6 @@
 #include <sparrow/config/config.hpp>
 
-SPARROW_API int dummy() { return 1; }
-
+SPARROW_API int dummy()
+{
+    return 1;
+}
diff --git a/src/list_value.cpp b/src/list_value.cpp
index b92c6c1c..ab5e2460 100644
--- a/src/list_value.cpp
+++ b/src/list_value.cpp
@@ -13,10 +13,11 @@
 // limitations under the License.
 
 #include "sparrow/layout/list_layout/list_value.hpp"
-#include "sparrow/layout/dispatch.hpp"
 
 #include <iostream>
 
+#include "sparrow/layout/dispatch.hpp"
+
 namespace sparrow
 {
     list_value::list_value(const array_wrapper* flat_array, size_type index_begin, size_type index_end)
@@ -24,7 +25,7 @@ namespace sparrow
         , m_index_begin(index_begin)
         , m_index_end(index_end)
     {
-        SPARROW_ASSERT_TRUE(index_begin<=index_end);
+        SPARROW_ASSERT_TRUE(index_begin <= index_end);
     }
 
     auto list_value::size() const -> size_type
diff --git a/src/run_encoded_array.cpp b/src/run_encoded_array.cpp
index a5d56082..f9d47295 100644
--- a/src/run_encoded_array.cpp
+++ b/src/run_encoded_array.cpp
@@ -1,26 +1,25 @@
-#include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
+#include "sparrow/array.hpp"
 #include "sparrow/layout/array_helper.hpp"
 #include "sparrow/layout/dispatch.hpp"
 #include "sparrow/layout/primitive_array.hpp"
-#include "sparrow/array.hpp"
+#include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
+
+namespace sparrow
+{
+    template <class T>
+    concept usable_array = mpl::is_type_instance_of_v<T, primitive_array>
+                           && (std::same_as<typename T::inner_value_type, std::uint16_t>
+                               || std::same_as<typename T::inner_value_type, std::uint32_t>
+                               || std::same_as<typename T::inner_value_type, std::uint64_t>);
 
-namespace sparrow   
-{    
-    template<class T>
-    concept usable_array =
-             mpl::is_type_instance_of_v<T, primitive_array> && (
-             std::same_as<typename T::inner_value_type, std::uint16_t> ||
-             std::same_as<typename T::inner_value_type, std::uint32_t> ||
-             std::same_as<typename T::inner_value_type, std::uint64_t>);
-    
     auto run_end_encoded_array::get_acc_lengths_ptr(const array_wrapper& ar) -> acc_length_ptr_variant_type
     {
         return visit(
             [](const auto& actual_arr) -> acc_length_ptr_variant_type
             {
                 using array_type = std::decay_t<decltype(actual_arr)>;
-                
-                if constexpr(usable_array<array_type>)
+
+                if constexpr (usable_array<array_type>)
                 {
                     return actual_arr.data();
                 }
@@ -38,11 +37,7 @@ namespace sparrow
         return visit(
             [i, this](const auto& acc_lengths_ptr) -> array_traits::const_reference
             {
-                const auto it = std::upper_bound(
-                    acc_lengths_ptr,
-                    acc_lengths_ptr + this->m_encoded_length,
-                    i
-                );
+                const auto it = std::upper_bound(acc_lengths_ptr, acc_lengths_ptr + this->m_encoded_length, i);
                 // std::lower_bound returns an iterator, so we need to convert it to an index
                 const auto index = static_cast<std::size_t>(std::distance(acc_lengths_ptr, it));
                 return array_element(*p_encoded_values_array, static_cast<std::size_t>(index));
@@ -51,10 +46,8 @@ namespace sparrow
         );
     }
 
-    std::pair<std::int64_t, std::int64_t> run_end_encoded_array::extract_length_and_null_count(
-        const array& acc_lengths_arr, 
-        const array& encoded_values_arr
-    ) 
+    std::pair<std::int64_t, std::int64_t>
+    run_end_encoded_array::extract_length_and_null_count(const array& acc_lengths_arr, const array& encoded_values_arr)
     {
         SPARROW_ASSERT_TRUE(acc_lengths_arr.size() == encoded_values_arr.size());
 
@@ -64,32 +57,35 @@ namespace sparrow
         // visit the acc_lengths array
         std::int64_t length = 0;
         std::int64_t null_count = 0;
-        acc_lengths_arr.visit([&](const auto& acc_lengths_array)
+        acc_lengths_arr.visit(
+            [&](const auto& acc_lengths_array)
             {
-                if constexpr(usable_array<std::decay_t<decltype(acc_lengths_array)>>)
-                {   
+                if constexpr (usable_array<std::decay_t<decltype(acc_lengths_array)>>)
+                {
                     auto acc_length_data = acc_lengths_array.data();
                     // get the length of the array (ie last element in the acc_lengths array)
                     length = acc_length_data[raw_size - 1];
 
-                    if(raw_null_count == 0){
+                    if (raw_null_count == 0)
+                    {
                         return;
                     }
-                    for(std::size_t i = 0; i < raw_size; ++i)
+                    for (std::size_t i = 0; i < raw_size; ++i)
                     {
                         // check if the value is null
-                        if(!encoded_values_arr[i].has_value())
+                        if (!encoded_values_arr[i].has_value())
                         {
                             // how often is this value repeated?
-                            const auto run_length = i == 0 ? acc_length_data[i] : acc_length_data[i] - acc_length_data[i - 1];
+                            const auto run_length = i == 0 ? acc_length_data[i]
+                                                           : acc_length_data[i] - acc_length_data[i - 1];
                             null_count += run_length;
                             raw_null_count -= 1;
-                            if(raw_null_count == 0){
+                            if (raw_null_count == 0)
+                            {
                                 return;
                             }
                         }
                     }
-                    
                 }
                 else
                 {
@@ -100,12 +96,8 @@ namespace sparrow
         return {null_count, length};
     };
 
-
-    auto run_end_encoded_array::create_proxy(
-        array && acc_lengths,
-        array && encoded_values
-    ) -> arrow_proxy
-    {   
+    auto run_end_encoded_array::create_proxy(array&& acc_lengths, array&& encoded_values) -> arrow_proxy
+    {
         auto [null_count, length] = extract_length_and_null_count(acc_lengths, encoded_values);
 
         auto [acc_length_array, acc_length_schema] = extract_arrow_structures(std::move(acc_lengths));
@@ -124,24 +116,24 @@ namespace sparrow
 
         ArrowSchema schema = make_arrow_schema(
             std::string("+r"),
-            std::nullopt, // name
-            std::nullopt, // metadata
-            std::nullopt, // flags,
+            std::nullopt,  // name
+            std::nullopt,  // metadata
+            std::nullopt,  // flags,
             n_children,
-            child_schemas, // children
-            nullptr // dictionary
+            child_schemas,  // children
+            nullptr         // dictionary
         );
 
         std::vector<buffer<std::uint8_t>> arr_buffs = {};
 
         ArrowArray arr = make_arrow_array(
-            static_cast<std::int64_t>(length), // length
+            static_cast<std::int64_t>(length),  // length
             static_cast<int64_t>(null_count),
-            0, // offset
+            0,  // offset
             std::move(arr_buffs),
-            n_children, // n_children
-            child_arrays, // children
-            nullptr // dictionary
+            n_children,    // n_children
+            child_arrays,  // children
+            nullptr        // dictionary
         );
 
         return arrow_proxy{std::move(arr), std::move(schema)};
diff --git a/src/struct_value.cpp b/src/struct_value.cpp
index 2e41181a..b32d89cf 100644
--- a/src/struct_value.cpp
+++ b/src/struct_value.cpp
@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/layout/nested_value_types.hpp"
 #include "sparrow/layout/array_helper.hpp"
+#include "sparrow/layout/nested_value_types.hpp"
 
 namespace sparrow
 {
-    struct_value::struct_value(  const std::vector<child_ptr>& children, size_type index)
+    struct_value::struct_value(const std::vector<child_ptr>& children, size_type index)
         : p_children(&children)
         , m_index(index)
     {
diff --git a/test/better_junit_reporter.hpp b/test/better_junit_reporter.hpp
index 038c8ed5..3a9ceee2 100644
--- a/test/better_junit_reporter.hpp
+++ b/test/better_junit_reporter.hpp
@@ -309,6 +309,8 @@ void JUnitReporter::log_message(const doctest::MessageData& mb)
     );
 }
 
-void JUnitReporter::test_case_skipped(const doctest::TestCaseData&) {}
+void JUnitReporter::test_case_skipped(const doctest::TestCaseData&)
+{
+}
 
 DOCTEST_REGISTER_REPORTER("better_junit", 0, JUnitReporter);
diff --git a/test/external_array_data_creation.cpp b/test/external_array_data_creation.cpp
index 205c1781..64a0f4f8 100644
--- a/test/external_array_data_creation.cpp
+++ b/test/external_array_data_creation.cpp
@@ -89,12 +89,12 @@ namespace sparrow::test
 
     sparrow::buffer<std::uint8_t> make_size_buffer(const std::vector<size_t>& sizes, bool big)
     {
-        const auto buf_size = sizes.size()  * (big ? sizeof(std::uint64_t) : sizeof(std::uint32_t));
+        const auto buf_size = sizes.size() * (big ? sizeof(std::uint64_t) : sizeof(std::uint32_t));
         std::uint8_t* buf = new std::uint8_t[buf_size];
-        if(big)
+        if (big)
         {
             std::uint64_t* size_buf = reinterpret_cast<std::uint64_t*>(buf);
-            for(std::size_t i = 0; i < sizes.size(); ++i)
+            for (std::size_t i = 0; i < sizes.size(); ++i)
             {
                 size_buf[i] = sizes[i];
             }
@@ -102,7 +102,7 @@ namespace sparrow::test
         else
         {
             std::uint32_t* size_buf = reinterpret_cast<std::uint32_t*>(buf);
-            for(std::size_t i = 0; i < sizes.size(); ++i)
+            for (std::size_t i = 0; i < sizes.size(); ++i)
             {
                 size_buf[i] = static_cast<std::uint32_t>(sizes[i]);
             }
@@ -115,10 +115,11 @@ namespace sparrow::test
         ArrowArray& arr,
         ArrowSchema&& flat_value_schema,
         ArrowArray&& flat_value_arr,
-        const std::vector<std::size_t> & list_lengths,
-        const std::vector<std::size_t> & false_positions,
+        const std::vector<std::size_t>& list_lengths,
+        const std::vector<std::size_t>& false_positions,
         bool big_list
-    ){
+    )
+    {
         ArrowSchema** schema_children = new ArrowSchema*[1];
         schema_children[0] = new ArrowSchema(std::move(flat_value_schema));
         sparrow::fill_arrow_schema(
@@ -133,12 +134,11 @@ namespace sparrow::test
         );
 
         using buffer_type = sparrow::buffer<std::uint8_t>;
-        std::vector<buffer_type> arr_buffs = 
-        {
+        std::vector<buffer_type> arr_buffs = {
             sparrow::test::make_bitmap_buffer(list_lengths.size(), false_positions),
             make_offset_buffer_from_sizes(list_lengths, big_list)
         };
-        
+
         ArrowArray** array_children = new ArrowArray*[1];
         array_children[0] = new ArrowArray(std::move(flat_value_arr));
         sparrow::fill_arrow_array(
@@ -158,9 +158,10 @@ namespace sparrow::test
         ArrowArray& arr,
         ArrowSchema&& flat_value_schema,
         ArrowArray&& flat_value_arr,
-        const std::vector<std::size_t> & false_positions,
+        const std::vector<std::size_t>& false_positions,
         std::size_t list_size
-    ){
+    )
+    {
         SPARROW_ASSERT(list_size > 0, "list size must be greater than 0");
         SPARROW_ASSERT(list_size < 10, "just a test limitation st. format string can be on stack");
         // convert list size to string
@@ -180,11 +181,8 @@ namespace sparrow::test
 
         std::size_t arr_size = static_cast<std::size_t>(flat_value_arr.length) / list_size;
         using buffer_type = sparrow::buffer<std::uint8_t>;
-        std::vector<buffer_type> arr_buffs = 
-        {
-            sparrow::test::make_bitmap_buffer(arr_size, false_positions)
-        };
-        
+        std::vector<buffer_type> arr_buffs = {sparrow::test::make_bitmap_buffer(arr_size, false_positions)};
+
         ArrowArray** array_children = new ArrowArray*[1];
         array_children[0] = new ArrowArray(std::move(flat_value_arr));
         sparrow::fill_arrow_array(
@@ -199,16 +197,16 @@ namespace sparrow::test
         );
     }
 
-
     void fill_schema_and_array_for_list_view_layout(
         ArrowSchema& schema,
         ArrowArray& arr,
         ArrowSchema&& flat_value_schema,
         ArrowArray&& flat_value_arr,
-        const std::vector<std::size_t> & list_lengths,
-        const std::vector<std::size_t> & false_positions,
+        const std::vector<std::size_t>& list_lengths,
+        const std::vector<std::size_t>& false_positions,
         bool big_list
-    ){
+    )
+    {
         ArrowSchema** schema_children = new ArrowSchema*[1];
         schema_children[0] = new ArrowSchema(std::move(flat_value_schema));
         sparrow::fill_arrow_schema(
@@ -223,13 +221,12 @@ namespace sparrow::test
         );
 
         using buffer_type = sparrow::buffer<std::uint8_t>;
-        std::vector<buffer_type> arr_buffs = 
-        {
+        std::vector<buffer_type> arr_buffs = {
             sparrow::test::make_bitmap_buffer(list_lengths.size(), false_positions),
             make_offset_buffer_from_sizes(list_lengths, big_list),
             make_size_buffer(list_lengths, big_list)
         };
-        
+
         ArrowArray** array_children = new ArrowArray*[1];
         array_children[0] = new ArrowArray(std::move(flat_value_arr));
         sparrow::fill_arrow_array(
@@ -249,14 +246,19 @@ namespace sparrow::test
         ArrowArray& arr,
         std::vector<ArrowSchema>&& children_schemas,
         std::vector<ArrowArray>&& children_arrays,
-        const std::vector<std::size_t> & false_positions
+        const std::vector<std::size_t>& false_positions
     )
     {
         ArrowSchema** schema_children = new ArrowSchema*[children_schemas.size()];
-        std::transform(std::make_move_iterator(children_schemas.begin()),
-                       std::make_move_iterator(children_schemas.end()),
-                       schema_children,
-                       [](auto&& child) { return new ArrowSchema(std::move(child)); });
+        std::transform(
+            std::make_move_iterator(children_schemas.begin()),
+            std::make_move_iterator(children_schemas.end()),
+            schema_children,
+            [](auto&& child)
+            {
+                return new ArrowSchema(std::move(child));
+            }
+        );
         sparrow::fill_arrow_schema(
             schema,
             std::string_view("+s"),
@@ -268,19 +270,23 @@ namespace sparrow::test
             nullptr
         );
 
-        
+
         int64_t length = children_arrays.front().length;
         using buffer_type = sparrow::buffer<std::uint8_t>;
-        std::vector<buffer_type> arr_buffs = 
-        {
+        std::vector<buffer_type> arr_buffs = {
             sparrow::test::make_bitmap_buffer(static_cast<std::size_t>(length), false_positions),
         };
 
         ArrowArray** array_children = new ArrowArray*[children_arrays.size()];
-        std::transform(std::make_move_iterator(children_arrays.begin()),
-                       std::make_move_iterator(children_arrays.end()),
-                       array_children,
-                       [](auto&& child) { return new ArrowArray(std::move(child)); });
+        std::transform(
+            std::make_move_iterator(children_arrays.begin()),
+            std::make_move_iterator(children_arrays.end()),
+            array_children,
+            [](auto&& child)
+            {
+                return new ArrowArray(std::move(child));
+            }
+        );
         sparrow::fill_arrow_array(
             arr,
             length,
@@ -300,12 +306,18 @@ namespace sparrow::test
         std::vector<ArrowArray>&& children_arrays,
         const std::vector<std::uint8_t>& type_ids,
         const std::string& format
-    ){
+    )
+    {
         ArrowSchema** schema_children = new ArrowSchema*[children_schemas.size()];
-        std::transform(std::make_move_iterator(children_schemas.begin()),
-                       std::make_move_iterator(children_schemas.end()),
-                       schema_children,
-                       [](auto&& child) { return new ArrowSchema(std::move(child)); });
+        std::transform(
+            std::make_move_iterator(children_schemas.begin()),
+            std::make_move_iterator(children_schemas.end()),
+            schema_children,
+            [](auto&& child)
+            {
+                return new ArrowSchema(std::move(child));
+            }
+        );
         sparrow::fill_arrow_schema(
             schema,
             format,
@@ -320,13 +332,18 @@ namespace sparrow::test
         using buffer_type = sparrow::buffer<std::uint8_t>;
         buffer_type buf(type_ids.size());
         std::copy(type_ids.begin(), type_ids.end(), buf.begin());
-        std::vector<buffer_type> arr_buffs = { std::move(buf) };
-        
+        std::vector<buffer_type> arr_buffs = {std::move(buf)};
+
         ArrowArray** array_children = new ArrowArray*[children_arrays.size()];
-        std::transform(std::make_move_iterator(children_arrays.begin()),
-                       std::make_move_iterator(children_arrays.end()),
-                       array_children,
-                       [](auto&& child) { return new ArrowArray(std::move(child)); });
+        std::transform(
+            std::make_move_iterator(children_arrays.begin()),
+            std::make_move_iterator(children_arrays.end()),
+            array_children,
+            [](auto&& child)
+            {
+                return new ArrowArray(std::move(child));
+            }
+        );
 
         sparrow::fill_arrow_array(
             arr,
@@ -345,15 +362,21 @@ namespace sparrow::test
         ArrowArray& arr,
         std::vector<ArrowSchema>&& children_schemas,
         std::vector<ArrowArray>&& children_arrays,
-        const std::vector<std::uint8_t> & type_ids,
-        const std::vector<std::int32_t> & offsets,
-        const std::string & format
-    ){
+        const std::vector<std::uint8_t>& type_ids,
+        const std::vector<std::int32_t>& offsets,
+        const std::string& format
+    )
+    {
         ArrowSchema** schema_children = new ArrowSchema*[children_schemas.size()];
-        std::transform(std::make_move_iterator(children_schemas.begin()),
-                       std::make_move_iterator(children_schemas.end()),
-                       schema_children,
-                       [](auto&& child) { return new ArrowSchema(std::move(child)); });
+        std::transform(
+            std::make_move_iterator(children_schemas.begin()),
+            std::make_move_iterator(children_schemas.end()),
+            schema_children,
+            [](auto&& child)
+            {
+                return new ArrowSchema(std::move(child));
+            }
+        );
         sparrow::fill_arrow_schema(
             schema,
             format,
@@ -369,17 +392,22 @@ namespace sparrow::test
 
         buffer_type buf0(type_ids.size());
         std::copy(type_ids.begin(), type_ids.end(), buf0.begin());
-        
+
         buffer_type buf1(offsets.size() * sizeof(std::int32_t));
         std::copy(offsets.begin(), offsets.end(), buf1.data<std::int32_t>());
-        
-        std::vector<buffer_type> arr_buffs ={ std::move(buf0), std::move(buf1) };
-        
+
+        std::vector<buffer_type> arr_buffs = {std::move(buf0), std::move(buf1)};
+
         ArrowArray** array_children = new ArrowArray*[children_arrays.size()];
-        std::transform(std::make_move_iterator(children_arrays.begin()),
-                       std::make_move_iterator(children_arrays.end()),
-                       array_children,
-                       [](auto&& child) { return new ArrowArray(std::move(child)); });
+        std::transform(
+            std::make_move_iterator(children_arrays.begin()),
+            std::make_move_iterator(children_arrays.end()),
+            array_children,
+            [](auto&& child)
+            {
+                return new ArrowArray(std::move(child));
+            }
+        );
 
         sparrow::fill_arrow_array(
             arr,
diff --git a/test/external_array_data_creation.hpp b/test/external_array_data_creation.hpp
index c7f1ca4f..645e921f 100644
--- a/test/external_array_data_creation.hpp
+++ b/test/external_array_data_creation.hpp
@@ -24,7 +24,6 @@
 #include "sparrow/types/data_traits.hpp"
 #include "sparrow/types/data_type.hpp"
 
-
 namespace sparrow::test
 {
     void release_external_arrow_schema(ArrowSchema* schema);
diff --git a/test/junit_xml_writer.hpp b/test/junit_xml_writer.hpp
index 8ec1439b..2796f933 100644
--- a/test/junit_xml_writer.hpp
+++ b/test/junit_xml_writer.hpp
@@ -66,7 +66,7 @@ namespace sparrow
         {
             m_xml_writer.writeAttribute("type", message.m_type);
         }
-        if(message.m_line != 0)
+        if (message.m_line != 0)
         {
             m_xml_writer.writeAttribute("line", message.m_line);
         }
@@ -180,7 +180,7 @@ namespace sparrow
             .writeAttribute("assertions", test_suites.assertions_count())
             .writeAttribute("time", test_suites.total_time());
 
-        for (const auto& [_ , test_suite] : test_suites.m_test_suites)
+        for (const auto& [_, test_suite] : test_suites.m_test_suites)
         {
             write(test_suite);
         }
diff --git a/test/test_array_wrapper.cpp b/test/test_array_wrapper.cpp
index d260caa2..8b956a4d 100644
--- a/test/test_array_wrapper.cpp
+++ b/test/test_array_wrapper.cpp
@@ -16,15 +16,14 @@
 #include "sparrow/layout/null_array.hpp"
 #include "sparrow/layout/primitive_array.hpp"
 
-#include "external_array_data_creation.hpp"
-
 #include "doctest/doctest.h"
+#include "external_array_data_creation.hpp"
 
 namespace sparrow
 {
     using test::make_arrow_proxy;
     using testing_types = std::tuple<
-        null_array, 
+        null_array,
         primitive_array<std::int8_t>,
         primitive_array<std::uint8_t>,
         primitive_array<std::int16_t>,
@@ -35,8 +34,7 @@ namespace sparrow
         primitive_array<std::uint64_t>,
         primitive_array<float16_t>,
         primitive_array<float32_t>,
-        primitive_array<float64_t>
-    >;
+        primitive_array<float64_t>>;
 
     TEST_SUITE("array_wrapper")
     {
@@ -138,4 +136,4 @@ namespace sparrow
         }
         TEST_CASE_TEMPLATE_APPLY(array_wrapper_clone, testing_types);
     }
-} 
+}
diff --git a/test/test_arrow_array.cpp b/test/test_arrow_array.cpp
index 4a7fc0e8..7ae9d2a5 100644
--- a/test/test_arrow_array.cpp
+++ b/test/test_arrow_array.cpp
@@ -38,15 +38,7 @@ TEST_SUITE("C Data Interface")
             children[0] = new ArrowArray();
             children[1] = new ArrowArray();
             ArrowArray* dictionary = new ArrowArray();
-            auto array = sparrow::make_arrow_array(
-                1,
-                0,
-                0,
-                buffers_dummy,
-                2,
-                children,
-                dictionary
-            );
+            auto array = sparrow::make_arrow_array(1, 0, 0, buffers_dummy, 2, children, dictionary);
 
             array.release(&array);
             CHECK_EQ(array.buffers, nullptr);
diff --git a/test/test_buffer_adaptor.cpp b/test/test_buffer_adaptor.cpp
index d7763377..2472c53e 100644
--- a/test/test_buffer_adaptor.cpp
+++ b/test/test_buffer_adaptor.cpp
@@ -23,7 +23,8 @@
 
 #include "doctest/doctest.h"
 
-constexpr uint8_t operator""_u8(unsigned long long int value) {
+constexpr uint8_t operator""_u8(unsigned long long int value)
+{
     return static_cast<uint8_t>(value);
 }
 
diff --git a/test/test_builder.cpp b/test/test_builder.cpp
index da255407..fc7f5aab 100644
--- a/test/test_builder.cpp
+++ b/test/test_builder.cpp
@@ -12,29 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/builder/builder.hpp"
-#include "test_utils.hpp"
-
-#include <vector>
+#include <array>
 #include <tuple>
 #include <variant>
-#include <array>
+#include <vector>
 
+#include "sparrow/builder/builder.hpp"
+
+#include "test_utils.hpp"
 
 namespace sparrow
 {
     // to keep everything very short for very deep nested types
-    template<class T>
+    template <class T>
     using nt = nullable<T>;
 
     TEST_SUITE("builder")
     {
-        
         TEST_CASE("primitive-layout")
         {
             // arr[float]
             SUBCASE("float")
-            {   
+            {
                 std::vector<float> v{1.0, 2.0, 3.0};
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
@@ -45,7 +44,7 @@ namespace sparrow
             }
             // arr[double] (with nulls)
             SUBCASE("float-with-nulls")
-            {   
+            {
                 std::vector<nt<double>> v{1.0, 2.0, sparrow::nullval, 3.0};
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
@@ -58,15 +57,14 @@ namespace sparrow
                 CHECK_EQ(arr[0].value(), 1.0);
                 CHECK_EQ(arr[1].value(), 2.0);
                 CHECK_EQ(arr[3].value(), 3.0);
-
             }
         }
-        
+
         TEST_CASE("list-layout")
         {
             // list[float]
             SUBCASE("list[float]")
-            {   
+            {
                 std::vector<std::vector<float>> v{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f}};
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
@@ -75,18 +73,17 @@ namespace sparrow
                 REQUIRE_EQ(arr[0].value().size(), 3);
                 REQUIRE_EQ(arr[1].value().size(), 2);
 
-                CHECK_NULLABLE_VARIANT_EQ(arr[0].value()[0],  1.0f);
-                CHECK_NULLABLE_VARIANT_EQ(arr[0].value()[1],  2.0f);
-                CHECK_NULLABLE_VARIANT_EQ(arr[0].value()[2],  3.0f);
-                CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[0],  4.0f);
-                CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[1],  5.0f);
+                CHECK_NULLABLE_VARIANT_EQ(arr[0].value()[0], 1.0f);
+                CHECK_NULLABLE_VARIANT_EQ(arr[0].value()[1], 2.0f);
+                CHECK_NULLABLE_VARIANT_EQ(arr[0].value()[2], 3.0f);
+                CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[0], 4.0f);
+                CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[1], 5.0f);
 
                 // check that the children are **NOT** dict-encoded
                 REQUIRE(!arr.raw_flat_array()->is_dictionary());
-
             }
             SUBCASE("list[list[float]]")
-            {   
+            {
                 std::vector<std::vector<std::vector<float>>> v{
                     {{1.2f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}},
                     {{7.0f, 8.0f, 9.0f}, {10.0f, 11.0f, 12.0f}}
@@ -96,7 +93,7 @@ namespace sparrow
                 REQUIRE_EQ(arr.size(), 2);
             }
             SUBCASE("options")
-            {   
+            {
                 SUBCASE("with_large_list_flag")
                 {
                     std::vector<std::vector<float>> v{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f}};
@@ -112,25 +109,20 @@ namespace sparrow
                     using array_type = std::decay_t<decltype(arr)>;
                     static_assert(std::is_same_v<array_type, sparrow::list_array>);
                 }
-
             }
         }
-        
+
         TEST_CASE("struct-layout")
         {
             // struct<float, float>
-            {   
-                std::vector<std::tuple<float, int>> v{
-                    {1.5f, 2},
-                    {3.5f, 4},
-                    {5.5f, 6}
-                };
+            {
+                std::vector<std::tuple<float, int>> v{{1.5f, 2}, {3.5f, 4}, {5.5f, 6}};
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
                 REQUIRE_EQ(arr.size(), 3);
             }
             // struct<float, float> (with nulls)
-            {   
+            {
                 std::vector<nt<std::tuple<float, int>>> v{
                     std::tuple<float, int>{1.5f, 2},
                     sparrow::nullval,
@@ -141,8 +133,8 @@ namespace sparrow
                 REQUIRE_EQ(arr.size(), 3);
             }
             // struct<list[float], uint16>
-            {   
-                std::vector<std::tuple<std::vector<float>,std::uint16_t>> v{
+            {
+                std::vector<std::tuple<std::vector<float>, std::uint16_t>> v{
                     {{1.0f, 2.0f, 3.0f}, 1},
                     {{4.0f, 5.0f, 6.0f}, 2},
                     {{7.0f, 8.0f, 9.0f}, 3}
@@ -152,22 +144,18 @@ namespace sparrow
                 REQUIRE_EQ(arr.size(), 3);
             }
         }
-        
+
         TEST_CASE("fixed-sized-list-layout")
         {
             // fixed_sized_list<float, 3>
-            {   
-                std::vector<std::array<float, 3>> v{
-                    {1.0f, 2.0f, 3.0f},
-                    {4.0f, 5.0f, 6.0f},
-                    {7.0f, 8.0f, 9.0f}
-                };
+            {
+                std::vector<std::array<float, 3>> v{{1.0f, 2.0f, 3.0f}, {4.0f, 5.0f, 6.0f}, {7.0f, 8.0f, 9.0f}};
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
                 REQUIRE_EQ(arr.size(), 3);
             }
             // fixed_sized_list<float, 3>  with nulls
-            {   
+            {
                 std::vector<nt<std::array<nt<float>, 3>>> v{
                     std::array<nt<float>, 3>{1.0f, sparrow::nullval, 3.0f},
                     sparrow::nullval,
@@ -175,14 +163,13 @@ namespace sparrow
                 };
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
-                
             }
         }
-        
+
         TEST_CASE("variable-sized-binary")
         {
             // variable_size_binary
-            {   
+            {
                 std::vector<std::string> v{
                     "hello",
                     " ",
@@ -196,15 +183,10 @@ namespace sparrow
                 CHECK_EQ(arr[1].value(), " ");
                 CHECK_EQ(arr[2].value(), "world");
                 CHECK_EQ(arr[3].value(), "!");
-
             }
             // variable_size_binary with nulls
-            {   
-                std::vector<nt<std::string>> v{
-                    "hello",
-                    sparrow::nullval,
-                    "world!"
-                };
+            {
+                std::vector<nt<std::string>> v{"hello", sparrow::nullval, "world!"};
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
                 REQUIRE_EQ(arr.size(), 3);
@@ -214,20 +196,15 @@ namespace sparrow
 
                 CHECK_EQ(arr[0].value(), "hello");
                 CHECK_EQ(arr[2].value(), "world!");
-                
             }
         }
-        
+
         TEST_CASE("sparse-union")
         {
             SUBCASE("simple")
-            {   
+            {
                 using variant_type = std::variant<int, float, std::string>;
-                std::vector<variant_type> v{
-                    1,
-                    2.0f,
-                    "hello"
-                };
+                std::vector<variant_type> v{1, 2.0f, "hello"};
 
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
@@ -243,4 +220,3 @@ namespace sparrow
     }
 
 }
-
diff --git a/test/test_builder_dict_encoded.cpp b/test/test_builder_dict_encoded.cpp
index f1f6114b..4371aed7 100644
--- a/test/test_builder_dict_encoded.cpp
+++ b/test/test_builder_dict_encoded.cpp
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/builder/builder.hpp"
-#include "test_utils.hpp"
-
-#include <vector>
+#include <array>
 #include <tuple>
 #include <variant>
-#include <array>
+#include <vector>
 
+#include "sparrow/builder/builder.hpp"
+
+#include "test_utils.hpp"
 
 namespace sparrow
 {
@@ -28,13 +28,11 @@ namespace sparrow
     {
         TEST_CASE("dict-encoded")
         {
-            SUBCASE("dict[int]") 
+            SUBCASE("dict[int]")
             {
                 SUBCASE("no-nulls")
                 {
-                    dict_encode<std::vector<int>> v{
-                        std::vector<int>{1, 1, 1, 2}
-                    };
+                    dict_encode<std::vector<int>> v{std::vector<int>{1, 1, 1, 2}};
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
                     using array_type = std::decay_t<decltype(arr)>;
@@ -50,10 +48,8 @@ namespace sparrow
                 SUBCASE("with-nulls")
                 {
                     dict_encode<std::vector<nullable<int>>> v{
-                        std::vector<nullable<int>>{
-                            1, 1, sparrow::nullval, 2
-                        }
-                    }; 
+                        std::vector<nullable<int>>{1, 1, sparrow::nullval, 2}
+                    };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
 
@@ -68,7 +64,6 @@ namespace sparrow
             }
             SUBCASE("dict[string]")
             {
-
                 dict_encode<std::vector<nullable<std::string>>> v{
                     std::vector<nullable<std::string>>{"hello", "world", "hello", "world", nullable<std::string>{}}
                 };
@@ -83,22 +78,20 @@ namespace sparrow
                 CHECK_NULLABLE_VARIANT_EQ(arr[2], std::string_view("hello"));
                 CHECK_NULLABLE_VARIANT_EQ(arr[3], std::string_view("world"));
                 CHECK(!arr[4].has_value());
-                
             }
             SUBCASE("dict[struct[int,float]]")
-            {   
+            {
                 using tuple_type = std::tuple<nullable<int>, std::uint16_t>;
                 using nullable_tuple_type = nullable<tuple_type>;
                 using vector_type = std::vector<nullable_tuple_type>;
 
-                dict_encode<vector_type> v{
-                    vector_type{
-                        nullable_tuple_type{tuple_type{nullable<int>{1}, std::uint16_t(1)}},
-                        nullable_tuple_type{},
-                        nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}},
-                        nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}}
-                    }
-                    
+                dict_encode<vector_type> v{vector_type{
+                    nullable_tuple_type{tuple_type{nullable<int>{1}, std::uint16_t(1)}},
+                    nullable_tuple_type{},
+                    nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}},
+                    nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}}
+                }
+
                 };
 
                 auto arr = sparrow::build(v);
@@ -107,7 +100,7 @@ namespace sparrow
                 static_assert(std::is_same_v<array_type, sparrow::dictionary_encoded_array<std::uint64_t>>);
 
                 REQUIRE_EQ(arr.size(), 4);
-                
+
                 // 0
                 auto arr0 = std::get<nullable<struct_value>>(arr[0]);
                 REQUIRE(arr0.has_value());
@@ -129,15 +122,10 @@ namespace sparrow
                 REQUIRE(arr3.has_value());
                 CHECK(!arr3.value()[0].has_value());
                 CHECK_NULLABLE_VARIANT_EQ(arr3.value()[1], std::uint16_t(42));
-
             }
             SUBCASE("dict[list[int]]")
             {
-                dict_encode<std::vector<std::vector<int>>> v{
-                    std::vector<std::vector<int>>{
-                        {1, 2, 3},
-                        {4, 5, 6}
-                    }
+                dict_encode<std::vector<std::vector<int>>> v{std::vector<std::vector<int>>{{1, 2, 3}, {4, 5, 6}}
                 };
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
@@ -148,8 +136,8 @@ namespace sparrow
                 CHECK_EQ(std::get<nullable<list_value>>(arr[0]).value().size(), 3);
                 CHECK_NULLABLE_VARIANT_EQ(std::get<nullable<list_value>>(arr[0]).value()[0], 1);
                 CHECK_NULLABLE_VARIANT_EQ(std::get<nullable<list_value>>(arr[0]).value()[1], 2);
-                CHECK_NULLABLE_VARIANT_EQ(std::get<nullable<list_value>>(arr[0]).value()[2], 3);    
-        }
+                CHECK_NULLABLE_VARIANT_EQ(std::get<nullable<list_value>>(arr[0]).value()[2], 3);
+            }
             SUBCASE("dict[union[int, string]]")
             {
                 dict_encode<std::vector<std::variant<int, std::string>>> v{
@@ -177,15 +165,9 @@ namespace sparrow
                 SUBCASE("without-nulls")
                 {
                     std::vector<dict_encode<std::vector<int>>> v{
-                        dict_encode<std::vector<int>>{
-                            std::vector<int>{1, 2, 3}
-                        },
-                        dict_encode<std::vector<int>>{
-                            std::vector<int>{4, 5}
-                        },
-                        dict_encode<std::vector<int>>{
-                            std::vector<int>{6}
-                        }
+                        dict_encode<std::vector<int>>{std::vector<int>{1, 2, 3}},
+                        dict_encode<std::vector<int>>{std::vector<int>{4, 5}},
+                        dict_encode<std::vector<int>>{std::vector<int>{6}}
                     };
 
                     auto arr = sparrow::build(v);
@@ -196,12 +178,12 @@ namespace sparrow
                     // ensure that the child is dict-encoded
                     REQUIRE(arr.raw_flat_array()->is_dictionary());
 
-                    for(std::size_t i = 0; i < 3; ++i)
+                    for (std::size_t i = 0; i < 3; ++i)
                     {
                         auto arr_val = arr[i];
                         REQUIRE(arr_val.has_value());
                         REQUIRE_EQ(arr_val.value().size(), v[i].get().size());
-                        for(std::size_t j = 0; j < v[i].get().size(); ++j)
+                        for (std::size_t j = 0; j < v[i].get().size(); ++j)
                         {
                             CHECK_NULLABLE_VARIANT_EQ(arr_val.value()[j], v[i].get()[j]);
                         }
@@ -210,16 +192,10 @@ namespace sparrow
                 SUBCASE("with-nulls")
                 {
                     std::vector<nullable<dict_encode<std::vector<nullable<int>>>>> v{
-                        dict_encode<std::vector<nullable<int>>>{
-                            std::vector<nullable<int>>{1, 2, 3}
-                        },
+                        dict_encode<std::vector<nullable<int>>>{std::vector<nullable<int>>{1, 2, 3}},
                         sparrow::nullval,
-                        dict_encode<std::vector<nullable<int>>>{
-                            std::vector<nullable<int>>{6}
-                        },
-                        dict_encode<std::vector<nullable<int>>>{
-                            std::vector<nullable<int>>{nullable<int>{}}
-                        },
+                        dict_encode<std::vector<nullable<int>>>{std::vector<nullable<int>>{6}},
+                        dict_encode<std::vector<nullable<int>>>{std::vector<nullable<int>>{nullable<int>{}}},
                     };
 
                     auto arr = sparrow::build(v);
@@ -251,15 +227,11 @@ namespace sparrow
                 SUBCASE("without-nulls")
                 {
                     std::vector<dict_encode<std::array<std::string, 3>>> v{
-                        dict_encode<std::array<std::string, 3>>{
-                            std::array<std::string, 3>{"one", "two", "three"}
+                        dict_encode<std::array<std::string, 3>>{std::array<std::string, 3>{"one", "two", "three"}
                         },
-                        dict_encode<std::array<std::string, 3>>{
-                            std::array<std::string, 3>{"one", "two", "three"}
+                        dict_encode<std::array<std::string, 3>>{std::array<std::string, 3>{"one", "two", "three"}
                         },
-                        dict_encode<std::array<std::string, 3>>{
-                            std::array<std::string, 3>{"one", "two", "four"}
-                        }
+                        dict_encode<std::array<std::string, 3>>{std::array<std::string, 3>{"one", "two", "four"}}
                     };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
@@ -269,27 +241,24 @@ namespace sparrow
                     // ensure that the child is dict-encoded
                     REQUIRE(arr.raw_flat_array()->is_dictionary());
 
-                    for(std::size_t i = 0; i < 3; ++i)
+                    for (std::size_t i = 0; i < 3; ++i)
                     {
                         auto arr_val = arr[i];
                         REQUIRE(arr_val.has_value());
                         REQUIRE_EQ(arr_val.value().size(), 3);
-                        for(std::size_t j = 0; j < 3; ++j)
+                        for (std::size_t j = 0; j < 3; ++j)
                         {
                             CHECK_NULLABLE_VARIANT_EQ(arr_val.value()[j], std::string_view(v[i].get()[j]));
                         }
                     }
                 }
                 SUBCASE("with-nulls")
-                {   
+                {
                     std::vector<nullable<dict_encode<std::array<std::string, 3>>>> v{
-                        dict_encode<std::array<std::string, 3>>{
-                            std::array<std::string, 3>{"one", "two", "three"}
+                        dict_encode<std::array<std::string, 3>>{std::array<std::string, 3>{"one", "two", "three"}
                         },
                         sparrow::nullval,
-                        dict_encode<std::array<std::string, 3>>{
-                            std::array<std::string, 3>{"one", "two", "three"}
-                        }
+                        dict_encode<std::array<std::string, 3>>{std::array<std::string, 3>{"one", "two", "three"}}
                     };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
@@ -302,25 +271,25 @@ namespace sparrow
                     REQUIRE(arr[0].has_value());
                     REQUIRE_FALSE(arr[1].has_value());
                     REQUIRE(arr[2].has_value());
-                }   
-            }           
+                }
+            }
             SUBCASE("struct[dict[string], int]")
-            {   
+            {
                 SUBCASE("with-nulls")
                 {
-                    std::vector<nullable<std::tuple<dict_encode<nullable<std::string>>,int>>> v 
-                    {
+                    std::vector<nullable<std::tuple<dict_encode<nullable<std::string>>, int>>> v{
                         std::tuple<dict_encode<nullable<std::string>>, int>{
-                            dict_encode<nullable<std::string>>{"hello"}, 1
+                            dict_encode<nullable<std::string>>{"hello"},
+                            1
                         },
                         nullable<std::tuple<dict_encode<nullable<std::string>>, int>>{},
                         std::tuple<dict_encode<nullable<std::string>>, int>{
-                            dict_encode<nullable<std::string>>{"!"}, 3
+                            dict_encode<nullable<std::string>>{"!"},
+                            3
                         },
                         std::tuple<dict_encode<nullable<std::string>>, int>{
-                            dict_encode<nullable<std::string>>{
-                                nullable<std::string>{}
-                            }, 4
+                            dict_encode<nullable<std::string>>{nullable<std::string>{}},
+                            4
                         }
                     };
                     auto arr = sparrow::build(v);
@@ -345,22 +314,17 @@ namespace sparrow
                     REQUIRE(arr[3].has_value());
                     CHECK_NULLABLE_VARIANT_EQ(arr[3].value()[1], int(4));
                     REQUIRE_FALSE(arr[3].value()[0].has_value());
-                    
                 }
             }
             SUBCASE("union[[dict[string], int]]")
             {
                 SUBCASE("without-nulls")
-                {   
+                {
                     using variant_type = std::variant<dict_encode<std::string>, int>;
 
                     std::vector<variant_type> v{
-                        variant_type{
-                            dict_encode<std::string>{"hello"}
-                        },
-                        variant_type{
-                            int(42)
-                        },
+                        variant_type{dict_encode<std::string>{"hello"}},
+                        variant_type{int(42)},
                     };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
@@ -372,11 +336,8 @@ namespace sparrow
                     CHECK_NULLABLE_VARIANT_EQ(arr[1], int(42));
                 }
                 SUBCASE("with-nulls")
-                {   
-                    using variant_type = std::variant<
-                        dict_encode<nullable<std::string>>, 
-                        nullable<int>
-                    >;
+                {
+                    using variant_type = std::variant<dict_encode<nullable<std::string>>, nullable<int>>;
                     std::vector<variant_type> v{
                         variant_type{nullable<std::string>{"hello"}},
                         variant_type{nullable<int>{}},
@@ -393,10 +354,8 @@ namespace sparrow
 
                     CHECK(!arr[1].has_value());
                     CHECK(!arr[2].has_value());
-                    
                 }
             }
         }
     }
 }
-
diff --git a/test/test_builder_run_end_encoded.cpp b/test/test_builder_run_end_encoded.cpp
index d57970fe..955a7253 100644
--- a/test/test_builder_run_end_encoded.cpp
+++ b/test/test_builder_run_end_encoded.cpp
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/builder/builder.hpp"
-#include "test_utils.hpp"
-
-#include <vector>
+#include <array>
 #include <tuple>
 #include <variant>
-#include <array>
+#include <vector>
 
+#include "sparrow/builder/builder.hpp"
+
+#include "test_utils.hpp"
 
 namespace sparrow
 {
@@ -27,13 +27,11 @@ namespace sparrow
     {
         TEST_CASE("run-end-encoded")
         {
-            SUBCASE("run_end_encode[int]") 
+            SUBCASE("run_end_encode[int]")
             {
                 SUBCASE("no-nulls")
                 {
-                    run_end_encode<std::vector<int>> v{
-                        std::vector<int>{1, 1, 1, 2}
-                    };
+                    run_end_encode<std::vector<int>> v{std::vector<int>{1, 1, 1, 2}};
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
                     using array_type = std::decay_t<decltype(arr)>;
@@ -49,10 +47,8 @@ namespace sparrow
                 SUBCASE("with-nulls")
                 {
                     run_end_encode<std::vector<nullable<int>>> v{
-                        std::vector<nullable<int>>{
-                            1, 1, sparrow::nullval, 2
-                        }
-                    }; 
+                        std::vector<nullable<int>>{1, 1, sparrow::nullval, 2}
+                    };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
 
@@ -65,10 +61,9 @@ namespace sparrow
                     CHECK_NULLABLE_VARIANT_EQ(arr[3], 2);
                 }
             }
-            
+
             SUBCASE("run_end_encode[string]")
             {
-
                 run_end_encode<std::vector<nullable<std::string>>> v{
                     std::vector<nullable<std::string>>{"hello", "world", "hello", "world", nullable<std::string>{}}
                 };
@@ -83,24 +78,22 @@ namespace sparrow
                 CHECK_NULLABLE_VARIANT_EQ(arr[2], std::string_view("hello"));
                 CHECK_NULLABLE_VARIANT_EQ(arr[3], std::string_view("world"));
                 CHECK(!arr[4].has_value());
-                
             }
-            
+
             SUBCASE("run_end_encode[struct[int,float]]")
-            {   
+            {
                 using tuple_type = std::tuple<nullable<int>, std::uint16_t>;
                 using nullable_tuple_type = nullable<tuple_type>;
                 using vector_type = std::vector<nullable_tuple_type>;
 
 
-                run_end_encode<vector_type> v{
-                    vector_type{
-                        nullable_tuple_type{tuple_type{nullable<int>{1}, std::uint16_t(1)}},
-                        nullable_tuple_type{},
-                        nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}},
-                        nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}}
-                    }
-                    
+                run_end_encode<vector_type> v{vector_type{
+                    nullable_tuple_type{tuple_type{nullable<int>{1}, std::uint16_t(1)}},
+                    nullable_tuple_type{},
+                    nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}},
+                    nullable_tuple_type{tuple_type{nullable<int>{}, std::uint16_t(42)}}
+                }
+
                 };
 
                 auto arr = sparrow::build(v);
@@ -110,7 +103,7 @@ namespace sparrow
 
 
                 REQUIRE_EQ(arr.size(), 4);
-                
+
                 // 0
                 auto arr0 = std::get<nullable<struct_value>>(arr[0]);
                 REQUIRE(arr0.has_value());
@@ -132,15 +125,11 @@ namespace sparrow
                 REQUIRE(arr3.has_value());
                 CHECK(!arr3.value()[0].has_value());
                 CHECK_NULLABLE_VARIANT_EQ(arr3.value()[1], std::uint16_t(42));
-
             }
-        SUBCASE("run_end_encode[list[int]]")
+            SUBCASE("run_end_encode[list[int]]")
             {
                 run_end_encode<std::vector<std::vector<int>>> v{
-                    std::vector<std::vector<int>>{
-                        {1, 2, 3},
-                        {4, 5, 6}
-                    }
+                    std::vector<std::vector<int>>{{1, 2, 3}, {4, 5, 6}}
                 };
                 auto arr = sparrow::build(v);
                 test::generic_consistency_test(arr);
@@ -183,15 +172,9 @@ namespace sparrow
                 SUBCASE("without-nulls")
                 {
                     std::vector<run_end_encode<std::vector<int>>> v{
-                        run_end_encode<std::vector<int>>{
-                            std::vector<int>{1, 2, 3}
-                        },
-                        run_end_encode<std::vector<int>>{
-                            std::vector<int>{4, 5}
-                        },
-                        run_end_encode<std::vector<int>>{
-                            std::vector<int>{6}
-                        }
+                        run_end_encode<std::vector<int>>{std::vector<int>{1, 2, 3}},
+                        run_end_encode<std::vector<int>>{std::vector<int>{4, 5}},
+                        run_end_encode<std::vector<int>>{std::vector<int>{6}}
                     };
 
                     auto arr = sparrow::build(v);
@@ -202,12 +185,12 @@ namespace sparrow
                     // ensure that the child is run_end_encoded
                     REQUIRE(arr.raw_flat_array()->data_type() == data_type::RUN_ENCODED);
 
-                    for(std::size_t i = 0; i < 3; ++i)
+                    for (std::size_t i = 0; i < 3; ++i)
                     {
                         auto arr_val = arr[i];
                         REQUIRE(arr_val.has_value());
                         REQUIRE_EQ(arr_val.value().size(), v[i].get().size());
-                        for(std::size_t j = 0; j < v[i].get().size(); ++j)
+                        for (std::size_t j = 0; j < v[i].get().size(); ++j)
                         {
                             CHECK_NULLABLE_VARIANT_EQ(arr_val.value()[j], v[i].get()[j]);
                         }
@@ -215,18 +198,11 @@ namespace sparrow
                 }
                 SUBCASE("with-nulls")
                 {
-        
                     std::vector<nullable<run_end_encode<std::vector<nullable<int>>>>> v{
-                        run_end_encode<std::vector<nullable<int>>>{
-                            std::vector<nullable<int>>{1, 2, 3}
-                        },
+                        run_end_encode<std::vector<nullable<int>>>{std::vector<nullable<int>>{1, 2, 3}},
                         sparrow::nullval,
-                        run_end_encode<std::vector<nullable<int>>>{
-                            std::vector<nullable<int>>{6}
-                        },
-                        run_end_encode<std::vector<nullable<int>>>{
-                            std::vector<nullable<int>>{nullable<int>{}}
-                        },
+                        run_end_encode<std::vector<nullable<int>>>{std::vector<nullable<int>>{6}},
+                        run_end_encode<std::vector<nullable<int>>>{std::vector<nullable<int>>{nullable<int>{}}},
                     };
 
                     auto arr = sparrow::build(v);
@@ -262,9 +238,7 @@ namespace sparrow
                         run_end_encode<std::array<std::string, 3>>{
                             std::array<std::string, 3>{"one", "two", "three"}
                         },
-                        run_end_encode<std::array<std::string, 3>>{
-                            std::array<std::string, 3>{"one", "two", "four"}
-                        }
+                        run_end_encode<std::array<std::string, 3>>{std::array<std::string, 3>{"one", "two", "four"}}
                     };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
@@ -275,12 +249,12 @@ namespace sparrow
                     // ensure that the child is run_end_encoded
                     REQUIRE(arr.raw_flat_array()->data_type() == data_type::RUN_ENCODED);
 
-                    for(std::size_t i = 0; i < 3; ++i)
+                    for (std::size_t i = 0; i < 3; ++i)
                     {
                         auto arr_val = arr[i];
                         REQUIRE(arr_val.has_value());
                         REQUIRE_EQ(arr_val.value().size(), 3);
-                        for(std::size_t j = 0; j < 3; ++j)
+                        for (std::size_t j = 0; j < 3; ++j)
                         {
                             CHECK_NULLABLE_VARIANT_EQ(arr_val.value()[j], std::string_view(v[i].get()[j]));
                         }
@@ -309,25 +283,25 @@ namespace sparrow
                     REQUIRE(arr[0].has_value());
                     REQUIRE_FALSE(arr[1].has_value());
                     REQUIRE(arr[2].has_value());
-                }   
-            }           
+                }
+            }
             SUBCASE("struct[run_end_encode[string], int]")
-            {   
+            {
                 SUBCASE("with-nulls")
                 {
-                    std::vector<nullable<std::tuple<run_end_encode<nullable<std::string>>,int>>> v 
-                    {
+                    std::vector<nullable<std::tuple<run_end_encode<nullable<std::string>>, int>>> v{
                         std::tuple<run_end_encode<nullable<std::string>>, int>{
-                            run_end_encode<nullable<std::string>>{"hello"}, 1
+                            run_end_encode<nullable<std::string>>{"hello"},
+                            1
                         },
                         nullable<std::tuple<run_end_encode<nullable<std::string>>, int>>{},
                         std::tuple<run_end_encode<nullable<std::string>>, int>{
-                            run_end_encode<nullable<std::string>>{"!"}, 3
+                            run_end_encode<nullable<std::string>>{"!"},
+                            3
                         },
                         std::tuple<run_end_encode<nullable<std::string>>, int>{
-                            run_end_encode<nullable<std::string>>{
-                                nullable<std::string>{}
-                            }, 4
+                            run_end_encode<nullable<std::string>>{nullable<std::string>{}},
+                            4
                         }
                     };
                     auto arr = sparrow::build(v);
@@ -351,21 +325,16 @@ namespace sparrow
                     REQUIRE(arr[3].has_value());
                     CHECK_NULLABLE_VARIANT_EQ(arr[3].value()[1], int(4));
                     REQUIRE_FALSE(arr[3].value()[0].has_value());
-                    
                 }
             }
             SUBCASE("union[[run_end_encode[string], int]]")
             {
                 SUBCASE("without-nulls")
-                {   
+                {
                     using variant_type = std::variant<run_end_encode<std::string>, int>;
                     std::vector<variant_type> v{
-                        variant_type{
-                            run_end_encode<std::string>{"hello"}
-                        },
-                        variant_type{
-                            int(42)
-                        },
+                        variant_type{run_end_encode<std::string>{"hello"}},
+                        variant_type{int(42)},
                     };
                     auto arr = sparrow::build(v);
                     test::generic_consistency_test(arr);
@@ -377,11 +346,8 @@ namespace sparrow
                     CHECK_NULLABLE_VARIANT_EQ(arr[1], int(42));
                 }
                 SUBCASE("with-nulls")
-                {   
-                    using variant_type = std::variant<
-                        run_end_encode<nullable<std::string>>, 
-                        nullable<int>
-                    >;
+                {
+                    using variant_type = std::variant<run_end_encode<nullable<std::string>>, nullable<int>>;
 
                     std::vector<variant_type> v{
                         variant_type{nullable<std::string>{"hello"}},
@@ -398,10 +364,9 @@ namespace sparrow
                     CHECK_NULLABLE_VARIANT_EQ(arr[0], std::string_view("hello"));
 
                     CHECK(!arr[1].has_value());
-                    CHECK(!arr[2].has_value()); 
+                    CHECK(!arr[2].has_value());
                 }
             }
         }
     }
 }
-
diff --git a/test/test_builder_utils.cpp b/test/test_builder_utils.cpp
index fc97976b..120e55e9 100644
--- a/test/test_builder_utils.cpp
+++ b/test/test_builder_utils.cpp
@@ -12,105 +12,120 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/builder/builder_utils.hpp"
-#include "test_utils.hpp"
-
-#include <vector>
+#include <array>
 #include <tuple>
 #include <variant>
-#include <array>
+#include <vector>
+
+#include "sparrow/builder/builder_utils.hpp"
+
+#include "test_utils.hpp"
 
 namespace sparrow
-{   
+{
     class my_variant : public std::variant<int, double>
     {
     public:
+
         using std::variant<int, double>::variant;
     };
 }
 
-template<std::size_t I>
+template <std::size_t I>
 struct std::variant_alternative<I, sparrow::my_variant>
 {
     using type = std::variant_alternative_t<I, std::variant<int, double>>;
 };
 
-namespace sparrow{
+namespace sparrow
+{
 
     TEST_SUITE("builder-utils")
-    {   
+    {
         TEST_CASE("for_each_index")
         {
             SUBCASE("empty")
             {
                 // the return type of for_each_index indicates if the loop was run to completion
-                detail::for_each_index<0>([](auto i) 
-                {
-                    // should not be called
-                    CHECK_FALSE(decltype(i)::value, 0);
-                    CHECK(false);
-                    return true; // should not be called
-                });
+                detail::for_each_index<0>(
+                    [](auto i)
+                    {
+                        // should not be called
+                        CHECK_FALSE(decltype(i)::value, 0);
+                        CHECK(false);
+                        return true;  // should not be called
+                    }
+                );
             }
             SUBCASE("non-empty")
             {
                 int c = 0;
-                detail::for_each_index<3>([&](auto i)
-                {
-                    CHECK_EQ(decltype(i)::value, c);
-                    ++c;
-                    return true;
-                });
+                detail::for_each_index<3>(
+                    [&](auto i)
+                    {
+                        CHECK_EQ(decltype(i)::value, c);
+                        ++c;
+                        return true;
+                    }
+                );
                 CHECK_EQ(c, 3);
             }
         }
 
         TEST_CASE("exitable_for_each_index")
-        {   
+        {
             SUBCASE("empty")
             {
                 // the return type of exitable_for_each_index indicates if the loop was run to completion
-                CHECK(detail::exitable_for_each_index<0>([](auto  i)
-                {
-                    // should not be called
-                    CHECK_FALSE(decltype(i)::value, 0);
-                    CHECK(false);
-                    return true; // should not be called
-                }));
+                CHECK(detail::exitable_for_each_index<0>(
+                    [](auto i)
+                    {
+                        // should not be called
+                        CHECK_FALSE(decltype(i)::value, 0);
+                        CHECK(false);
+                        return true;  // should not be called
+                    }
+                ));
             }
             SUBCASE("exit right away")
             {
                 // the return type of exitable_for_each_index indicates if the loop was run to completion
-                CHECK_FALSE(detail::exitable_for_each_index<3>([](auto i)
-                {
-                    // exit right away
-                    CHECK(decltype(i)::value == 0);
-                    return false;
-                }));
+                CHECK_FALSE(detail::exitable_for_each_index<3>(
+                    [](auto i)
+                    {
+                        // exit right away
+                        CHECK(decltype(i)::value == 0);
+                        return false;
+                    }
+                ));
             }
-            
+
             SUBCASE("full")
             {
-                int c=0;
-                CHECK(detail::exitable_for_each_index<3>([&](auto i)
-                {
-                    // run to completion
-                    CHECK_EQ(decltype(i)::value, c);
-                    ++c;
-                    return true;
-                }));
+                int c = 0;
+                CHECK(detail::exitable_for_each_index<3>(
+                    [&](auto i)
+                    {
+                        // run to completion
+                        CHECK_EQ(decltype(i)::value, c);
+                        ++c;
+                        return true;
+                    }
+                ));
                 CHECK_EQ(c, 3);
             }
 
             SUBCASE("half")
             {
                 int c = 0;
-                CHECK_FALSE(detail::exitable_for_each_index<4>([&](auto i)
-                {
-                    CHECK_EQ(decltype(i)::value, c);
-                    ++c;
-                    return decltype(i)::value < 2;
-                }));
+                CHECK_FALSE(detail::exitable_for_each_index<4>(
+                    [&](auto i)
+                    {
+                        CHECK_EQ(decltype(i)::value, c);
+                        ++c;
+                        return decltype(i)::value < 2;
+                    }
+                ));
                 CHECK_EQ(c, 3);
             }
         }
@@ -134,7 +149,7 @@ namespace sparrow{
 
             // is tuple_like
             static_assert(detail::tuple_like<std::tuple<int>>);
-            static_assert(detail::tuple_like<std::tuple<int,int>>);
+            static_assert(detail::tuple_like<std::tuple<int, int>>);
             static_assert(detail::tuple_like<std::tuple<>>);
             static_assert(detail::tuple_like<std::pair<int, int>>);
             static_assert(detail::tuple_like<std::array<int, 3>>);
@@ -164,15 +179,19 @@ namespace sparrow{
             static_assert(std::is_same_v<detail::meldv_t<run_end_encode<int>>, int>);
             static_assert(std::is_same_v<detail::meldv_t<int>, int>);
             static_assert(std::is_same_v<detail::meldv_t<nullable<int>>, nullable<int>>);
-            static_assert(std::is_same_v<detail::meldv_t<nullable<run_end_encode<int>>> , nullable<run_end_encode<int>>>);
+            static_assert(std::is_same_v<detail::meldv_t<nullable<run_end_encode<int>>>, nullable<run_end_encode<int>>>);
 
             // layout_flag_t
             static_assert(std::is_same_v<detail::layout_flag_t<int>, detail::dont_enforce_layout>);
             static_assert(std::is_same_v<detail::layout_flag_t<run_end_encode<int>>, detail::enforce_run_end_encoded_layout>);
-            static_assert(std::is_same_v<detail::layout_flag_t<nullable<run_end_encode<int>>>, detail::enforce_run_end_encoded_layout>);
+            static_assert(std::is_same_v<
+                          detail::layout_flag_t<nullable<run_end_encode<int>>>,
+                          detail::enforce_run_end_encoded_layout>);
             static_assert(std::is_same_v<detail::layout_flag_t<dict_encode<int>>, detail::enforce_dict_encoded_layout>);
-            static_assert(std::is_same_v<detail::layout_flag_t<nullable<dict_encode<int>>>, detail::enforce_dict_encoded_layout>);
- 
+            static_assert(std::is_same_v<
+                          detail::layout_flag_t<nullable<dict_encode<int>>>,
+                          detail::enforce_dict_encoded_layout>);
+
             // look trough
             static_assert(std::is_same_v<detail::look_trough_t<std::vector<nullable<int>>>, std::vector<nullable<int>>>);
             static_assert(std::is_same_v<detail::look_trough_t<nullable<std::vector<int>>>, std::vector<int>>);
@@ -180,8 +199,7 @@ namespace sparrow{
             static_assert(std::is_same_v<detail::look_trough_t<nullable<nullable<int>>>, nullable<int>>);
             static_assert(std::is_same_v<detail::look_trough_t<dict_encode<std::vector<int>>>, std::vector<int>>);
             static_assert(std::is_same_v<detail::look_trough_t<dict_encode<nullable<int>>>, int>);
-
-        } 
+        }
         TEST_CASE("get_size_save")
         {
             CHECK_EQ(detail::get_size_save(std::vector<int>{1, 2, 3}), 3);
@@ -197,7 +215,7 @@ namespace sparrow{
             CHECK_EQ(detail::ensure_value(dict_encode<int>{1}), 1);
             CHECK_EQ(detail::ensure_value(run_end_encode<int>{1}), 1);
             CHECK_EQ(detail::ensure_value(nullable<dict_encode<int>>{dict_encode<int>{1}}), 1);
-        }       
+        }
         TEST_CASE("where-null")
         {
             SUBCASE("vector-of-nullables")
@@ -210,8 +228,8 @@ namespace sparrow{
             SUBCASE("vector-of-scalar")
             {
                 std::vector<int> v{1, 2, 3, 4};
-                std::array<std::size_t,0> res = detail::where_null(v);
-                CHECK_EQ(res.size(), 0); // pointless but uses the return value
+                std::array<std::size_t, 0> res = detail::where_null(v);
+                CHECK_EQ(res.size(), 0);  // pointless but uses the return value
             }
             SUBCASE("vector-of-nullabels-dict-encode")
             {
@@ -228,9 +246,9 @@ namespace sparrow{
             SUBCASE("vector-of-nullabels-dict-encode")
             {
                 std::vector<dict_encode<nullable<int>>> v{
-                    dict_encode<nullable<int>>{nullable<int>{int(1)}},   
-                    dict_encode<nullable<int>>{nullable<int>{}},   
-                    dict_encode<nullable<int>>{nullable<int>{int(2)}},   
+                    dict_encode<nullable<int>>{nullable<int>{int(1)}},
+                    dict_encode<nullable<int>>{nullable<int>{}},
+                    dict_encode<nullable<int>>{nullable<int>{int(2)}},
                     dict_encode<nullable<int>>{nullable<int>{int(3)}}
                 };
                 std::vector<std::size_t> res = detail::where_null(v);
@@ -240,4 +258,3 @@ namespace sparrow{
         }
     }
 }
-
diff --git a/test/test_decimal.cpp b/test/test_decimal.cpp
index e12bc685..133c0848 100644
--- a/test/test_decimal.cpp
+++ b/test/test_decimal.cpp
@@ -12,21 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "doctest/doctest.h"
-
-#include <vector>
-#include <string>
 #include <cmath>
+#include <string>
 #include <utility>
+#include <vector>
 
-#include <sparrow/utils/large_int.hpp>
 #include <sparrow/utils/decimal.hpp>
+#include <sparrow/utils/large_int.hpp>
+
+#include "doctest/doctest.h"
 
 // ignore -Wdouble-promotion
 
 #ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wdouble-promotion"
 #endif
 
 
@@ -34,13 +34,14 @@ namespace sparrow
 {
 
     using testing_types = std::tuple<
-        int32_t
-        ,int64_t
-        #ifndef SPARROW_USE_LARGE_INT_PLACEHOLDERS
-        ,int128_t
-        ,int256_t
-        #endif
-    >;
+        int32_t,
+        int64_t
+#ifndef SPARROW_USE_LARGE_INT_PLACEHOLDERS
+        ,
+        int128_t,
+        int256_t
+#endif
+        >;
 
 
     TEST_SUITE("decimals")
@@ -56,18 +57,18 @@ namespace sparrow
                 decimal_type d;
                 auto storage = d.storage();
                 CHECK_EQ(static_cast<int32_t>(storage), 0);
-                
+
                 // float
-                auto as_float =  static_cast<float>(d);
+                auto as_float = static_cast<float>(d);
                 // cast to double:
                 CHECK_EQ(as_float, doctest::Approx(0.0));
 
                 // double
-                auto as_double =  static_cast<double>(d);
+                auto as_double = static_cast<double>(d);
                 CHECK_EQ(as_double, doctest::Approx(0.0));
 
                 // string
-                auto as_string =  std::string(d);
+                auto as_string = std::string(d);
                 CHECK_EQ(as_string, "0");
             }
 
@@ -76,17 +77,17 @@ namespace sparrow
                 decimal_type d(42, 0);
                 auto storage = d.storage();
                 CHECK_EQ(static_cast<int32_t>(storage), 42);
-                
+
                 // float
-                auto as_float =  static_cast<float>(d);
+                auto as_float = static_cast<float>(d);
                 CHECK_EQ(as_float, doctest::Approx(42.0));
 
                 // double
-                auto as_double =  static_cast<double>(d);
+                auto as_double = static_cast<double>(d);
                 CHECK_EQ(as_double, doctest::Approx(42.0));
 
                 // string
-                auto as_string =  std::string(d);
+                auto as_string = std::string(d);
                 CHECK_EQ(as_string, "42");
             }
 
@@ -97,17 +98,17 @@ namespace sparrow
                     decimal_type d(42, 1);
                     auto storage = d.storage();
                     CHECK_EQ(static_cast<int32_t>(storage), 42);
-                    
+
                     // float
-                    auto as_float =  static_cast<float>(d);
+                    auto as_float = static_cast<float>(d);
                     CHECK_EQ(as_float, doctest::Approx(4.2));
 
                     // double
-                    auto as_double =  static_cast<double>(d);
+                    auto as_double = static_cast<double>(d);
                     CHECK_EQ(as_double, doctest::Approx(4.20));
 
                     // string
-                    auto as_string =  std::string(d);
+                    auto as_string = std::string(d);
                     CHECK_EQ(as_string, "4.2");
                 }
                 SUBCASE("neg")
@@ -115,17 +116,17 @@ namespace sparrow
                     decimal_type d(-42, 1);
                     auto storage = d.storage();
                     CHECK_EQ(static_cast<int32_t>(storage), -42);
-                    
+
                     // float
-                    auto as_float =  static_cast<float>(d);
+                    auto as_float = static_cast<float>(d);
                     CHECK_EQ(as_float, doctest::Approx(-4.2));
 
                     // double
-                    auto as_double =  static_cast<double>(d);
+                    auto as_double = static_cast<double>(d);
                     CHECK_EQ(as_double, doctest::Approx(-4.20));
 
                     // string
-                    auto as_string =  std::string(d);
+                    auto as_string = std::string(d);
                     CHECK_EQ(as_string, "-4.2");
                 }
             }
@@ -136,17 +137,17 @@ namespace sparrow
                     decimal_type d(42, -1);
                     auto storage = d.storage();
                     CHECK_EQ(static_cast<int32_t>(storage), 42);
-                    
+
                     // float
-                    auto as_float =  static_cast<float>(d);
+                    auto as_float = static_cast<float>(d);
                     CHECK_EQ(as_float, doctest::Approx(420.0));
 
                     // double
-                    auto as_double =  static_cast<double>(d);
+                    auto as_double = static_cast<double>(d);
                     CHECK_EQ(as_double, doctest::Approx(420.0));
 
                     // string
-                    auto as_string =  std::string(d);
+                    auto as_string = std::string(d);
                     CHECK_EQ(as_string, "420");
                 }
                 SUBCASE("neg")
@@ -154,42 +155,48 @@ namespace sparrow
                     decimal_type d(-42, -1);
                     auto storage = d.storage();
                     CHECK_EQ(static_cast<int32_t>(storage), -42);
-                    
+
                     // float
-                    auto as_float =  static_cast<float>(d);
+                    auto as_float = static_cast<float>(d);
                     CHECK_EQ(as_float, doctest::Approx(-420.0));
 
                     // double
-                    auto as_double =  static_cast<double>(d);
+                    auto as_double = static_cast<double>(d);
                     CHECK_EQ(as_double, doctest::Approx(-420.0));
 
                     // string
-                    auto as_string =  std::string(d);
+                    auto as_string = std::string(d);
                     CHECK_EQ(as_string, "-420");
                 }
             }
 
             SUBCASE("generic")
             {
-                std::vector<int> values = {-123,-122, -111, -100, -99, 10, 11, 100, 101, 110, 111, 122, 123};
-                std::vector<int > scales    = {-3, -2, -1, 0, 1, 2, -4};
+                std::vector<int> values = {-123, -122, -111, -100, -99, 10, 11, 100, 101, 110, 111, 122, 123};
+                std::vector<int> scales = {-3, -2, -1, 0, 1, 2, -4};
 
                 // cross product
-                for(auto value : values)
+                for (auto value : values)
                 {
-                    for(auto scale : scales)
+                    for (auto scale : scales)
                     {
                         decimal_type d(value, scale);
                         auto storage = d.storage();
                         CHECK_EQ(static_cast<int32_t>(storage), value);
-                        
+
                         // float
-                        auto as_float =  static_cast<float>(d);
-                        CHECK_EQ(as_float, doctest::Approx(static_cast<double>(value) / static_cast<double>(std::pow(10, scale))));
+                        auto as_float = static_cast<float>(d);
+                        CHECK_EQ(
+                            as_float,
+                            doctest::Approx(static_cast<double>(value) / static_cast<double>(std::pow(10, scale)))
+                        );
 
                         // double
-                        auto as_double =  static_cast<double>(d);
-                        CHECK_EQ(as_double, doctest::Approx(static_cast<double>(value) / static_cast<double>(std::pow(10, scale))));
+                        auto as_double = static_cast<double>(d);
+                        CHECK_EQ(
+                            as_double,
+                            doctest::Approx(static_cast<double>(value) / static_cast<double>(std::pow(10, scale)))
+                        );
                     }
                 }
             }
@@ -215,7 +222,7 @@ namespace sparrow
                     {decimal_type(-1, 3), "-0.001"},
                     {decimal_type(-1, -1), "-10"},
                     {decimal_type(-1, -2), "-100"},
-                    {decimal_type(-1, -3), "-1000"}, 
+                    {decimal_type(-1, -3), "-1000"},
                     {decimal_type(123456789, 0), "123456789"},
                     {decimal_type(123456789, 1), "12345678.9"},
                     {decimal_type(123456789, 2), "1234567.89"},
@@ -260,18 +267,17 @@ namespace sparrow
                     {decimal_type(-123456789, 20), "-0.00000000000123456789"},
                 };
 
-                for(auto [d, expected] : data)
+                for (auto [d, expected] : data)
                 {
-                    auto as_string =  std::string(d);
+                    auto as_string = std::string(d);
                     CHECK_EQ(as_string, expected);
                 }
             }
-
         }
         TEST_CASE_TEMPLATE_APPLY(decimal_test_id, testing_types);
     }
 }
 
 #ifdef __GNUC__
-#pragma GCC diagnostic pop
+#    pragma GCC diagnostic pop
 #endif
\ No newline at end of file
diff --git a/test/test_decimal_array.cpp b/test/test_decimal_array.cpp
index 97cb9f5f..32deb68b 100644
--- a/test/test_decimal_array.cpp
+++ b/test/test_decimal_array.cpp
@@ -16,34 +16,30 @@
 #include <ranges>
 #include <vector>
 
-
 #include "sparrow/layout/decimal_array.hpp"
+
 #include "test_utils.hpp"
 
 namespace sparrow
 {
 
     using integer_types = std::tuple<
-        std::int32_t
-        ,std::int64_t
-        #ifndef SPARROW_USE_LARGE_INT_PLACEHOLDERS
-        ,int128_t
-        ,int256_t
-        #endif
-    >;
+        std::int32_t,
+        std::int64_t
+#ifndef SPARROW_USE_LARGE_INT_PLACEHOLDERS
+        ,
+        int128_t,
+        int256_t
+#endif
+        >;
 
 
     TEST_SUITE("decimal_array")
     {
         TEST_CASE_TEMPLATE_DEFINE("generic", INTEGER_TYPE, decimal_array_test_generic_id)
-        {   
+        {
             using integer_type = INTEGER_TYPE;
-            u8_buffer<integer_type> buffer{
-                integer_type(10),
-                integer_type(20),
-                integer_type(33),
-                integer_type(111)
-            };
+            u8_buffer<integer_type> buffer{integer_type(10), integer_type(20), integer_type(33), integer_type(111)};
             std::size_t precision = 2;
             int scale = 4;
             decimal_array<decimal<integer_type>> array{std::move(buffer), precision, scale};
@@ -53,7 +49,7 @@ namespace sparrow
             CHECK_EQ(val.scale(), scale);
             CHECK_EQ(static_cast<std::int64_t>(val.storage()), 10);
             CHECK_EQ(static_cast<double>(val), doctest::Approx(0.001));
-            
+
             val = array[1].value();
             CHECK_EQ(val.scale(), scale);
             CHECK_EQ(static_cast<std::int64_t>(val.storage()), 20);
@@ -63,8 +59,7 @@ namespace sparrow
             CHECK_EQ(val.scale(), scale);
             CHECK_EQ(static_cast<std::int64_t>(val.storage()), 33);
             CHECK_EQ(static_cast<double>(val), doctest::Approx(0.0033));
-
         }
         TEST_CASE_TEMPLATE_APPLY(decimal_array_test_generic_id, integer_types);
     }
-} // namespace sparrow
\ No newline at end of file
+}  // namespace sparrow
\ No newline at end of file
diff --git a/test/test_dispatch.cpp b/test/test_dispatch.cpp
index 1859fab2..ecc5efd2 100644
--- a/test/test_dispatch.cpp
+++ b/test/test_dispatch.cpp
@@ -16,15 +16,14 @@
 #include "sparrow/layout/array_helper.hpp"
 #include "sparrow/layout/dispatch.hpp"
 
-#include "doctest/doctest.h"
-
 #include "../test/external_array_data_creation.hpp"
+#include "doctest/doctest.h"
 
 namespace sparrow
 {
     using test::make_arrow_proxy;
     using testing_types = std::tuple<
-        null_array, 
+        null_array,
         primitive_array<std::int8_t>,
         primitive_array<std::uint8_t>,
         primitive_array<std::int16_t>,
@@ -35,9 +34,8 @@ namespace sparrow
         primitive_array<std::uint64_t>,
         primitive_array<float16_t>,
         primitive_array<float32_t>,
-        primitive_array<float64_t>
-    >;
-    
+        primitive_array<float64_t>>;
+
     TEST_SUITE("dispatch")
     {
         TEST_CASE_TEMPLATE_DEFINE("array_size", AR, array_size_id)
diff --git a/test/test_high_level_constructors.cpp b/test/test_high_level_constructors.cpp
index 9be78c80..63c29c7e 100644
--- a/test/test_high_level_constructors.cpp
+++ b/test/test_high_level_constructors.cpp
@@ -13,25 +13,32 @@
 // limitations under the License.
 
 
-#include "sparrow/layout/primitive_array.hpp"
-#include "sparrow/layout/list_layout/list_array.hpp"
+#include <ranges>
+
 #include "sparrow/array.hpp"
+#include "sparrow/layout/list_layout/list_array.hpp"
+#include "sparrow/layout/primitive_array.hpp"
+
 #include "doctest/doctest.h"
 #include "test_utils.hpp"
 
-#include <ranges>
-
 namespace sparrow
 {
 
     TEST_SUITE("high_level_constructors")
     {
         TEST_CASE("list")
-        {   
+        {
             // a primite array
             std::size_t flat_size = 10;
-            primitive_array<std::uint16_t> primitive_arr(std::ranges::iota_view{std::size_t(0), std::size_t(10)} | std::views::transform([](auto i){
-                return static_cast<std::uint16_t>(i);})
+            primitive_array<std::uint16_t> primitive_arr(
+                std::ranges::iota_view{std::size_t(0), std::size_t(10)}
+                | std::views::transform(
+                    [](auto i)
+                    {
+                        return static_cast<std::uint16_t>(i);
+                    }
+                )
             );
 
             // wrap into an detyped array
@@ -49,34 +56,36 @@ namespace sparrow
             REQUIRE_EQ(size, n);
 
             auto flat_i = 0;
-            for(std::size_t i = 0; i < size; ++i)
+            for (std::size_t i = 0; i < size; ++i)
             {
                 auto list = list_arr[i].value();
                 CHECK_EQ(list.size(), list_size);
 
-                for(std::size_t j = 0; j < list.size(); ++j)
+                for (std::size_t j = 0; j < list.size(); ++j)
                 {
                     auto opt_val_variant = list[j];
-                    std::visit([&](auto&& opt_val){
-                        using nullable_type = std::decay_t<decltype(opt_val)>;
-                        using inner_type = std::decay_t<typename nullable_type::value_type>;
-                        if constexpr(std::is_same_v<inner_type, std::uint16_t>)
-                        {
-                            REQUIRE(opt_val.has_value());
-                            CHECK_EQ(opt_val.value(), static_cast<std::uint16_t>(flat_i));
-                        }
-                        else
+                    std::visit(
+                        [&](auto&& opt_val)
                         {
-                           REQUIRE(false);
-                        }
-                    }, opt_val_variant);
+                            using nullable_type = std::decay_t<decltype(opt_val)>;
+                            using inner_type = std::decay_t<typename nullable_type::value_type>;
+                            if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+                            {
+                                REQUIRE(opt_val.has_value());
+                                CHECK_EQ(opt_val.value(), static_cast<std::uint16_t>(flat_i));
+                            }
+                            else
+                            {
+                                REQUIRE(false);
+                            }
+                        },
+                        opt_val_variant
+                    );
                     ++flat_i;
                 }
-
             }
         }
     }
-   
 
-}
 
+}
diff --git a/test/test_list_array.cpp b/test/test_list_array.cpp
index 1e5f1494..37878190 100644
--- a/test/test_list_array.cpp
+++ b/test/test_list_array.cpp
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "sparrow/array.hpp"
 #include "sparrow/layout/list_layout/list_array.hpp"
 #include "sparrow/layout/primitive_array.hpp"
 
 #include "doctest/doctest.h"
 #include "external_array_data_creation.hpp"
 #include "test_utils.hpp"
-#include "sparrow/array.hpp"
 
 namespace sparrow
 {
@@ -30,12 +30,20 @@ namespace sparrow
             // first we create a flat array of integers
             ArrowArray flat_arr{};
             ArrowSchema flat_schema{};
-            test::fill_schema_and_array<T>(flat_schema, flat_arr, n_flat, 0/*offset*/, {});
+            test::fill_schema_and_array<T>(flat_schema, flat_arr, n_flat, 0 /*offset*/, {});
             flat_schema.name = "the flat array";
 
             ArrowArray arr{};
             ArrowSchema schema{};
-            test::fill_schema_and_array_for_list_layout(schema, arr, std::move(flat_schema), std::move(flat_arr), sizes, {}, 0);
+            test::fill_schema_and_array_for_list_layout(
+                schema,
+                arr,
+                std::move(flat_schema),
+                std::move(flat_arr),
+                sizes,
+                {},
+                0
+            );
             return arrow_proxy(std::move(arr), std::move(schema));
         }
     }
@@ -57,8 +65,14 @@ namespace sparrow
             std::size_t n_flat = 11;  // 2+2+3+4
 
             // create flat array of integers
-            primitive_array<std::int16_t> flat_arr(std::ranges::iota_view{std::size_t(0), std::size_t(n_flat)} | std::views::transform([](auto i){
-                return static_cast<std::int16_t>(i);})
+            primitive_array<std::int16_t> flat_arr(
+                std::ranges::iota_view{std::size_t(0), std::size_t(n_flat)}
+                | std::views::transform(
+                    [](auto i)
+                    {
+                        return static_cast<std::int16_t>(i);
+                    }
+                )
             );
 
             // wrap into an detyped array
@@ -69,19 +83,19 @@ namespace sparrow
 
             // check the size
             REQUIRE_EQ(list_arr.size(), sizes.size());
-            
+
             // check the sizes
-            for(std::size_t i = 0; i < sizes.size(); ++i)
+            for (std::size_t i = 0; i < sizes.size(); ++i)
             {
                 CHECK_EQ(list_arr[i].value().size(), sizes[i]);
             }
 
             // check the values
             std::int16_t flat_index = 0;
-            for(std::size_t i = 0; i < sizes.size(); ++i)
+            for (std::size_t i = 0; i < sizes.size(); ++i)
             {
                 auto list = list_arr[i].value();
-                for(std::size_t j = 0; j < sizes[i]; ++j)
+                for (std::size_t j = 0; j < sizes[i]; ++j)
                 {
                     CHECK_NULLABLE_VARIANT_EQ(list[j], flat_index);
                     ++flat_index;
@@ -148,14 +162,14 @@ namespace sparrow
                     for (std::size_t j = 0; j < sizes[i]; ++j)
                     {
                         auto value_variant = list[j];
-                        CHECK_NULLABLE_VARIANT_EQ(value_variant,  static_cast<inner_scalar_type>(flat_index));
+                        CHECK_NULLABLE_VARIANT_EQ(value_variant, static_cast<inner_scalar_type>(flat_index));
                         ++flat_index;
                     }
                 }
             }
 
             SUBCASE("consistency")
-            {   
+            {
                 test::generic_consistency_test(list_arr);
             }
 
@@ -174,14 +188,19 @@ namespace sparrow
                 // check that flat values are "iota"
                 if constexpr (std::is_integral_v<inner_scalar_type>)
                 {
-                    for(inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i){
+                    for (inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i)
+                    {
                         CHECK(flat_values_casted[static_cast<primitive_size_type>(i)].value() == i);
                     }
                 }
                 else
                 {
-                    for(inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i){
-                        CHECK(flat_values_casted[static_cast<primitive_size_type>(i)].value() == doctest::Approx(static_cast<double>(i)));
+                    for (inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i)
+                    {
+                        CHECK(
+                            flat_values_casted[static_cast<primitive_size_type>(i)].value()
+                            == doctest::Approx(static_cast<double>(i))
+                        );
                     }
                 }
             }
@@ -196,12 +215,20 @@ namespace sparrow
             // first we create a flat array of integers
             ArrowArray flat_arr{};
             ArrowSchema flat_schema{};
-            test::fill_schema_and_array<T>(flat_schema, flat_arr, n_flat, 0/*offset*/, {});
+            test::fill_schema_and_array<T>(flat_schema, flat_arr, n_flat, 0 /*offset*/, {});
             flat_schema.name = "the flat array";
 
             ArrowArray arr{};
             ArrowSchema schema{};
-            test::fill_schema_and_array_for_list_view_layout(schema, arr, std::move(flat_schema), std::move(flat_arr), sizes, {}, 0);
+            test::fill_schema_and_array_for_list_view_layout(
+                schema,
+                arr,
+                std::move(flat_schema),
+                std::move(flat_arr),
+                sizes,
+                {},
+                0
+            );
             return arrow_proxy(std::move(arr), std::move(schema));
         }
     }
@@ -216,20 +243,26 @@ namespace sparrow
 
         TEST_CASE("constructors")
         {
-           // flat data is [0,1,2,3,4]
+            // flat data is [0,1,2,3,4]
             std::size_t n_flat = 5;
 
             // create flat array of integers
-            primitive_array<std::int16_t> flat_arr(std::ranges::iota_view{std::size_t(0), std::size_t(n_flat)} | std::views::transform([](auto i){
-                return static_cast<std::int16_t>(i);})
+            primitive_array<std::int16_t> flat_arr(
+                std::ranges::iota_view{std::size_t(0), std::size_t(n_flat)}
+                | std::views::transform(
+                    [](auto i)
+                    {
+                        return static_cast<std::int16_t>(i);
+                    }
+                )
             );
 
             // the desired goal array is
             // [[3,4],[2,3],NAN, [0,1,2]]
 
             // vector of sizes
-            std::vector<std::uint32_t> sizes = {2, 2,0, 3};
-            std::vector<std::uint32_t> offsets = {3, 2,0,0};
+            std::vector<std::uint32_t> sizes = {2, 2, 0, 3};
+            std::vector<std::uint32_t> offsets = {3, 2, 0, 0};
 
             std::vector<std::uint32_t> where_missing = {2};
 
@@ -255,7 +288,6 @@ namespace sparrow
             CHECK_EQ(list_view_arr[3].value().size(), sizes[3]);
 
 
-
             // check the values
             CHECK_NULLABLE_VARIANT_EQ(list_view_arr[0].value()[0], std::int16_t(3));
             CHECK_NULLABLE_VARIANT_EQ(list_view_arr[0].value()[1], std::int16_t(4));
@@ -281,7 +313,7 @@ namespace sparrow
 
             const std::size_t n_flat2 = 8;
             std::vector<std::size_t> sizes2 = {2, 4, 2};
-            
+
             arrow_proxy proxy = test::make_list_view_proxy<inner_scalar_type>(n_flat, sizes);
 
             // create a list array
@@ -336,7 +368,7 @@ namespace sparrow
             }
 
             SUBCASE("consistency")
-            {   
+            {
                 test::generic_consistency_test(list_arr);
             }
 
@@ -355,14 +387,19 @@ namespace sparrow
                 // check that flat values are "iota"
                 if constexpr (std::is_integral_v<inner_scalar_type>)
                 {
-                    for(inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i){
+                    for (inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i)
+                    {
                         CHECK(flat_values_casted[static_cast<primitive_size_type>(i)].value() == i);
                     }
                 }
                 else
                 {
-                    for(inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i){
-                        CHECK(flat_values_casted[static_cast<primitive_size_type>(i)].value() == doctest::Approx(static_cast<double>(i)));
+                    for (inner_scalar_type i = 0; i < static_cast<inner_scalar_type>(n_flat); ++i)
+                    {
+                        CHECK(
+                            flat_values_casted[static_cast<primitive_size_type>(i)].value()
+                            == doctest::Approx(static_cast<double>(i))
+                        );
                     }
                 }
             }
@@ -377,12 +414,19 @@ namespace sparrow
             // first we create a flat array of integers
             ArrowArray flat_arr{};
             ArrowSchema flat_schema{};
-            test::fill_schema_and_array<T>(flat_schema, flat_arr, n_flat, 0/*offset*/, {});
+            test::fill_schema_and_array<T>(flat_schema, flat_arr, n_flat, 0 /*offset*/, {});
             flat_schema.name = "the flat array";
 
             ArrowArray arr{};
             ArrowSchema schema{};
-            test::fill_schema_and_array_for_fixed_size_list_layout(schema, arr, std::move(flat_schema), std::move(flat_arr), {}, list_size);
+            test::fill_schema_and_array_for_fixed_size_list_layout(
+                schema,
+                arr,
+                std::move(flat_schema),
+                std::move(flat_arr),
+                {},
+                list_size
+            );
             return arrow_proxy(std::move(arr), std::move(schema));
         }
     }
@@ -410,7 +454,7 @@ namespace sparrow
 
             const std::size_t n_flat2 = 10;
             const std::size_t list_size2 = 4;
-            
+
             arrow_proxy proxy = test::make_fixed_sized_list_proxy<inner_scalar_type>(n_flat, list_size);
             fixed_sized_list_array list_arr(std::move(proxy));
 
@@ -438,7 +482,7 @@ namespace sparrow
             }
 
             SUBCASE("consistency")
-            {   
+            {
                 test::generic_consistency_test(list_arr);
             }
             REQUIRE(list_arr.size() == n);
diff --git a/test/test_list_value.cpp b/test/test_list_value.cpp
index 8967160b..f05e81eb 100644
--- a/test/test_list_value.cpp
+++ b/test/test_list_value.cpp
@@ -12,13 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/list_layout/list_value.hpp"
+#include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/struct_layout/struct_value.hpp"
 
-#include "doctest/doctest.h"
-
 #include "../test/external_array_data_creation.hpp"
+#include "doctest/doctest.h"
 
 namespace sparrow
 {
@@ -48,10 +47,13 @@ namespace sparrow
             list_value l(&w, begin, end);
             for (std::size_t i = begin; i < end; ++i)
             {
-                CHECK_EQ(l[i].has_value(), ar[begin+i].has_value());
-                if (ar[begin+i].has_value())
+                CHECK_EQ(l[i].has_value(), ar[begin + i].has_value());
+                if (ar[begin + i].has_value())
                 {
-                    CHECK_EQ(std::get<primitive_array<scalar_value_type>::const_reference>(l[i]).value(), ar[begin+i].value());
+                    CHECK_EQ(
+                        std::get<primitive_array<scalar_value_type>::const_reference>(l[i]).value(),
+                        ar[begin + i].value()
+                    );
                 }
             }
         }
diff --git a/test/test_memory.cpp b/test/test_memory.cpp
index 0d459a81..52bc83f3 100644
--- a/test/test_memory.cpp
+++ b/test/test_memory.cpp
@@ -197,7 +197,10 @@ namespace sparrow::cloning_test
             return std::unique_ptr<mock_derived>{new mock_derived(*this)};
         }
 
-        static int instance_count() { return m_instance_count; }
+        static int instance_count()
+        {
+            return m_instance_count;
+        }
 
     private:
 
@@ -416,7 +419,7 @@ namespace sparrow
             auto d2 = new mock_derived();
             cloning_ptr<mock_derived> p1(d1);
             cloning_ptr<mock_derived> p2(d2);
-            
+
             SUBCASE("method")
             {
                 p1.swap(p2);
@@ -474,7 +477,7 @@ namespace sparrow
                 CHECK(p1 != nullptr);
                 CHECK(p4 == nullptr);
             }
-            
+
             SUBCASE("ordering")
             {
                 CHECK(p1 <= p1);
diff --git a/test/test_nested_comperators.cpp b/test/test_nested_comperators.cpp
index 9bfddea0..4049659c 100644
--- a/test/test_nested_comperators.cpp
+++ b/test/test_nested_comperators.cpp
@@ -12,22 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/builder/builder_utils.hpp"
-#include "sparrow/builder/nested_less.hpp"
-#include "sparrow/builder/nested_eq.hpp"
-#include "test_utils.hpp"
-
-#include <vector>
+#include <array>
 #include <tuple>
 #include <variant>
-#include <array>
+#include <vector>
 
+#include "sparrow/builder/builder_utils.hpp"
+#include "sparrow/builder/nested_eq.hpp"
+#include "sparrow/builder/nested_less.hpp"
+
+#include "test_utils.hpp"
 
 namespace sparrow
-{   
+{
 
     TEST_SUITE("nested-less")
-    {   
+    {
         TEST_CASE("nullable-less")
         {
             using type = nullable<int>;
@@ -42,20 +42,17 @@ namespace sparrow
             CHECK_FALSE(less_type{}(type{1}, type{1}));
         }
         TEST_CASE("tuple")
-        {   
-
+        {
             {
                 using tuple_type = std::tuple<int>;
                 using less_type = detail::nested_less<tuple_type>;
                 CHECK(less_type{}(tuple_type{0}, tuple_type{1}));
             }
             {
-                using tuple_type = std::tuple<int,int>;
+                using tuple_type = std::tuple<int, int>;
                 using less_type = detail::nested_less<tuple_type>;
                 CHECK(less_type{}(tuple_type{0, 2}, tuple_type{1, 0}));
             }
-            
-
         }
         TEST_CASE("very-nested-less")
         {
@@ -79,9 +76,10 @@ namespace sparrow
             CHECK_FALSE(less_type{}(c, a));
             CHECK_FALSE(less_type{}(c, c));
         }
-    }   
+    }
+
     TEST_SUITE("nested-eq")
-    {   
+    {
         TEST_CASE("nullable-eq")
         {
             using type = nullable<int>;
@@ -96,8 +94,7 @@ namespace sparrow
             CHECK_FALSE(eq_type{}(type{1}, type{2}));
         }
         TEST_CASE("tuple")
-        {   
-
+        {
             {
                 using tuple_type = std::tuple<int>;
                 using eq_type = detail::nested_eq<tuple_type>;
@@ -107,15 +104,13 @@ namespace sparrow
                 CHECK_FALSE(eq_type{}(tuple_type{0}, tuple_type{1}));
             }
             {
-                using tuple_type = std::tuple<int,int>;
+                using tuple_type = std::tuple<int, int>;
                 using eq_type = detail::nested_eq<tuple_type>;
                 CHECK(eq_type{}(tuple_type{0, 0}, tuple_type{0, 0}));
                 CHECK_FALSE(eq_type{}(tuple_type{0, 1}, tuple_type{1, 0}));
                 CHECK_FALSE(eq_type{}(tuple_type{1, 0}, tuple_type{1, 1}));
                 CHECK(eq_type{}(tuple_type{1, 1}, tuple_type{1, 1}));
             }
-            
-
         }
         TEST_CASE("very-nested-eq")
         {
@@ -141,4 +136,3 @@ namespace sparrow
         }
     }
 }
-
diff --git a/test/test_null_array.cpp b/test/test_null_array.cpp
index cea3a86b..18918116 100644
--- a/test/test_null_array.cpp
+++ b/test/test_null_array.cpp
@@ -16,9 +16,8 @@
 
 #include "sparrow/layout/null_array.hpp"
 
-#include "doctest/doctest.h"
-
 #include "../test/external_array_data_creation.hpp"
+#include "doctest/doctest.h"
 
 namespace sparrow
 {
@@ -118,4 +117,3 @@ namespace sparrow
         }
     }
 }
-
diff --git a/test/test_nullable.cpp b/test/test_nullable.cpp
index db96b1c8..7fcc8d24 100644
--- a/test/test_nullable.cpp
+++ b/test/test_nullable.cpp
@@ -93,13 +93,17 @@ namespace sparrow
             return *this;
         }
 
-        const int& get_value() const { return m_value; }
+        const int& get_value() const
+        {
+            return m_value;
+        }
 
     private:
 
         int m_value;
         bool m_moved = false;
     };
+
     int Custom::counter = 0;
 
     bool operator==(const Custom& lhs, const Custom& rhs)
@@ -122,10 +126,7 @@ namespace sparrow
         return lhs.get_value() <=> rhs;
     }
 
-    using testing_types = std::tuple<
-        double,
-        std::string,
-        Custom>;
+    using testing_types = std::tuple<double, std::string, Custom>;
 
     namespace
     {
@@ -135,37 +136,79 @@ namespace sparrow
         template <>
         struct fixture<double>
         {
-            static double init() { return 1.2; }
-            static double other() { return 2.5; }
-            static int convert_init() { return 3; }
+            static double init()
+            {
+                return 1.2;
+            }
+
+            static double other()
+            {
+                return 2.5;
+            }
+
+            static int convert_init()
+            {
+                return 3;
+            }
 
             using convert_type = int;
 
-            static bool check_move_count(int) { return true; }
+            static bool check_move_count(int)
+            {
+                return true;
+            }
         };
 
         template <>
         struct fixture<std::string>
         {
-            static std::string init() { return "And now young codebase ..."; }
-            static std::string other() { return "Darth Codius"; }
-            static const char* convert_init() { return "Noooooo that's impossible!"; }
+            static std::string init()
+            {
+                return "And now young codebase ...";
+            }
+
+            static std::string other()
+            {
+                return "Darth Codius";
+            }
+
+            static const char* convert_init()
+            {
+                return "Noooooo that's impossible!";
+            }
 
             using convert_type = const char*;
 
-            static bool check_move_count(int) { return true; }
+            static bool check_move_count(int)
+            {
+                return true;
+            }
         };
 
         template <>
         struct fixture<Custom>
         {
-            static Custom init() { return Custom(1); }
-            static Custom other() { return Custom(2); }
-            static int convert_init() { return 3; }
+            static Custom init()
+            {
+                return Custom(1);
+            }
+
+            static Custom other()
+            {
+                return Custom(2);
+            }
+
+            static int convert_init()
+            {
+                return 3;
+            }
 
             using convert_type = int;
 
-            static bool check_move_count(int ref) { return Custom::counter == ref; }
+            static bool check_move_count(int ref)
+            {
+                return Custom::counter == ref;
+            }
         };
     }
 
@@ -583,14 +626,12 @@ namespace sparrow
     TEST_SUITE("nullable proxy")
     {
         static_assert(std::is_convertible_v<
-            sparrow::nullable<const bool &> &&,
-            sparrow::nullable<const bool &, const bool&>>
-        );
+                      sparrow::nullable<const bool&>&&,
+                      sparrow::nullable<const bool&, const bool&>>);
 
         static_assert(std::is_convertible_v<
-            const sparrow::nullable<const bool &>&,
-            sparrow::nullable<const bool &, const bool&>>
-        );
+                      const sparrow::nullable<const bool&>&,
+                      sparrow::nullable<const bool&, const bool&>>);
 
         TEST_CASE_TEMPLATE_DEFINE("constructors", T, constructors_id)
         {
@@ -935,7 +976,13 @@ namespace sparrow
             nullable<double> d = vd;
             nullable_variant_type v = d;
 
-            bool res = std::visit([vd](const auto& val) { return val.has_value() && val.value() == vd; }, v);
+            bool res = std::visit(
+                [vd](const auto& val)
+                {
+                    return val.has_value() && val.value() == vd;
+                },
+                v
+            );
             CHECK(res);
         }
 
@@ -965,4 +1012,3 @@ namespace sparrow
         }
     }
 }
-
diff --git a/test/test_record_batch.cpp b/test/test_record_batch.cpp
index 9fcd18b3..0824b11e 100644
--- a/test/test_record_batch.cpp
+++ b/test/test_record_batch.cpp
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "sparrow/record_batch.hpp"
 #include "sparrow/layout/primitive_array.hpp"
+#include "sparrow/record_batch.hpp"
 
 #include "doctest/doctest.h"
 
@@ -21,14 +21,19 @@ namespace sparrow
 {
     std::vector<array> make_array_list(const std::size_t data_size)
     {
-        primitive_array<std::uint16_t> pr0(std::ranges::iota_view{std::size_t(0), std::size_t(data_size)}
-                | std::views::transform([](auto i){
-                return static_cast<std::uint16_t>(i);})
-            );
+        primitive_array<std::uint16_t> pr0(
+            std::ranges::iota_view{std::size_t(0), std::size_t(data_size)}
+            | std::views::transform(
+                [](auto i)
+                {
+                    return static_cast<std::uint16_t>(i);
+                }
+            )
+        );
         primitive_array<std::int32_t> pr1(std::ranges::iota_view{std::int32_t(4), 4 + std::int32_t(data_size)});
         primitive_array<std::int32_t> pr2(std::ranges::iota_view{std::int32_t(2), 2 + std::int32_t(data_size)});
 
-        std::vector<array> arr_list = { array(std::move(pr0)), array(std::move(pr1)), array(std::move(pr2)) };
+        std::vector<array> arr_list = {array(std::move(pr0)), array(std::move(pr1)), array(std::move(pr2))};
         return arr_list;
     }
 
@@ -40,7 +45,6 @@ namespace sparrow
 
     record_batch make_record_batch(const std::size_t data_size)
     {
-
         return record_batch(make_name_list(), make_array_list(data_size));
     }
 
@@ -61,10 +65,7 @@ namespace sparrow
             {
                 auto col_list = make_array_list(col_size);
 
-                record_batch record = {
-                    { "first", col_list[0]},
-                    { "second", col_list[1]},
-                    { "third", col_list[2]} };
+                record_batch record = {{"first", col_list[0]}, {"second", col_list[1]}, {"third", col_list[2]}};
                 CHECK_EQ(record.nb_columns(), 3u);
                 CHECK_EQ(record.nb_rows(), 10u);
             }
@@ -111,7 +112,7 @@ namespace sparrow
         {
             auto record = make_record_batch(col_size);
             auto name_list = make_name_list();
-            for (const auto& name: name_list)
+            for (const auto& name : name_list)
             {
                 CHECK(record.contains_column(name));
             }
@@ -162,4 +163,3 @@ namespace sparrow
         }
     }
 }
-
diff --git a/test/test_run_end_encoded_array.cpp b/test/test_run_end_encoded_array.cpp
index ee89084c..1ee355e5 100644
--- a/test/test_run_end_encoded_array.cpp
+++ b/test/test_run_end_encoded_array.cpp
@@ -12,15 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "sparrow/array.hpp"
+#include "sparrow/layout/dispatch.hpp"
 #include "sparrow/layout/primitive_array.hpp"
+#include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
 #include "sparrow/utils/nullable.hpp"
-#include "sparrow/layout/dispatch.hpp"
+
+#include "../test/external_array_data_creation.hpp"
 #include "doctest/doctest.h"
 #include "test_utils.hpp"
-#include "../test/external_array_data_creation.hpp"
-#include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
-
-#include "sparrow/array.hpp"
 
 namespace sparrow
 {
@@ -42,30 +42,31 @@ namespace sparrow
 
             // if alterate is true, all 42s will be replaced by 43s
             // this is to test EQ/NEQ after copy/move
-     
+
             // encoded values
             primitive_array<inner_value_type> encoded_values(
                 std::vector<inner_value_type>{
                     inner_value_type(1),
                     inner_value_type(),
                     // to check if arrays differ / are the same
-                    alterate ? inner_value_type(43): inner_value_type(42),
+                    alterate ? inner_value_type(43) : inner_value_type(42),
                     inner_value_type(),
-                    inner_value_type(9)                        
+                    inner_value_type(9)
                 },
-                std::vector<std::size_t>{1,3} // where we have no value
+                std::vector<std::size_t>{1, 3}  // where we have no value
             );
 
             // accumulated lengths
-            primitive_array<acc_type> acc_lengths{{acc_type(1), acc_type(3), acc_type(6), acc_type(7), acc_type(8)}};
+            primitive_array<acc_type> acc_lengths{
+                {acc_type(1), acc_type(3), acc_type(6), acc_type(7), acc_type(8)}
+            };
 
             array acc_lengths_array(std::move(acc_lengths));
             array encoded_values_array(std::move(encoded_values));
-            
+
             return run_end_encoded_array(std::move(acc_lengths_array), std::move(encoded_values_array));
         }
     }
-    
 
     TEST_SUITE("run_length_encoded")
     {
@@ -81,15 +82,15 @@ namespace sparrow
             // check size
             REQUIRE(rle_array.size() == n);
 
-            std::vector<bool> expected_bitmap{1,0,0,1,1,1,0,1};
-            std::vector<inner_value_type> expected_values{1,0,0, 42,42, 42,0,9};
-            
+            std::vector<bool> expected_bitmap{1, 0, 0, 1, 1, 1, 0, 1};
+            std::vector<inner_value_type> expected_values{1, 0, 0, 42, 42, 42, 0, 9};
+
             SUBCASE("copy")
             {
                 run_end_encoded_array rle_array2(rle_array);
                 CHECK_EQ(rle_array2, rle_array);
 
-                run_end_encoded_array rle_array3  = test::make_test_run_encoded_array(/*alterate=*/true);
+                run_end_encoded_array rle_array3 = test::make_test_run_encoded_array(/*alterate=*/true);
                 CHECK_NE(rle_array3, rle_array);
                 rle_array3 = rle_array;
                 CHECK_EQ(rle_array3, rle_array);
@@ -101,32 +102,41 @@ namespace sparrow
                 run_end_encoded_array rle_array3(std::move(rle_array2));
                 CHECK_EQ(rle_array3, rle_array);
 
-                run_end_encoded_array rle_array4 = test::make_test_run_encoded_array(/*alterate*/true);
+                run_end_encoded_array rle_array4 = test::make_test_run_encoded_array(/*alterate*/ true);
                 CHECK_NE(rle_array4, rle_array);
                 rle_array4 = std::move(rle_array3);
                 CHECK_EQ(rle_array4, rle_array);
             }
 
-            SUBCASE("operator[]"){
-                //check elements
-                for(std::size_t i=0; i<n; ++i){
+            SUBCASE("operator[]")
+            {
+                // check elements
+                for (std::size_t i = 0; i < n; ++i)
+                {
                     REQUIRE(rle_array[i].has_value() == bool(expected_bitmap[i]));
-                    if(expected_bitmap[i]){
+                    if (expected_bitmap[i])
+                    {
                         array_traits::const_reference val = rle_array[i];
                         CHECK(val.has_value() == val.has_value());
                         // // visit the variant
-                        std::visit([&]( auto && nullable) -> void {
+                        std::visit(
+                            [&](auto&& nullable) -> void
+                            {
                                 using T = std::decay_t<decltype(nullable)>;
                                 using inner_type = std::decay_t<typename T::value_type>;
-                                if constexpr(std::is_same_v<inner_type, inner_value_type>){
-                                    if(nullable.has_value()){
+                                if constexpr (std::is_same_v<inner_type, inner_value_type>)
+                                {
+                                    if (nullable.has_value())
+                                    {
                                         CHECK(nullable.value() == expected_values[i]);
                                     }
-                                    else{
+                                    else
+                                    {
                                         CHECK(false);
                                     }
                                 }
-                                else{
+                                else
+                                {
                                     CHECK(false);
                                 }
                             },
@@ -135,26 +145,35 @@ namespace sparrow
                     }
                 }
             }
-            SUBCASE("iterator"){
+            SUBCASE("iterator")
+            {
                 auto iter = rle_array.begin();
-                //check elements
-                for(std::size_t i=0; i<n; ++i){
+                // check elements
+                for (std::size_t i = 0; i < n; ++i)
+                {
                     REQUIRE(iter != rle_array.end());
                     CHECK(iter->has_value() == bool(expected_bitmap[i]));
-                    if(iter->has_value()){
+                    if (iter->has_value())
+                    {
                         auto val = *iter;
-                        std::visit([&]( auto && nullable) -> void {
+                        std::visit(
+                            [&](auto&& nullable) -> void
+                            {
                                 using T = std::decay_t<decltype(nullable)>;
                                 using inner_type = std::decay_t<typename T::value_type>;
-                                if constexpr(std::is_same_v<inner_type, inner_value_type>){
-                                    if(nullable.has_value()){
+                                if constexpr (std::is_same_v<inner_type, inner_value_type>)
+                                {
+                                    if (nullable.has_value())
+                                    {
                                         CHECK(nullable.value() == expected_values[i]);
                                     }
-                                    else{
+                                    else
+                                    {
                                         CHECK(false);
                                     }
                                 }
-                                else{
+                                else
+                                {
                                     CHECK(false);
                                 }
                             },
@@ -165,10 +184,9 @@ namespace sparrow
                 }
             }
             SUBCASE("consitency")
-            {   
+            {
                 test::generic_consistency_test(rle_array);
             }
         }
     }
 }
-
diff --git a/test/test_struct_array.cpp b/test/test_struct_array.cpp
index eba566a5..a6a94a4f 100644
--- a/test/test_struct_array.cpp
+++ b/test/test_struct_array.cpp
@@ -12,15 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "sparrow/array.hpp"
 #include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/struct_layout/struct_array.hpp"
 #include "sparrow/utils/nullable.hpp"
 
+#include "../test/external_array_data_creation.hpp"
 #include "doctest/doctest.h"
-
 #include "test_utils.hpp"
-#include "../test/external_array_data_creation.hpp"
-#include "sparrow/array.hpp"
 
 namespace sparrow
 {
@@ -33,37 +32,51 @@ namespace sparrow
             std::vector<ArrowArray> children_arrays(2);
             std::vector<ArrowSchema> children_schemas(2);
 
-            test::fill_schema_and_array<T0>(children_schemas[0], children_arrays[0], n, 0/*offset*/, {});
+            test::fill_schema_and_array<T0>(children_schemas[0], children_arrays[0], n, 0 /*offset*/, {});
             children_schemas[0].name = "item 0";
 
-            test::fill_schema_and_array<T1>(children_schemas[1], children_arrays[1], n, 0/*offset*/, {});
+            test::fill_schema_and_array<T1>(children_schemas[1], children_arrays[1], n, 0 /*offset*/, {});
             children_schemas[1].name = "item 1";
 
             ArrowArray arr{};
             ArrowSchema schema{};
-            test::fill_schema_and_array_for_struct_layout(schema, arr, std::move(children_schemas), std::move(children_arrays), {});
+            test::fill_schema_and_array_for_struct_layout(
+                schema,
+                arr,
+                std::move(children_schemas),
+                std::move(children_arrays),
+                {}
+            );
             return arrow_proxy(std::move(arr), std::move(schema));
         }
     }
 
     TEST_SUITE("struct_array")
-    {   
+    {
         static_assert(is_struc_array_v<struct_array>);
 
         TEST_CASE("constructors")
         {
-            primitive_array<std::int16_t> flat_arr({{std::int16_t(0), std::int16_t(1), std::int16_t(2), std::int16_t(3)}});
+            primitive_array<std::int16_t> flat_arr(
+                {{std::int16_t(0), std::int16_t(1), std::int16_t(2), std::int16_t(3)}}
+            );
             primitive_array<float> flat_arr2({{4.0f, 5.0f, 6.0f, 7.0f}});
-            primitive_array<std::int32_t> flat_arr3({{std::int32_t(8), std::int32_t(9), std::int32_t(10), std::int32_t(11)}});
+            primitive_array<std::int32_t> flat_arr3(
+                {{std::int32_t(8), std::int32_t(9), std::int32_t(10), std::int32_t(11)}}
+            );
 
             // detyped arrays
-            std::vector<array> children = {array(std::move(flat_arr)), array(std::move(flat_arr2)), array(std::move(flat_arr3))};
+            std::vector<array> children = {
+                array(std::move(flat_arr)),
+                array(std::move(flat_arr2)),
+                array(std::move(flat_arr3))
+            };
 
             struct_array arr(std::move(children));
 
             // check the size
             REQUIRE_EQ(arr.size(), 4);
-            
+
             // check the children
             REQUIRE_EQ(arr[0].value().size(), 3);
             REQUIRE_EQ(arr[1].value().size(), 3);
@@ -78,19 +91,17 @@ namespace sparrow
             CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[0], std::int16_t(1));
             CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[1], float(5.0f));
             CHECK_NULLABLE_VARIANT_EQ(arr[1].value()[2], std::int32_t(9));
-            
+
             CHECK_NULLABLE_VARIANT_EQ(arr[2].value()[0], std::int16_t(2));
             CHECK_NULLABLE_VARIANT_EQ(arr[2].value()[1], float(6.0f));
             CHECK_NULLABLE_VARIANT_EQ(arr[2].value()[2], std::int32_t(10));
-
-
         };
 
 
-        TEST_CASE_TEMPLATE("struct[T, uint8]",T,  std::uint8_t, std::int32_t, float, double)
+        TEST_CASE_TEMPLATE("struct[T, uint8]", T, std::uint8_t, std::int32_t, float, double)
         {
             using inner_scalar_type = T;
-            //using inner_nullable_type = nullable<inner_scalar_type>;
+            // using inner_nullable_type = nullable<inner_scalar_type>;
 
             // number of elements in the struct array
             const std::size_t n = 4;
@@ -140,9 +151,9 @@ namespace sparrow
                     REQUIRE(val1_variant.has_value());
 
 
-                    //using const_scalar_ref = const inner_scalar_type&;
-                    using nullable_inner_scalar_type = nullable<const inner_scalar_type &, bool >;
-                    using nullable_uint8_t = nullable<const  std::uint8_t & , bool >;
+                    // using const_scalar_ref = const inner_scalar_type&;
+                    using nullable_inner_scalar_type = nullable<const inner_scalar_type&, bool>;
+                    using nullable_uint8_t = nullable<const std::uint8_t&, bool>;
 
                     // visit the variant
                     std::visit(
@@ -174,7 +185,6 @@ namespace sparrow
                         },
                         val1_variant
                     );
-
                 }
             }
 
@@ -185,12 +195,11 @@ namespace sparrow
             }
 
             SUBCASE("consistency")
-            {   
+            {
                 test::generic_consistency_test(struct_arr);
-            }  
+            }
         }
     }
 
 
 }
-
diff --git a/test/test_traits.cpp b/test/test_traits.cpp
index 85ae5455..7bcd14cd 100644
--- a/test/test_traits.cpp
+++ b/test/test_traits.cpp
@@ -15,7 +15,6 @@
 #include <sparrow/layout/primitive_array.hpp>
 #include <sparrow/types/data_traits.hpp>
 
-
 /////////////////////////////////////////////////////////////////////////////////////////
 // Opt-in support for custom C++ representations of arrow data types.
 
@@ -42,15 +41,21 @@ namespace sparrow
     static_assert(mpl::all_of(all_base_types_t{}, predicate::has_arrow_traits));
 
 
-// Native basic standard types support
+    // Native basic standard types support
 
     using basic_native_types = mpl::typelist<
         bool,
-        char, unsigned char, signed char,
-        short, unsigned short,
-        int, unsigned int,
-        long, unsigned long, // `long long` could be bigger than 64bits and is not supported
-        float, double, // `long double` could be bigger than 64bit and is not supported
+        char,
+        unsigned char,
+        signed char,
+        short,
+        unsigned short,
+        int,
+        unsigned int,
+        long,
+        unsigned long,  // `long long` could be bigger than 64bits and is not supported
+        float,
+        double,  // `long double` could be bigger than 64bit and is not supported
         std::uint8_t,
         std::int8_t,
         std::uint16_t,
@@ -61,12 +66,10 @@ namespace sparrow
         std::int64_t,
         float16_t,
         float32_t,
-        float64_t
-        >;
+        float64_t>;
 
     template <std::integral T>
-    consteval
-    bool is_possible_arrow_data_type(data_type type_id)
+    consteval bool is_possible_arrow_data_type(data_type type_id)
     {
         // NOTE:
         // `char` is not specified by the C and C++ standard to be `signed` or `unsigned`.
@@ -121,8 +124,7 @@ namespace sparrow
     }
 
     template <std::floating_point T>
-    consteval
-    bool is_possible_arrow_data_type(data_type type_id)
+    consteval bool is_possible_arrow_data_type(data_type type_id)
     {
         switch (type_id)
         {
@@ -142,8 +144,7 @@ namespace sparrow
     {
         template <class T>
             requires has_arrow_type_traits<T>
-        consteval
-        bool operator()(mpl::typelist<T>)
+        consteval bool operator()(mpl::typelist<T>)
         {
             constexpr auto deduced_type_id = data_type_from_size<T>();
             static_assert(deduced_type_id == arrow_traits<T>::type_id);
diff --git a/test/test_union_array.cpp b/test/test_union_array.cpp
index 1f90a4b2..23b552aa 100644
--- a/test/test_union_array.cpp
+++ b/test/test_union_array.cpp
@@ -12,72 +12,92 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "sparrow/array.hpp"
+#include "sparrow/layout/dispatch.hpp"
 #include "sparrow/layout/primitive_array.hpp"
+#include "sparrow/layout/union_array.hpp"
 #include "sparrow/utils/nullable.hpp"
-#include "sparrow/layout/dispatch.hpp"
-#include "doctest/doctest.h"
 
-#include "test_utils.hpp"
 #include "../test/external_array_data_creation.hpp"
-
-#include "sparrow/layout/union_array.hpp"
-#include "sparrow/array.hpp"
+#include "doctest/doctest.h"
+#include "test_utils.hpp"
 
 namespace sparrow
 {
 
     namespace test
     {
-        arrow_proxy make_sparse_union_proxy(const std::string& format_string, std::size_t n, bool altered = false)
+        arrow_proxy
+        make_sparse_union_proxy(const std::string& format_string, std::size_t n, bool altered = false)
         {
             std::vector<ArrowArray> children_arrays(2);
             std::vector<ArrowSchema> children_schemas(2);
 
-            test::fill_schema_and_array<float>(children_schemas[0], children_arrays[0], n, 0/*offset*/, {});
+            test::fill_schema_and_array<float>(children_schemas[0], children_arrays[0], n, 0 /*offset*/, {});
             children_schemas[0].name = "item 0";
 
-            test::fill_schema_and_array<std::uint16_t>(children_schemas[1], children_arrays[1], n, 0/*offset*/, {});
+            test::fill_schema_and_array<std::uint16_t>(children_schemas[1], children_arrays[1], n, 0 /*offset*/, {});
             children_schemas[1].name = "item 1";
 
             ArrowArray arr{};
             ArrowSchema schema{};
 
-            std::vector<std::uint8_t> type_ids = {std::uint8_t(3), std::uint8_t(4), std::uint8_t(3), std::uint8_t(4)};
+            std::vector<std::uint8_t> type_ids =
+                {std::uint8_t(3), std::uint8_t(4), std::uint8_t(3), std::uint8_t(4)};
             if (altered)
             {
                 type_ids[0] = std::uint8_t(4);
             }
-            
+
             test::fill_schema_and_array_for_sparse_union(
-                schema, arr, std::move(children_schemas), std::move(children_arrays), type_ids, format_string
+                schema,
+                arr,
+                std::move(children_schemas),
+                std::move(children_arrays),
+                type_ids,
+                format_string
             );
 
             return arrow_proxy(std::move(arr), std::move(schema));
         }
 
-        arrow_proxy make_dense_union_proxy(const std::string& format_string, std::size_t n_c, bool altered = false)
+        arrow_proxy
+        make_dense_union_proxy(const std::string& format_string, std::size_t n_c, bool altered = false)
         {
             std::vector<ArrowArray> children_arrays(2);
             std::vector<ArrowSchema> children_schemas(2);
 
-            test::fill_schema_and_array<float>(children_schemas[0], children_arrays[0], n_c, 0/*offset*/, {});
+            test::fill_schema_and_array<float>(children_schemas[0], children_arrays[0], n_c, 0 /*offset*/, {});
             children_schemas[0].name = "item 0";
 
-            test::fill_schema_and_array<std::uint16_t>(children_schemas[1], children_arrays[1], n_c, 0/*offset*/, {});
+            test::fill_schema_and_array<std::uint16_t>(
+                children_schemas[1],
+                children_arrays[1],
+                n_c,
+                0 /*offset*/,
+                {}
+            );
             children_schemas[1].name = "item 1";
 
             ArrowArray arr{};
             ArrowSchema schema{};
 
-            std::vector<std::uint8_t> type_ids = {std::uint8_t(3), std::uint8_t(4), std::uint8_t(3), std::uint8_t(4)};
+            std::vector<std::uint8_t> type_ids =
+                {std::uint8_t(3), std::uint8_t(4), std::uint8_t(3), std::uint8_t(4)};
             if (altered)
             {
                 type_ids[0] = std::uint8_t(4);
             }
-            std::vector<std::int32_t> offsets = {0,0,1,1};
-            
+            std::vector<std::int32_t> offsets = {0, 0, 1, 1};
+
             test::fill_schema_and_array_for_dense_union(
-                schema, arr, std::move(children_schemas), std::move(children_arrays), type_ids, offsets, format_string
+                schema,
+                arr,
+                std::move(children_schemas),
+                std::move(children_arrays),
+                type_ids,
+                offsets,
+                format_string
             );
 
             return arrow_proxy(std::move(arr), std::move(schema));
@@ -85,33 +105,35 @@ namespace sparrow
     }
 
     TEST_SUITE("sparse_union")
-    {   
+    {
         static_assert(is_sparse_union_array_v<sparse_union_array>);
         static_assert(!is_dense_union_array_v<sparse_union_array>);
 
         TEST_CASE("constructor")
-        {   
+        {
             // the child arrays
             primitive_array<std::int16_t> arr1({{std::int16_t(2), std::int16_t(5), std::size_t(9)}});
             primitive_array<std::int32_t> arr2(
                 std::vector<std::int32_t>{std::int32_t(3), std::int32_t(4), std::size_t(5)},
-                std::vector<std::size_t>{1} // INDEX 1 IS MISSING
-            ); 
+                std::vector<std::size_t>{1}  // INDEX 1 IS MISSING
+            );
 
             // detyped arrays
             std::vector<array> children = {array(std::move(arr1)), array(std::move(arr2))};
-       
+
 
             SUBCASE("with mapping")
             {
                 // type ids
-                sparse_union_array::type_id_buffer_type type_ids{{std::uint8_t(2), std::uint8_t(3), std::uint8_t(3)}};
+                sparse_union_array::type_id_buffer_type type_ids{
+                    {std::uint8_t(2), std::uint8_t(3), std::uint8_t(3)}
+                };
 
                 // mapping
                 std::vector<std::size_t> type_mapping{2, 3};
 
                 // the array
-                sparse_union_array arr( std::move(children), std::move(type_ids), std::move(type_mapping));
+                sparse_union_array arr(std::move(children), std::move(type_ids), std::move(type_mapping));
 
                 // check the size
                 REQUIRE_EQ(arr.size(), 3);
@@ -127,10 +149,12 @@ namespace sparrow
             SUBCASE("without mapping")
             {
                 // type ids
-                sparse_union_array::type_id_buffer_type type_ids{{std::uint8_t(0), std::uint8_t(1), std::uint8_t(1)}};
+                sparse_union_array::type_id_buffer_type type_ids{
+                    {std::uint8_t(0), std::uint8_t(1), std::uint8_t(1)}
+                };
 
                 // the array
-                sparse_union_array arr( std::move(children), std::move(type_ids));
+                sparse_union_array arr(std::move(children), std::move(type_ids));
 
                 // check the size
                 REQUIRE_EQ(arr.size(), 3);
@@ -143,11 +167,9 @@ namespace sparrow
                 CHECK_NULLABLE_VARIANT_EQ(arr[0], std::int16_t(2));
                 CHECK_NULLABLE_VARIANT_EQ(arr[2], std::int32_t(5));
             }
- 
         }
         TEST_CASE("basics")
         {
-
             const std::string format_string = "+us:3,4";
             const std::size_t n = 4;
 
@@ -188,92 +210,108 @@ namespace sparrow
                     REQUIRE(val.has_value());
                 }
 
-                // 0 
-                std::visit([](auto&& arg) {
-                    using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                    if constexpr (std::is_same_v<inner_type, float>)
+                // 0
+                std::visit(
+                    [](auto&& arg)
                     {
-                        REQUIRE_EQ(0.0f, arg.value());
-                    }
-                    else
-                    {
-                        CHECK(false);
-                    }
-                
-                }, uarr[0]);
+                        using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                        if constexpr (std::is_same_v<inner_type, float>)
+                        {
+                            REQUIRE_EQ(0.0f, arg.value());
+                        }
+                        else
+                        {
+                            CHECK(false);
+                        }
+                    },
+                    uarr[0]
+                );
 
                 // 1
-                std::visit([](auto&& arg) {
-                    using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                    if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+                std::visit(
+                    [](auto&& arg)
                     {
-                        REQUIRE_EQ(1, arg.value());
-                    }
-                    else
+                        using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                        if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+                        {
+                            REQUIRE_EQ(1, arg.value());
+                        }
+                        else
+                        {
+                            CHECK(false);
+                        }
+                    },
+                    uarr[1]
+                );
+
+                // 2
+                std::visit(
+                    [](auto&& arg)
                     {
-                        CHECK(false);
-                    }
-                
-                }, uarr[1]);
-
-                // 2 
-                std::visit([](auto&& arg) {
-                    using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                    if constexpr (std::is_same_v<inner_type, float>)
-                    {
-                        REQUIRE_EQ(2.0f, arg.value());
-                    }
-                    else
+                        using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                        if constexpr (std::is_same_v<inner_type, float>)
+                        {
+                            REQUIRE_EQ(2.0f, arg.value());
+                        }
+                        else
+                        {
+                            CHECK(false);
+                        }
+                    },
+                    uarr[2]
+                );
+
+                // 3
+                std::visit(
+                    [](auto&& arg)
                     {
-                        CHECK(false);
-                    }
-                
-                }, uarr[2]);
-
-                // 3 
-                std::visit([](auto&& arg) {
-                    using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                    if constexpr (std::is_same_v<inner_type, std::uint16_t>)
-                    {
-                        REQUIRE_EQ(3, arg.value());
-                    }
-                    else
-                    {
-                        CHECK(false);
-                    }
-                
-                }, uarr[3]);
-                
+                        using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                        if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+                        {
+                            REQUIRE_EQ(3, arg.value());
+                        }
+                        else
+                        {
+                            CHECK(false);
+                        }
+                    },
+                    uarr[3]
+                );
             }
         }
     }
+
     TEST_SUITE("dense_union")
     {
         static_assert(is_dense_union_array_v<dense_union_array>);
         static_assert(!is_sparse_union_array_v<dense_union_array>);
         TEST_CASE("constructor")
-        {   
+        {
             // the child arrays
             primitive_array<std::int16_t> arr1({{std::int16_t(0), std::int16_t(1)}});
             primitive_array<std::int32_t> arr2(
                 std::vector<std::int32_t>{std::int32_t(2), std::int32_t(3)},
-                std::vector<std::size_t>{1} // INDEX 1 IS MISSING
-            ); 
+                std::vector<std::size_t>{1}  // INDEX 1 IS MISSING
+            );
 
             // detyped arrays
             std::vector<array> children = {array(std::move(arr1)), array(std::move(arr2))};
-       
+
 
             // offsets
-            dense_union_array::offset_buffer_type offsets{{std::size_t(1), std::size_t(1), std::size_t(0), std::size_t(0)}};
+            dense_union_array::offset_buffer_type offsets{
+                {std::size_t(1), std::size_t(1), std::size_t(0), std::size_t(0)}
+            };
 
             SUBCASE("without mapping")
             {
                 // type ids
-                dense_union_array::type_id_buffer_type type_ids{{std::uint8_t(0), std::uint8_t(1), std::uint8_t(0), std::uint8_t(1)}};
+                dense_union_array::type_id_buffer_type type_ids{
+                    {std::uint8_t(0), std::uint8_t(1), std::uint8_t(0), std::uint8_t(1)}
+                };
 
                 // the array
-                dense_union_array arr( std::move(children), std::move(type_ids), std::move(offsets));
+                dense_union_array arr(std::move(children), std::move(type_ids), std::move(offsets));
 
                 // check the size
                 REQUIRE_EQ(arr.size(), 4);
@@ -289,14 +327,20 @@ namespace sparrow
                 CHECK_NULLABLE_VARIANT_EQ(arr[3], std::int32_t(2));
             }
             SUBCASE("with mapping")
-            {   
-
+            {
                 std::vector<std::size_t> child_index_to_type_id{1, 0};
                 // type ids
-                dense_union_array::type_id_buffer_type type_ids{{std::uint8_t(1), std::uint8_t(0), std::uint8_t(1), std::uint8_t(0)}};
+                dense_union_array::type_id_buffer_type type_ids{
+                    {std::uint8_t(1), std::uint8_t(0), std::uint8_t(1), std::uint8_t(0)}
+                };
 
                 // the array
-                dense_union_array arr( std::move(children), std::move(type_ids), std::move(offsets), std::move(child_index_to_type_id));
+                dense_union_array arr(
+                    std::move(children),
+                    std::move(type_ids),
+                    std::move(offsets),
+                    std::move(child_index_to_type_id)
+                );
 
                 // check the size
                 REQUIRE_EQ(arr.size(), 4);
@@ -311,7 +355,6 @@ namespace sparrow
                 CHECK_NULLABLE_VARIANT_EQ(arr[2], std::int16_t(0));
                 CHECK_NULLABLE_VARIANT_EQ(arr[3], std::int32_t(2));
             }
-
         }
         TEST_CASE("basics")
         {
@@ -356,64 +399,75 @@ namespace sparrow
                 }
             }
 
-            // 0 
-            std::visit([](auto&& arg) {
-                using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                if constexpr (std::is_same_v<inner_type, float>)
+            // 0
+            std::visit(
+                [](auto&& arg)
                 {
-                    REQUIRE_EQ(0.0f, arg.value());
-                }
-                else
-                {
-                    CHECK(false);
-                }
-            
-            }, uarr[0]);
+                    using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                    if constexpr (std::is_same_v<inner_type, float>)
+                    {
+                        REQUIRE_EQ(0.0f, arg.value());
+                    }
+                    else
+                    {
+                        CHECK(false);
+                    }
+                },
+                uarr[0]
+            );
 
             // 1
-            std::visit([](auto&& arg) {
-                using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                if constexpr (std::is_same_v<inner_type, std::uint16_t>)
-                {
-                    REQUIRE_EQ(0, arg.value());
-                }
-                else
+            std::visit(
+                [](auto&& arg)
                 {
-                    CHECK(false);
-                }
-            
-            }, uarr[1]);
+                    using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                    if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+                    {
+                        REQUIRE_EQ(0, arg.value());
+                    }
+                    else
+                    {
+                        CHECK(false);
+                    }
+                },
+                uarr[1]
+            );
 
-            // 2 
-            std::visit([](auto&& arg) {
-                using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                if constexpr (std::is_same_v<inner_type, float>)
-                {
-                    REQUIRE_EQ(1.0f, arg.value());
-                }
-                else
+            // 2
+            std::visit(
+                [](auto&& arg)
                 {
-                    CHECK(false);
-                }
-            
-            }, uarr[2]);
+                    using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                    if constexpr (std::is_same_v<inner_type, float>)
+                    {
+                        REQUIRE_EQ(1.0f, arg.value());
+                    }
+                    else
+                    {
+                        CHECK(false);
+                    }
+                },
+                uarr[2]
+            );
 
             // 3
-            std::visit([](auto&& arg) {
-                using inner_type = std::decay_t< typename std::decay_t<decltype(arg)>::value_type>;
-                if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+            std::visit(
+                [](auto&& arg)
                 {
-                    REQUIRE_EQ(1, arg.value());
-                }
-                else
-                {
-                    CHECK(false);
-                }
-            
-            }, uarr[3]);
+                    using inner_type = std::decay_t<typename std::decay_t<decltype(arg)>::value_type>;
+                    if constexpr (std::is_same_v<inner_type, std::uint16_t>)
+                    {
+                        REQUIRE_EQ(1, arg.value());
+                    }
+                    else
+                    {
+                        CHECK(false);
+                    }
+                },
+                uarr[3]
+            );
         }
     }
 
 
 }
-
diff --git a/test/test_utils.cpp b/test/test_utils.cpp
index 63a68575..8f4a0870 100644
--- a/test/test_utils.cpp
+++ b/test/test_utils.cpp
@@ -2,4 +2,4 @@
 
 namespace sparrow
 {
-} // namespace sparrow  
\ No newline at end of file
+}  // namespace sparrow
\ No newline at end of file
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index ba433a1c..361dae90 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -1,25 +1,29 @@
 #pragma once
-#include "doctest/doctest.h"
+#include <algorithm>
 
-#include "sparrow/utils/nullable.hpp"
 #include "sparrow/array.hpp"
-#include <algorithm>
+#include "sparrow/utils/nullable.hpp"
+
+#include "doctest/doctest.h"
 
 namespace sparrow::test
 {
 
-    template<class ARRAY_TYPE>
-    void generic_consistency_test_impl(ARRAY_TYPE && typed_arr){
+    template <class ARRAY_TYPE>
+    void generic_consistency_test_impl(ARRAY_TYPE&& typed_arr)
+    {
         using array_type = std::decay_t<ARRAY_TYPE>;
         const auto size = typed_arr.size();
 
         // check that iterators sizes are consistent
-        SUBCASE("iterators"){
+        SUBCASE("iterators")
+        {
             auto it = typed_arr.begin();
             auto it_end = typed_arr.end();
             CHECK(std::distance(it, it_end) == size);
         }
-        SUBCASE("const iterators"){
+        SUBCASE("const iterators")
+        {
             auto it = typed_arr.cbegin();
             auto it_end = typed_arr.cend();
             CHECK(std::distance(it, it_end) == size);
@@ -32,64 +36,73 @@ namespace sparrow::test
             sparrow::array arr(std::move(arr_copy));
 
             // detyped visit
-            arr.visit([&](auto && v) {
-                using typed_array_type = std::decay_t<decltype(v)>;
-                CHECK(std::is_same_v<typed_array_type, array_type>);
-                if constexpr(std::is_same_v<typed_array_type, ARRAY_TYPE>)
+            arr.visit(
+                [&](auto&& v)
                 {
-                    CHECK(v == typed_arr);
+                    using typed_array_type = std::decay_t<decltype(v)>;
+                    CHECK(std::is_same_v<typed_array_type, array_type>);
+                    if constexpr (std::is_same_v<typed_array_type, ARRAY_TYPE>)
+                    {
+                        CHECK(v == typed_arr);
+                    }
                 }
-            });
-
+            );
         }
     }
 
-    template<class ARRAY_TYPE>
-    void generic_consistency_test(ARRAY_TYPE & array){
-        
-        // array as array 
+    template <class ARRAY_TYPE>
+    void generic_consistency_test(ARRAY_TYPE& array)
+    {
+        // array as array
         generic_consistency_test_impl(array);
 
-        // const array 
-        const auto & const_array = array;
+        // const array
+        const auto& const_array = array;
         generic_consistency_test_impl(const_array);
     }
 
+// ensure that the variant (of nullables) has a value
+// and that the value is equal to the expected value
+// (including the type)
+#define CHECK_NULLABLE_VARIANT_EQ(variant, value) \
+    sparrow::test::check_nullable_variant_eq(variant, value, __FILE__, __LINE__)
 
-    // ensure that the variant (of nullables) has a value
-    // and that the value is equal to the expected value
-    // (including the type)
-    #define CHECK_NULLABLE_VARIANT_EQ(variant, value) sparrow::test::check_nullable_variant_eq(variant, value, __FILE__, __LINE__)
-    
     template <class V, class T>
-    static void check_nullable_variant_eq(const V & variant, const T & value,const char* file, int line)
+    static void check_nullable_variant_eq(const V& variant, const T& value, const char* file, int line)
     {
-        return std::visit([&](auto && v) { 
-
-            // v is a nullable
-            using nullable_type = std::decay_t<decltype(v)>;
-            using inner_type = std::decay_t<typename nullable_type::value_type>;
-
-            if constexpr(std::is_same_v<inner_type, T>)
+        return std::visit(
+            [&](auto&& v)
             {
-                if (v.has_value())
+                // v is a nullable
+                using nullable_type = std::decay_t<decltype(v)>;
+                using inner_type = std::decay_t<typename nullable_type::value_type>;
+
+                if constexpr (std::is_same_v<inner_type, T>)
                 {
-                    if(v.value() != value)
+                    if (v.has_value())
+                    {
+                        if (v.value() != value)
+                        {
+                            ADD_FAIL_AT(
+                                file,
+                                line,
+                                "value mismatch: expected " << value << " but got " << v.value()
+                            );
+                        }
+                    }
+                    else
                     {
-                        ADD_FAIL_AT(file, line, "value mismatch: expected " << value << " but got " << v.value());
+                        ADD_FAIL_AT(file, line, "value is null");
                     }
                 }
                 else
                 {
-                    ADD_FAIL_AT(file, line, "value is null");
+                    ADD_FAIL_AT(file, line, "type mismatch");
                 }
-            }
-            else
-            {
-                ADD_FAIL_AT(file, line, "type mismatch");
-            }
-        }, variant);
+            },
+            variant
+        );
     }
 
-    
+
 };
\ No newline at end of file
diff --git a/test/test_utils_buffers.cpp b/test/test_utils_buffers.cpp
index 0b3a98a2..a85dbcba 100644
--- a/test/test_utils_buffers.cpp
+++ b/test/test_utils_buffers.cpp
@@ -18,7 +18,6 @@
 
 #include "doctest/doctest.h"
 
-
 namespace sparrow
 {
     TEST_SUITE("number_of_bytes")
diff --git a/test/test_utils_offsets.cpp b/test/test_utils_offsets.cpp
index 78c566fd..542ffdac 100644
--- a/test/test_utils_offsets.cpp
+++ b/test/test_utils_offsets.cpp
@@ -14,9 +14,10 @@
 
 #include <array>
 
-#include "doctest/doctest.h"
 #include "sparrow/utils/offsets.hpp"
 
+#include "doctest/doctest.h"
+
 namespace sparrow
 {
     TEST_SUITE("make_offset_buffer")
diff --git a/test/test_variable_size_binary_view_array.cpp b/test/test_variable_size_binary_view_array.cpp
index 63a46825..67aeb754 100644
--- a/test/test_variable_size_binary_view_array.cpp
+++ b/test/test_variable_size_binary_view_array.cpp
@@ -11,11 +11,12 @@
 // 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.
+#include <string>
+#include <vector>
+
 #include "sparrow/layout/variable_size_binary_view_array.hpp"
-#include "test_utils.hpp"
 
-#include <vector>
-#include <string>
+#include "test_utils.hpp"
 
 using namespace std::literals;
 
@@ -28,9 +29,9 @@ namespace sparrow
             std::vector<std::string> words{
                 "short",
                 "longer",
-                "abcdefghijk",   // exactly 11
-                "abcdefghijkl",   // exactly 12
-                "123456789101112", // longer than 12,
+                "abcdefghijk",      // exactly 11
+                "abcdefghijkl",     // exactly 12
+                "123456789101112",  // longer than 12,
                 "hello world this is a long string"
             };
 
@@ -39,9 +40,9 @@ namespace sparrow
             string_view_array array(words, where_nulls);
 
 
-            for(std::size_t i = 0; i < words.size(); ++i)
+            for (std::size_t i = 0; i < words.size(); ++i)
             {
-                if(i == 1)
+                if (i == 1)
                 {
                     CHECK_FALSE(array[i].has_value());
                 }