[stdlib] Implement Int.from_bytes() and Int.as_bytes()

docs/changelog.md

@@ -16,6 +16,10 @@ what we publish.
 
 ### ⭐️ New
 
+- New `Int.from_bytes()` and `Int.as_bytes()` functions to convert a list of
+  bytes to an integer and vice versa, accepting the endianess as an argument.
+  Similar to Python `int.from_bytes()` and `int.to_bytes()` functions.
+
 - `StringRef` is now representable so `repr(StringRef("hello"))` will return
   `StringRef('hello')`.
 

stdlib/src/builtin/int.mojo

@@ -16,6 +16,8 @@ These are Mojo built-ins, so you don't need to import them.
 """
 
 from collections import KeyElement
+
+from bit import byte_swap
 from collections.string import (
     _calc_initial_buffer_size_int32,
     _calc_initial_buffer_size_int64,
@@ -29,8 +31,11 @@ from builtin.io import _snprintf
 from memory import UnsafePointer
 from python import Python, PythonObject
 from python._cpython import Py_ssize_t
+from memory import memcpy, UnsafePointer
+
+from sys import is_big_endian, bitwidthof
 
-from utils import Writable, Writer
+from utils import Span, Writable, Writer
 from utils._select import _select_register_value as select
 from utils._visualizers import lldb_formatter_wrapping_type
 
@@ -1212,6 +1217,65 @@ struct Int(
 
         writer.write(self)
 
+    @staticmethod
+    fn from_bytes[
+        D: DType, big_endian: Bool = False
+    ](bytes: Span[Byte]) raises -> Self:
+        """Converts a byte array to an integer.
+
+        Args:
+            bytes: The byte array to convert.
+
+        Parameters:
+            D: The type of the integer.
+            big_endian: Whether the byte array is big-endian.
+
+        Returns:
+            The integer value.
+        """
+        if D.sizeof() != len(bytes):
+            raise Error("Byte array size does not match the integer size.")
+
+        var ptr: UnsafePointer[Scalar[D]] = bytes.unsafe_ptr().bitcast[
+            Scalar[D]
+        ]()
+        var value = ptr[]
+
+        @parameter
+        if is_big_endian() and not big_endian:
+            value = byte_swap(value)
+        elif not is_big_endian() and big_endian:
+            value = byte_swap(value)
+        return int(value)
+
+    fn as_bytes[D: DType, big_endian: Bool = False](self) -> List[Byte]:
+        """Convert the integer to a byte array.
+
+        Parameters:
+            D: The type of the integer.
+            big_endian: Whether the byte array should be big-endian.
+
+        Returns:
+            The byte array.
+        """
+        alias type_len = D.sizeof()
+        var value = Scalar[D](self)
+
+        @parameter
+        if is_big_endian() and not big_endian:
+            value = byte_swap(value)
+        elif not is_big_endian() and big_endian:
+            value = byte_swap(value)
+
+        var ptr = UnsafePointer.address_of(value)
+        var list = List[Byte](capacity=type_len)
+
+        # TODO: Maybe this can be a List.extend(ptr, count) method
+        memcpy(list.unsafe_ptr(), ptr.bitcast[Byte](), type_len)
+        list.size = type_len
+
+        return list^
+
     @always_inline("nodebug")
     fn __mlir_index__(self) -> __mlir_type.index:
         """Convert to index.

stdlib/test/builtin/test_int.mojo

@@ -245,6 +245,58 @@ def test_conversion_from_python():
     assert_equal(Int.try_from_python(PythonObject(-1)), -1)
 
 
+def test_from_bytes_as_bytes():
+    alias Bytes = List[Byte]
+
+    assert_equal(Int.from_bytes[DType.int16, big_endian=True](Bytes(0, 16)), 16)
+    assert_equal(
+        Int.from_bytes[DType.int16, big_endian=False](Bytes(0, 16)), 4096
+    )
+    assert_equal(
+        Int.from_bytes[DType.int16, big_endian=True](Bytes(252, 0)), -1024
+    )
+    assert_equal(
+        Int.from_bytes[DType.uint16, big_endian=True](Bytes(252, 0)), 64512
+    )
+    assert_equal(
+        Int.from_bytes[DType.int16, big_endian=False](Bytes(252, 0)), 252
+    )
+    assert_equal(
+        Int.from_bytes[DType.int32, big_endian=True](Bytes(0, 0, 0, 1)), 1
+    )
+    assert_equal(
+        Int.from_bytes[DType.int32, big_endian=False](Bytes(0, 0, 0, 1)),
+        16777216,
+    )
+    assert_equal(
+        Int.from_bytes[DType.int32, big_endian=True](Bytes(1, 0, 0, 0)),
+        16777216,
+    )
+    assert_equal(
+        Int.from_bytes[DType.int32, big_endian=True](Bytes(1, 0, 0, 1)),
+        16777217,
+    )
+    assert_equal(
+        Int.from_bytes[DType.int32, big_endian=False](Bytes(1, 0, 0, 1)),
+        16777217,
+    )
+    assert_equal(
+        Int.from_bytes[DType.int32, big_endian=True](Bytes(255, 0, 0, 0)),
+        -16777216,
+    )
+    for x_ref in List[Int](10, 100, -12, 0, 1, -1, 1000, -1000):
+        x = x_ref[]
+
+        @parameter
+        for b in range(2):
+            assert_equal(
+                Int.from_bytes[DType.int16, big_endian=b](
+                    Int(x).as_bytes[DType.int16, big_endian=b]()
+                ),
+                x,
+            )
+
+
 def main():
     test_properties()
     test_add()
@@ -268,3 +320,4 @@ def main():
     test_int_uint()
     test_float_conversion()
     test_conversion_from_python()
+    test_from_bytes_as_bytes()