diff --git a/include/libhal-util/bit.hpp b/include/libhal-util/bit.hpp
index 1b7f6fb..60996ce 100644
--- a/include/libhal-util/bit.hpp
+++ b/include/libhal-util/bit.hpp
@@ -19,8 +19,8 @@
 #include <cstdint>
 #include <limits>
 
-namespace hal::bit {
-struct mask
+namespace hal {
+struct bitmask
 {
   /// Where the bit mask starts
   std::uint32_t position;
@@ -28,96 +28,102 @@ struct mask
   std::uint32_t width;
 
   /**
-   * @brief Generate, at compile time, a mask that spans the from position1 to
-   * position2.
+   * @brief Generate, at compile time, a bitmask that spans the from position1
+   * to position2.
    *
-   * If position1 is the same position2 then the mask will have length of 1 and
-   * the bit position will be the value of position1.
+   * If position1 is the same position2 then the bitmask will have length of 1
+   * and the bit position will be the value of position1.
    *
    * position1 and position2 can be in any order so long as they span the
-   * distance from the start and end of the masked range.
+   * distance from the start and end of the bitmask range.
    *
    * @tparam position1 - bit position 1
    * @tparam position2 - bit position 2
-   * @return consteval mask - bit mask represented by the two bit positions
+   * @return consteval bitmask - bit bitmask represented by the two bit
+   * positions
    */
   template<std::uint32_t position1, std::uint32_t position2>
-  static consteval mask from()
+  static consteval bitmask from()
   {
     constexpr std::uint32_t plus_one = 1;
     if constexpr (position1 < position2) {
-      return mask{ .position = position1,
-                   .width = plus_one + (position2 - position1) };
+      return bitmask{ .position = position1,
+                      .width = plus_one + (position2 - position1) };
     } else {
-      return mask{ .position = position2,
-                   .width = plus_one + (position1 - position2) };
+      return bitmask{ .position = position2,
+                      .width = plus_one + (position1 - position2) };
     }
   }
 
   /**
-   * @brief Generate, at compile time, a single bit width mask at position
+   * @brief Generate, at compile time, a single bit width bitmask at position
    *
-   * @tparam position - the bit to make the mask for
-   * @return constexpr mask - bit mask with the position bit set to position
+   * @tparam position - the bit to make the bitmask for
+   * @return constexpr bitmask - bit bitmask with the position bit set to
+   * position
    */
   template<std::uint32_t position>
-  static constexpr mask from()
+  static constexpr bitmask from()
   {
-    return mask{ .position = position, .width = 1U };
+    return bitmask{ .position = position, .width = 1U };
   }
 
   /**
-   * @brief Generate, at compile time, a mask that spans the from position1 to
-   * position2.
+   * @brief Generate, at compile time, a bitmask that spans the from position1
+   * to position2.
    *
-   * If position1 is the same position2 then the mask will have length of 1 and
-   * the bit position will be the value of position1.
+   * If position1 is the same position2 then the bitmask will have length of 1
+   * and the bit position will be the value of position1.
    *
    * position1 and position2 can be in any order so long as they span the
-   * distance from the start and end of the masked range.
+   * distance from the start and end of the bitmask range.
    *
    * @param position1 - bit position 1
    * @param position2 - bit position 2
-   * @return consteval mask - bit mask represented by the two bit positions
+   * @return consteval bitmask - bit bitmask represented by the two bit
+   * positions
    */
-  static consteval mask from(std::uint32_t position1, std::uint32_t position2)
+  static consteval bitmask from(std::uint32_t position1,
+                                std::uint32_t position2)
   {
     constexpr std::uint32_t plus_one = 1;
     if (position1 < position2) {
-      return mask{ .position = position1,
-                   .width = plus_one + (position2 - position1) };
+      return bitmask{ .position = position1,
+                      .width = plus_one + (position2 - position1) };
     } else {
-      return mask{ .position = position2,
-                   .width = plus_one + (position1 - position2) };
+      return bitmask{ .position = position2,
+                      .width = plus_one + (position1 - position2) };
     }
   }
 
   /**
-   * @brief Generate, at runtime, a single bit width mask at position
+   * @brief Generate, at runtime, a single bit width bitmask at position
    *
-   * @param position - the bit to make the mask for
-   * @return constexpr mask - bit mask with the position bit set to position
+   * @param position - the bit to make the bitmask for
+   * @return constexpr bitmask - bit bitmask with the position bit set to
+   * position
    */
-  static constexpr mask from(std::uint32_t position)
+  static constexpr bitmask from(std::uint32_t position)
   {
-    return mask{ .position = position, .width = 1U };
+    return bitmask{ .position = position, .width = 1U };
   }
 
   /**
-   * @brief Convert mask to a integral representation but with bit position at 0
+   * @brief Convert bitmask to a integral representation but with bit position
+   * at 0
    *
    * The integral presentation will have 1 bits starting from the position bit
    * up to bit position + width. All other bits will be 0s.
    *
    * For example:
    *
-   *      value<std::uint16_t>(mask{
+   *      value<std::uint16_t>(bitmask{
    *          .position = 1,
    *          .width = 4,
    *      }); // returns = 0b0000'0000'0000'1111;
    *
-   * @tparam T - unsigned integral type to hold the mask
-   * @return constexpr auto - mask value as an unsigned integer
+   * @tparam T - unsigned integral type to hold the bitmask
+   * @return constexpr auto - bitmask value as an unsigned integer
    */
   template<std::unsigned_integral T>
   constexpr auto origin() const
@@ -129,8 +135,8 @@ struct mask
     // At compile time calculate the number of bits in the target parameter.
     constexpr size_t target_width = sizeof(T) * 8;
 
-    // Create mask by shifting the set of 1s down so that the number of 1s from
-    // bit position 0 is equal to the width parameter.
+    // Create bitmask by shifting the set of 1s down so that the number of 1s
+    // from bit position 0 is equal to the width parameter.
     T mask_at_origin = static_cast<T>(field_of_ones >> (target_width - width));
 
     return mask_at_origin;
@@ -144,7 +150,7 @@ struct mask
    *
    * For example:
    *
-   *      value<std::uint16_t>(mask{
+   *      value<std::uint16_t>(bitmask{
    *          .position = 1,
    *          .width = 4,
    *      }); // returns = 0b0000'0000'0001'1110;
@@ -165,7 +171,7 @@ struct mask
    * @return true - the masks are the same
    * @return false - the masks are not the same
    */
-  constexpr bool operator==(const mask& other)
+  constexpr bool operator==(const bitmask& other)
   {
     return other.position == position && other.width == width;
   }
@@ -183,16 +189,16 @@ struct byte_mask
    * @brief Mask value defined at compile time
    *
    */
-  static constexpr hal::bit::mask value{ .position = ByteIndex, .width = 8 };
+  static constexpr hal::bitmask value{ .position = ByteIndex, .width = 8 };
 };
 
 /**
- * @brief Shorthand for using hal::bit::byte_mask<N>::value
+ * @brief Shorthand for using hal::byte_mask<N>::value
  *
  * @tparam ByteIndex - the byte position to make a mask for
  */
 template<size_t ByteIndex>
-constexpr hal::bit::mask byte_m = byte_mask<ByteIndex>::value;
+constexpr hal::bitmask byte_m = byte_mask<ByteIndex>::value;
 
 /**
  * @brief Helper for generating nibble position masks
@@ -202,18 +208,18 @@ constexpr hal::bit::mask byte_m = byte_mask<ByteIndex>::value;
 template<size_t NibbleIndex>
 struct nibble_mask
 {
-  static constexpr hal::bit::mask value{ .position = NibbleIndex, .width = 4 };
+  static constexpr hal::bitmask value{ .position = NibbleIndex, .width = 4 };
 };
 
 /**
- * @brief Shorthand for using hal::bit::nibble_mask<N>::value
+ * @brief Shorthand for using hal::nibble_mask<N>::value
  *
  * @tparam NibbleIndex - the nibble position to make a mask for
  */
 template<size_t NibbleIndex>
-constexpr hal::bit::mask nibble_m = nibble_mask<NibbleIndex>::value;
+constexpr hal::bitmask nibble_m = nibble_mask<NibbleIndex>::value;
 
-template<mask field>
+template<bitmask field>
 constexpr auto extract(std::unsigned_integral auto p_value)
 {
   using T = decltype(p_value);
@@ -225,7 +231,7 @@ constexpr auto extract(std::unsigned_integral auto p_value)
   return static_cast<T>(masked);
 }
 
-constexpr auto extract(mask p_field, std::unsigned_integral auto p_value)
+constexpr auto extract(bitmask p_field, std::unsigned_integral auto p_value)
 {
   using T = decltype(p_value);
   // Shift desired value to the right to position 0
@@ -247,7 +253,7 @@ class value
   {
   }
 
-  template<mask field>
+  template<bitmask field>
   constexpr auto& set()
   {
     static_assert(field.position < width,
@@ -259,7 +265,7 @@ class value
     return *this;
   }
 
-  constexpr auto& set(mask p_field)
+  constexpr auto& set(bitmask p_field)
   {
     const auto mask = static_cast<T>(1U << p_field.position);
 
@@ -268,7 +274,7 @@ class value
     return *this;
   }
 
-  template<mask field>
+  template<bitmask field>
   constexpr auto& clear()
   {
     static_assert(field.position < width,
@@ -281,7 +287,7 @@ class value
     return *this;
   }
 
-  constexpr auto& clear(mask p_field)
+  constexpr auto& clear(bitmask p_field)
   {
     const auto mask = static_cast<T>(1U << p_field.position);
     const auto inverted_mask = ~mask;
@@ -291,7 +297,7 @@ class value
     return *this;
   }
 
-  template<mask field>
+  template<bitmask field>
   constexpr auto& toggle()
   {
     static_assert(field.position < width,
@@ -304,7 +310,7 @@ class value
     return *this;
   }
 
-  constexpr auto& toggle(mask p_field)
+  constexpr auto& toggle(bitmask p_field)
   {
     const auto mask = static_cast<T>(1U << p_field.position);
 
@@ -313,7 +319,7 @@ class value
     return *this;
   }
 
-  template<mask field>
+  template<bitmask field>
   constexpr auto& insert(std::unsigned_integral auto p_value)
   {
     const auto value_to_insert = static_cast<T>(p_value);
@@ -330,7 +336,7 @@ class value
     return *this;
   }
 
-  constexpr auto& insert(mask p_field, std::unsigned_integral auto p_value)
+  constexpr auto& insert(bitmask p_field, std::unsigned_integral auto p_value)
   {
     // AND value with mask to remove any bits beyond the specified width.
     // Shift masked value into bit position and OR with target value.
@@ -378,4 +384,4 @@ class modify : public value<T>
 private:
   volatile T* m_pointer;
 };
-}  // namespace hal::bit
+}  // namespace hal
diff --git a/include/libhal-util/streams.hpp b/include/libhal-util/streams.hpp
index a597127..ac92e26 100644
--- a/include/libhal-util/streams.hpp
+++ b/include/libhal-util/streams.hpp
@@ -22,12 +22,11 @@
 #include <libhal/units.hpp>
 
 namespace hal {
-namespace stream {
 /**
  * @brief Discard received bytes until the sequence is found
  *
  */
-class find
+class stream_find
 {
 public:
   /**
@@ -37,11 +36,11 @@ class find
    * pointed to by this span must outlive this object, or not be used when the
    * lifetime of that data is no longer available.
    */
-  explicit find(std::span<const hal::byte> p_sequence);
+  explicit stream_find(std::span<const hal::byte> p_sequence);
 
   friend std::span<const hal::byte> operator|(
     const std::span<const hal::byte>& p_input_data,
-    find& p_self);
+    stream_find& p_self);
 
   work_state state();
 
@@ -54,7 +53,7 @@ class find
  * @brief Non-blocking callable for reading serial data into a buffer
  *
  */
-class fill
+class stream_fill
 {
 public:
   /**
@@ -62,7 +61,7 @@ class fill
    *
    * @param p_buffer - buffer to read data into
    */
-  explicit fill(std::span<hal::byte> p_buffer);
+  explicit stream_fill(std::span<hal::byte> p_buffer);
 
   /**
    * @brief Construct a new fill object
@@ -71,11 +70,11 @@ class fill
    * @param p_fill_amount - reference to a size value to limit the fill amount
    * by.
    */
-  fill(std::span<hal::byte> p_buffer, const size_t& p_fill_amount);
+  stream_fill(std::span<hal::byte> p_buffer, const size_t& p_fill_amount);
 
   friend std::span<const hal::byte> operator|(
     const std::span<const hal::byte>& p_input_data,
-    fill& p_self);
+    stream_fill& p_self);
 
   work_state state();
 
@@ -88,7 +87,7 @@ class fill
  * @brief Discard received bytes until the sequence is found
  *
  */
-class fill_upto
+class stream_fill_upto
 {
 public:
   /**
@@ -99,12 +98,12 @@ class fill_upto
    * lifetime of that data is no longer available.
    * @param p_buffer - buffer to fill data into
    */
-  fill_upto(std::span<const hal::byte> p_sequence,
-            std::span<hal::byte> p_buffer);
+  stream_fill_upto(std::span<const hal::byte> p_sequence,
+                   std::span<hal::byte> p_buffer);
 
   friend std::span<const hal::byte> operator|(
     const std::span<const hal::byte>& p_input_data,
-    fill_upto& p_self);
+    stream_fill_upto& p_self);
 
   work_state state();
 
@@ -123,17 +122,17 @@ class fill_upto
  *
  */
 template<std::unsigned_integral T>
-class parse
+class stream_parse
 {
 public:
   /**
    * @brief Construct a new parse object
    */
-  explicit parse() = default;
+  explicit stream_parse() = default;
 
   friend std::span<const hal::byte> operator|(
     const std::span<const hal::byte>& p_input_data,
-    parse& p_self)
+    stream_parse& p_self)
   {
     if (p_self.m_finished) {
       return p_input_data;
@@ -176,23 +175,22 @@ class parse
  * @brief Skip number of bytes in a byte stream
  *
  */
-class skip
+class stream_skip
 {
 public:
   /**
    * @brief Construct a new skip object
    *
    */
-  explicit skip(size_t p_skip);
+  explicit stream_skip(size_t p_skip);
 
   friend std::span<const hal::byte> operator|(
     const std::span<const hal::byte>& p_input_data,
-    skip& p_self);
+    stream_skip& p_self);
 
   work_state state();
 
 private:
   size_t m_skip;
 };
-}  // namespace stream
 }  // namespace hal
diff --git a/src/streams.cpp b/src/streams.cpp
index c8b13ca..82857e7 100644
--- a/src/streams.cpp
+++ b/src/streams.cpp
@@ -23,15 +23,14 @@
 #include <libhal/units.hpp>
 
 namespace hal {
-namespace stream {
-find::find(std::span<const hal::byte> p_sequence)
+stream_find::stream_find(std::span<const hal::byte> p_sequence)
   : m_sequence(p_sequence)
 {
 }
 
 std::span<const hal::byte> operator|(
   const std::span<const hal::byte>& p_input_data,
-  find& p_self)
+  stream_find& p_self)
 {
   if (p_input_data.empty()) {
     return p_input_data;
@@ -58,7 +57,7 @@ std::span<const hal::byte> operator|(
   return p_input_data.subspan(p_input_data.size());
 }
 
-work_state find::state()
+work_state stream_find::state()
 {
   if (m_search_index == m_sequence.size()) {
     return work_state::finished;
@@ -66,12 +65,13 @@ work_state find::state()
   return work_state::in_progress;
 }
 
-fill::fill(std::span<hal::byte> p_buffer)
+stream_fill::stream_fill(std::span<hal::byte> p_buffer)
   : m_buffer(p_buffer)
 {
 }
 
-fill::fill(std::span<hal::byte> p_buffer, const size_t& p_fill_amount)
+stream_fill::stream_fill(std::span<hal::byte> p_buffer,
+                         const size_t& p_fill_amount)
   : m_buffer(p_buffer)
   , m_fill_amount(&p_fill_amount)
 {
@@ -79,7 +79,7 @@ fill::fill(std::span<hal::byte> p_buffer, const size_t& p_fill_amount)
 
 std::span<const hal::byte> operator|(
   const std::span<const hal::byte>& p_input_data,
-  fill& p_self)
+  stream_fill& p_self)
 {
   if (p_input_data.empty() || p_self.m_buffer.empty()) {
     return p_input_data;
@@ -101,7 +101,7 @@ std::span<const hal::byte> operator|(
   return p_input_data.subspan(min_size);
 }
 
-work_state fill::state()
+work_state stream_fill::state()
 {
   if (m_buffer.empty()) {
     return work_state::finished;
@@ -109,8 +109,8 @@ work_state fill::state()
   return work_state::in_progress;
 }
 
-fill_upto::fill_upto(std::span<const hal::byte> p_sequence,
-                     std::span<hal::byte> p_buffer)
+stream_fill_upto::stream_fill_upto(std::span<const hal::byte> p_sequence,
+                                   std::span<hal::byte> p_buffer)
   : m_sequence(p_sequence)
   , m_buffer(p_buffer)
 {
@@ -118,7 +118,7 @@ fill_upto::fill_upto(std::span<const hal::byte> p_sequence,
 
 std::span<const hal::byte> operator|(
   const std::span<const hal::byte>& p_input_data,
-  fill_upto& p_self)
+  stream_fill_upto& p_self)
 {
   if (p_input_data.empty() ||
       p_self.m_sequence.size() == p_self.m_search_index ||
@@ -150,7 +150,7 @@ std::span<const hal::byte> operator|(
   return p_input_data.subspan(min_size);
 }
 
-work_state fill_upto::state()
+work_state stream_fill_upto::state()
 {
   if (m_buffer.empty() && m_search_index != m_sequence.size()) {
     return work_state::failed;
@@ -161,24 +161,24 @@ work_state fill_upto::state()
   return work_state::in_progress;
 }
 
-std::span<hal::byte> fill_upto::span()
+std::span<hal::byte> stream_fill_upto::span()
 {
   return m_buffer.subspan(0, m_fill_amount);
 }
 
-std::span<hal::byte> fill_upto::unfilled()
+std::span<hal::byte> stream_fill_upto::unfilled()
 {
   return m_buffer.subspan(m_fill_amount);
 }
 
-skip::skip(size_t p_skip)
+stream_skip::stream_skip(size_t p_skip)
   : m_skip(p_skip)
 {
 }
 
 std::span<const hal::byte> operator|(
   const std::span<const hal::byte>& p_input_data,
-  skip& p_self)
+  stream_skip& p_self)
 {
   if (p_input_data.empty()) {
     return p_input_data;
@@ -193,9 +193,8 @@ std::span<const hal::byte> operator|(
   return p_input_data.subspan(min);
 }
 
-work_state skip::state()
+work_state stream_skip::state()
 {
   return (m_skip == 0) ? work_state::finished : work_state::in_progress;
 }
-}  // namespace stream
-}  // namespace hal
+}  // namespace hal
\ No newline at end of file
diff --git a/tests/bit.test.cpp b/tests/bit.test.cpp
index 854e544..80eed56 100644
--- a/tests/bit.test.cpp
+++ b/tests/bit.test.cpp
@@ -24,21 +24,21 @@ void bit_test()
   "hal::bit<template> standard usage"_test = []() {
     // Setup
     volatile std::uint32_t control_register = 1 << 15 | 1 << 16;
-    constexpr auto enable_bit = bit::mask::from<1>();
-    constexpr auto high_power_mode = bit::mask::from<15>();
-    constexpr auto clock_divider = bit::mask::from<20, 23>();
-    constexpr auto extractor_mask = bit::mask::from<16, 23>();
-    constexpr auto single_bit_mask = bit::mask::from<1>();
+    constexpr auto enable_bit = bitmask::from<1>();
+    constexpr auto high_power_mode = bitmask::from<15>();
+    constexpr auto clock_divider = bitmask::from<20, 23>();
+    constexpr auto extractor_mask = bitmask::from<16, 23>();
+    constexpr auto single_bitmask = bitmask::from<1>();
 
     // Exercise
-    bit::modify(control_register)
+    modify(control_register)
       .set<enable_bit>()
       .clear<high_power_mode>()
       .insert<clock_divider>(0xAU);
-    auto extracted = bit::extract<extractor_mask>(control_register);
-    auto probed = bit::extract<single_bit_mask>(control_register);
+    auto extracted = extract<extractor_mask>(control_register);
+    auto probed = extract<single_bitmask>(control_register);
     auto probed_inline =
-      bit::extract<bit::mask{ .position = 15, .width = 1 }>(control_register);
+      extract<bitmask{ .position = 15, .width = 1 }>(control_register);
 
     // Verify
     expect(that % 0x00A1'0002 == control_register);
@@ -50,21 +50,21 @@ void bit_test()
   "hal::bit standard usage "_test = []() {
     // Setup
     volatile std::uint32_t control_register = 1 << 15 | 1 << 16;
-    constexpr auto enable_bit = bit::mask::from<1>();
-    constexpr auto high_power_mode = bit::mask::from<15>();
-    constexpr auto clock_divider = bit::mask::from<20, 23>();
-    constexpr auto extractor_mask = bit::mask::from<16, 23>();
-    constexpr auto single_bit_mask = bit::mask::from<1>();
+    constexpr auto enable_bit = bitmask::from<1>();
+    constexpr auto high_power_mode = bitmask::from<15>();
+    constexpr auto clock_divider = bitmask::from<20, 23>();
+    constexpr auto extractor_mask = bitmask::from<16, 23>();
+    constexpr auto single_bitmask = bitmask::from<1>();
 
     // Exercise
-    bit::modify(control_register)
+    modify(control_register)
       .set(enable_bit)
       .clear(high_power_mode)
       .insert(clock_divider, 0xAU);
-    auto extracted = bit::extract(extractor_mask, control_register);
-    auto probed = bit::extract(single_bit_mask, control_register);
+    auto extracted = extract(extractor_mask, control_register);
+    auto probed = extract(single_bitmask, control_register);
     auto probed_inline =
-      bit::extract(bit::mask{ .position = 15, .width = 1 }, control_register);
+      extract(bitmask{ .position = 15, .width = 1 }, control_register);
 
     // Verify
     expect(that % 0x00A1'0002 == control_register);
diff --git a/tests/streams.test.cpp b/tests/streams.test.cpp
index 63e7b38..9598e43 100644
--- a/tests/streams.test.cpp
+++ b/tests/streams.test.cpp
@@ -106,7 +106,7 @@ void parse_stream_test()
     // Setup
     std::string_view digits_in_between = "abcd1234x---";
     auto digits_span = hal::as_bytes(digits_in_between);
-    hal::stream::parse<std::uint32_t> parse_int;
+    hal::stream_parse<std::uint32_t> parse_int;
 
     // Exercise
     auto remaining = digits_span | parse_int;
@@ -123,7 +123,7 @@ void parse_stream_test()
     // Setup
     std::string_view digits_in_between = "abcd12356789101234x---";
     auto digits_span = hal::as_bytes(digits_in_between);
-    hal::stream::parse<std::uint64_t> parse_int;
+    hal::stream_parse<std::uint64_t> parse_int;
 
     // Exercise
     auto remaining = digits_span | parse_int;
@@ -138,7 +138,7 @@ void parse_stream_test()
 
   "[parse<std::uint32_t>] empty span"_test = []() {
     // Setup
-    hal::stream::parse<std::uint32_t> parse_int;
+    hal::stream_parse<std::uint32_t> parse_int;
 
     // Exercise
     auto remaining = std::span<const hal::byte>() | parse_int;
@@ -153,7 +153,7 @@ void parse_stream_test()
     // Setup
     std::string_view digits_in_between = "abcd?efghx-[--]/";
     auto digits_span = hal::as_bytes(digits_in_between);
-    hal::stream::parse<std::uint32_t> parse_int;
+    hal::stream_parse<std::uint32_t> parse_int;
 
     // Exercise
     auto remaining = digits_span | parse_int;
@@ -170,7 +170,7 @@ void parse_stream_test()
     auto span0 = hal::as_bytes(halves[0]);
     auto span1 = hal::as_bytes(halves[1]);
 
-    hal::stream::parse<std::uint32_t> parse_int;
+    hal::stream_parse<std::uint32_t> parse_int;
 
     auto remaining0 = span0 | parse_int;
     auto remaining1 = span1 | parse_int;
@@ -192,7 +192,7 @@ void parse_stream_test()
     auto span1 = hal::as_bytes(halves[1]);
     auto span2 = hal::as_bytes(halves[2]);
 
-    hal::stream::parse<std::uint32_t> parse_int;
+    hal::stream_parse<std::uint32_t> parse_int;
 
     auto remaining0 = span0 | parse_int;
     auto remaining1 = span1 | parse_int;
@@ -217,7 +217,7 @@ void parse_stream_test()
     auto span1 = hal::as_bytes(halves[1]);
     auto span2 = hal::as_bytes(halves[2]);
 
-    hal::stream::parse<std::uint32_t> parse_int;
+    hal::stream_parse<std::uint32_t> parse_int;
 
     auto remaining0 = span0 | parse_int;
     auto remaining1 = span1 | parse_int;
@@ -240,9 +240,9 @@ void parse_stream_test()
     std::string_view three_numbers = "a123b456c789d";
     auto span = hal::as_bytes(three_numbers);
 
-    hal::stream::parse<std::uint32_t> parse_int0;
-    hal::stream::parse<std::uint32_t> parse_int1;
-    hal::stream::parse<std::uint32_t> parse_int2;
+    hal::stream_parse<std::uint32_t> parse_int0;
+    hal::stream_parse<std::uint32_t> parse_int1;
+    hal::stream_parse<std::uint32_t> parse_int2;
 
     // Exercise
     auto remaining = span | parse_int0 | parse_int1 | parse_int2;
@@ -274,7 +274,7 @@ void find_stream_test()
     // Setup
     std::string_view str = "Content-Length: 1023\r\n";
     auto span = hal::as_bytes(str);
-    hal::stream::find finder(hal::as_bytes(": "sv));
+    hal::stream_find finder(hal::as_bytes(": "sv));
 
     // Exercise
     auto remaining = span | finder;
@@ -286,7 +286,7 @@ void find_stream_test()
 
   "[find] empty span"_test = []() {
     // Setup
-    hal::stream::find finder(hal::as_bytes(": "sv));
+    hal::stream_find finder(hal::as_bytes(": "sv));
 
     // Exercise
     auto remaining = std::span<hal::byte>() | finder;
@@ -301,7 +301,7 @@ void find_stream_test()
     std::string_view digits_in_between = "abcd??efghx-[--]/";
     auto digits_span = hal::as_bytes(digits_in_between);
 
-    hal::stream::find finder(hal::as_bytes("????"sv));
+    hal::stream_find finder(hal::as_bytes("????"sv));
 
     // Exercise
     auto remaining = digits_span | finder;
@@ -316,7 +316,7 @@ void find_stream_test()
     auto span0 = hal::as_bytes(halves[0]);
     auto span1 = hal::as_bytes(halves[1]);
 
-    hal::stream::find finder(hal::as_bytes("1298"sv));
+    hal::stream_find finder(hal::as_bytes("1298"sv));
 
     auto remaining0 = span0 | finder;
     auto remaining1 = span1 | finder;
@@ -336,7 +336,7 @@ void find_stream_test()
     auto span1 = hal::as_bytes(halves[1]);
     auto span2 = hal::as_bytes(halves[2]);
 
-    hal::stream::find finder(hal::as_bytes("345"sv));
+    hal::stream_find finder(hal::as_bytes("345"sv));
 
     auto remaining0 = span0 | finder;
     auto remaining1 = span1 | finder;
@@ -357,9 +357,9 @@ void find_stream_test()
     std::string_view three_numbers = "----a---b---c";
     auto span = hal::as_bytes(three_numbers);
 
-    hal::stream::find finder0(hal::as_bytes("a"sv));
-    hal::stream::find finder1(hal::as_bytes("b"sv));
-    hal::stream::find finder2(hal::as_bytes("c"sv));
+    hal::stream_find finder0(hal::as_bytes("a"sv));
+    hal::stream_find finder1(hal::as_bytes("b"sv));
+    hal::stream_find finder2(hal::as_bytes("c"sv));
 
     // Exercise
     auto remaining = span | finder0 | finder1 | finder2;
@@ -391,7 +391,7 @@ void fill_upto_stream_test()
     std::array<hal::byte, 128> buffer;
     auto target_string = "#_$"sv;
     auto target = hal::as_bytes(target_string);
-    hal::stream::fill_upto filler(target, buffer);
+    hal::stream_fill_upto filler(target, buffer);
 
     // Exercise
     auto remaining = span | filler;
@@ -424,7 +424,7 @@ void fill_upto_stream_test()
     std::array span{ hal::as_bytes(str[0]), hal::as_bytes(str[1]) };
 
     std::array<hal::byte, 128> buffer;
-    hal::stream::fill_upto filler(hal::as_bytes("#_$"sv), buffer);
+    hal::stream_fill_upto filler(hal::as_bytes("#_$"sv), buffer);
 
     // Exercise
     auto remaining0 = span[0] | filler;
@@ -475,10 +475,10 @@ void multi_stream_test()
     std::array<hal::byte, 1024> response_buffer;
     response_buffer.fill('.');
 
-    hal::stream::find find_content_length(hal::as_bytes("Content-Length: "sv));
-    hal::stream::parse<std::uint32_t> parse_body_length;
-    hal::stream::fill_upto find_end_of_header(hal::as_bytes("\r\n\r\n"sv),
-                                              response_buffer);
+    hal::stream_find find_content_length(hal::as_bytes("Content-Length: "sv));
+    hal::stream_parse<std::uint32_t> parse_body_length;
+    hal::stream_fill_upto find_end_of_header(hal::as_bytes("\r\n\r\n"sv),
+                                             response_buffer);
 
     [[maybe_unused]] auto start_of_body =
       input_data | find_content_length | parse_body_length;
@@ -487,7 +487,7 @@ void multi_stream_test()
 
     /*
     if (hal::terminated(find_end_of_header.state())) {
-      hal::stream::fill fill_buffer(find_end_of_header.unfilled(),
+      hal::stream_fill fill_buffer(find_end_of_header.unfilled(),
                                     parse_body_length.value());
       remaining = remaining | fill_buffer;
     }