[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

@@ -17,6 +17,7 @@ These are Mojo built-ins, so you don't need to import them.
 
 from collections import KeyElement
 
+from bit import byte_swap
 from math import Ceilable, CeilDivable, Floorable, Truncable
 from hashlib.hash import _hash_simd
 from hashlib._hasher import _HashableWithHasher, _Hasher
@@ -27,12 +28,12 @@ from collections.string import (
 )
 from python import Python, PythonObject
 from python._cpython import Py_ssize_t
-from memory import UnsafePointer
+from memory import memcpy, UnsafePointer
 
-from utils import Writable, Writer
+from utils import Span, Writable, Writer
 from utils._visualizers import lldb_formatter_wrapping_type
 from utils._select import _select_register_value as select
-from sys import is_nvidia_gpu, bitwidthof
+from sys import is_big_endian, is_nvidia_gpu, bitwidthof
 
 # ===----------------------------------------------------------------------=== #
 #  Indexer
@@ -1194,6 +1195,64 @@ struct Int(
 
         writer.write(self)
 
+    @staticmethod
+    fn from_bytes[
+        type: 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:
+            type: The type of the integer.
+            big_endian: Whether the byte array is big-endian.
+
+        Returns:
+            The integer value.
+        """
+        if type.sizeof() != len(bytes):
+            raise Error("Byte array size does not match the integer size.")
+        var ptr: UnsafePointer[Byte] = UnsafePointer.address_of(bytes[0])
+        var type_ptr: UnsafePointer[Scalar[type]] = ptr.bitcast[Scalar[type]]()
+        var value = type_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[type: DType, big_endian: Bool = False](self) -> List[Byte]:
+        """Convert the integer to a byte array.
+
+        Parameters:
+            type: The type of the integer.
+            big_endian: Whether the byte array should be big-endian.
+
+        Returns:
+            The byte array.
+        """
+        alias type_len = type.sizeof()
+        var value = Scalar[type](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[Scalar[type]] = UnsafePointer.address_of(value)
+        var byte_ptr: UnsafePointer[Byte] = ptr.bitcast[Byte]()
+        var list = List[Byte](capacity=type_len)
+
+        # TODO: Maybe this can be a List.extend(ptr, count) method
+        memcpy(list.unsafe_ptr(), byte_ptr, 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

@@ -19,6 +19,8 @@ from testing import assert_equal, assert_true, assert_false, assert_raises
 from python import PythonObject
 from memory import UnsafePointer
 
+alias Bytes = List[Byte]
+
 
 def test_properties():
     assert_equal(Int.MAX, (1 << bitwidthof[DType.index]() - 1) - 1)
@@ -246,6 +248,56 @@ def test_conversion_from_python():
     assert_equal(Int.try_from_python(PythonObject(-1)), -1)
 
 
+def test_from_bytes():
+    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()
@@ -269,3 +321,4 @@ def main():
     test_int_uint()
     test_float_conversion()
     test_conversion_from_python()
+    test_from_bytes()