Implement Iteration for Bytes (#6953)

## Description
Adds an iterator to allow for loops over bytes

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [x] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [x] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [x] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

---------

Co-authored-by: Cameron Carstens <bitzoic.eth@gmail.com>

Author: SwayStar123

sway-lib-std/src/bytes.sw

@@ -7,6 +7,7 @@ use ::intrinsics::size_of_val;
 use ::option::Option::{self, *};
 use ::convert::{From, Into, *};
 use ::clone::Clone;
+use ::iterator::*;
 
 struct RawBytes {
     ptr: raw_ptr,
@@ -871,6 +872,86 @@ impl Bytes {
 
         self.len = new_len;
     }
+
+    /// Returns an [Iterator] to iterate over this `Bytes`.
+    ///
+    /// # Returns
+    ///
+    /// * [BytesIter] - The struct which can be iterated over.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let mut bytes = Bytes::new();
+    ///     bytes.push(5_u8);
+    ///     bytes.push(10_u8);
+    ///     bytes.push(15_u8);
+    ///
+    ///     // Get the iterator
+    ///     let iter = bytes.iter();
+    ///
+    ///     assert_eq(5_u8, iter.next().unwrap());
+    ///     assert_eq(10_u8, iter.next().unwrap());
+    ///     assert_eq(15_u8, iter.next().unwrap());
+    ///
+    ///     for elem in bytes.iter() {
+    ///         log(elem);
+    ///     }
+    /// }
+    ///
+    /// # Undefined Behavior
+    ///
+    /// Modifying vector during iteration is a logical error and
+    /// results in undefined behavior. E.g.:
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let mut bytes = Bytes::new();
+    ///     bytes.push(5_u8);
+    ///     bytes.push(10_u8);
+    ///     bytes.push(15_u8);
+    ///
+    ///     for elem in bytes.iter() {
+    ///         bytes.push(20_u8); // Modification causes undefined behavior.
+    ///     }
+    /// }
+    /// ```
+    pub fn iter(self) -> BytesIter {
+        // WARNING: Be aware of caveats of this implementation
+        //          if you take it as an example for implementing
+        //          `Iterator` for other types.
+        //
+        //          Due to the Sway's copy semantics, the `values` will
+        //          actually contain **a copy of the original bytes
+        //          `self`**. This is contrary to the iterator semantics
+        //          which should iterate over the collection itself.
+        //
+        //          Strictly speaking, we should take a reference to
+        //          `self` here, but references as for now an experimental
+        //          feature.
+        //
+        //          However, this issue of copying gets compensated by
+        //          another issue, which is the broken copy semantics
+        //          for heap types like `Bytes`. Essentially, the original
+        //          `self` and it's copy `values` will both point to
+        //          the same elements on the heap, which gives us the
+        //          desired behavior for the iterator.
+        //
+        //          This fact makes the implementation of `next` very
+        //          misleading in the part where the bytes length is
+        //          checked (see comment in the `next` implementation
+        //          below).
+        //
+        //          Once we fix and formalize the copying of heap types
+        //          this implementation will be changed, but for
+        //          the time being, it is the most pragmatic one we can
+        //          have now.
+        BytesIter {
+            values: self,
+            index: 0,
+        }
+    }
 }
 
 #[cfg(experimental_partial_eq = false)]
@@ -1091,3 +1172,33 @@ impl AbiDecode for Bytes {
         raw_slice::abi_decode(buffer).into()
     }
 }
+
+pub struct BytesIter {
+    values: Bytes,
+    index: u64,
+}
+
+impl Iterator for BytesIter {
+    type Item = u8;
+    fn next(ref mut self) -> Option<Self::Item> {
+        // BEWARE: `self.values` keeps **the copy** of the `Bytes`
+        //         we iterate over. The below check checks against
+        //         the length of that copy, taken when the iterator
+        //         was created, and not the original vector.
+        //
+        //         If the original vector gets modified during the iteration
+        //         (e.g., elements are removed), this modification will not
+        //         be reflected in `self.values.len()`.
+        //
+        //         But since modifying the vector during iteration is
+        //         considered undefined behavior, this implementation,
+        //         that always checks against the length at the time
+        //         the iterator got created is perfectly valid.
+        if self.index >= self.values.len() {
+            return None
+        }
+
+        self.index += 1;
+        self.values.get(self.index - 1)
+    }
+}

test/src/in_language_tests/test_programs/bytes_inline_tests/src/iter.sw

@@ -0,0 +1,55 @@
+library;
+
+use std::bytes::Bytes;
+
+#[test]
+fn bytes_iter() {
+    let mut bytes: Bytes = Bytes::new();
+
+    let number0 = 0;
+    let number1 = 1;
+    let number2 = 2;
+    let number3 = 3;
+    let number4 = 4;
+
+    bytes.push(number0);
+    bytes.push(number1);
+    bytes.push(number2);
+    bytes.push(number3);
+    bytes.push(number4);
+
+    let mut iter = bytes.iter();
+
+    assert(iter.next() == Some(number0));
+    assert(iter.next() == Some(number1));
+    assert(iter.next() == Some(number2));
+    assert(iter.next() == Some(number3));
+    assert(iter.next() == Some(number4));
+    assert(iter.next() == None);
+    assert(iter.next() == None);
+}
+
+#[test]
+fn bytes_for_loop() {
+    let mut bytes: Bytes = Bytes::new();
+
+    let number0 = 0;
+    let number1 = 1;
+    let number2 = 2;
+    let number3 = 3;
+    let number4 = 4;
+
+    bytes.push(number0);
+    bytes.push(number1);
+    bytes.push(number2);
+    bytes.push(number3);
+    bytes.push(number4);
+
+    let arr = [number0, number1, number2, number3, number4];
+
+    let mut i = 0;
+    for elem in bytes.iter() {
+        assert(elem == arr[i]);
+        i += 1;
+    }
+}

test/src/in_language_tests/test_programs/bytes_inline_tests/src/main.sw

@@ -2,6 +2,7 @@ library;
 
 pub mod utils;
 pub mod splice;
+pub mod iter;
 
 use utils::setup;
 use std::bytes::Bytes;