[stlib] String conversion of list literals and lists with representable items

docs/changelog.md

@@ -16,6 +16,21 @@ what we publish.
 
 ### ⭐️ New
 
+- List literals with variadic items and lists with representable items are now
+ convertible and representables as strings. This improves the ergonomics of
+ the language, becoming more familiar to Python developers.
+
+ ```mojo
+ l = [1, False, "Mojo is awesome 🔥"]
+ print(l)
+ # [1, False, 'Mojo is awesome 🔥']
+ l = List(1, 2, 3)
+ print(str(l))
+ # [1, 2, 3]
+ ```
+
+ ([PR #3521](https://github.com/modularml/mojo/pull/3521) by [@msaelices](https://github.com/msaelices))
+
 - Mojo can now interpret simple LLVM intrinsics in parameter expressions,
  enabling things like `count_leading_zeros` to work at compile time:
  [Issue #933](https://github.com/modularml/mojo/issues/933).

stdlib/src/builtin/builtin_list.mojo

@@ -16,15 +16,20 @@ These are Mojo built-ins, so you don't need to import them.
 """
 
 from memory import Reference, UnsafePointer
+from python import PythonObject
 
 from sys.intrinsics import _type_is_eq
 
+from collections import Dict
+
 # ===----------------------------------------------------------------------===#
 # ListLiteral
 # ===----------------------------------------------------------------------===#
 
 
-struct ListLiteral[*Ts: CollectionElement](Sized, CollectionElement):
+struct ListLiteral[*Ts: CollectionElement](
+ Sized, CollectionElement, Formattable, Representable, Stringable
+):
  """The type of a literal heterogeneous list expression.
 
  A list consists of zero or more values, separated by commas.
@@ -80,6 +85,74 @@ struct ListLiteral[*Ts: CollectionElement](Sized, CollectionElement):
  """
  return len(self.storage)
 
+ fn __str__(self) -> String:
+ """Returns a string representation of a ListLiteral.
+
+ Returns:
+ The string representation of the ListLiteral.
+
+ Here is an example below:
+ ```mojo
+ var my_list = [1, 2, "Mojo"]
+ print(str(my_list))
+ ```.
+ """
+ var output = String()
+ var writer = output._unsafe_to_formatter()
+ self.format_to(writer)
+ return output^
+
+ fn __repr__(self) -> String:
+ """Returns a string representation of a ListLiteral.
+
+ Returns:
+ The string representation of the ListLiteral.
+
+ Here is an example below:
+ ```mojo
+ var my_list = [1, 2, "Mojo"]
+ print(repr(my_list))
+ ```.
+ """
+ return self.__str__()
+
+ @no_inline
+ fn format_to(self, inout writer: Formatter):
+ """Format the list literal.
+
+ Args:
+ writer: The formatter to use.
+ """
+ writer.write("[")
+
+ @parameter
+ for i in range(len(VariadicList(Ts))):
+ alias T = Ts[i]
+ var s: String
+ if i > 0:
+ writer.write(", ")
+
+ @parameter
+ if _type_is_eq[T, PythonObject]():
+ s = str(rebind[PythonObject](self.storage[i]))
+ elif _type_is_eq[T, Int]():
+ s = repr(rebind[Int](self.storage[i]))
+ elif _type_is_eq[T, Float64]():
+ s = repr(rebind[Float64](self.storage[i]))
+ elif _type_is_eq[T, Bool]():
+ s = repr(rebind[Bool](self.storage[i]))
+ elif _type_is_eq[T, String]():
+ s = repr(rebind[String](self.storage[i]))
+ elif _type_is_eq[T, StringLiteral]():
+ s = repr(rebind[StringLiteral](self.storage[i]))
+ else:
+ s = String("unknown")
+ constrained[
+ False, "cannot convert list literal element to string"
+ ]()
+ writer.write(s)
+ writer.write("]")
+
  # ===-------------------------------------------------------------------===#
  # Methods
  # ===-------------------------------------------------------------------===#

stdlib/src/builtin/str.mojo

@@ -176,3 +176,19 @@ fn str[T: StringableRaising](value: T) raises -> String:
  If there is an error when computing the string representation of the type.
  """
  return value.__str__()
+
+
+@no_inline
+fn str[T: RepresentableCollectionElement](value: List[T]) -> String:
+ """Get the string representation of a list of representable items.
+
+ Parameters:
+ T: The type conforming to RepresentableCollectionElement.
+
+ Args:
+ value: The list to get the string representation of.
+
+ Returns:
+ The string representation of the list.
+ """
+ return value.__str__()

stdlib/test/builtin/test_list_literal.mojo

@@ -66,7 +66,17 @@ def test_contains():
  assert_true("Mojo" not in h and String("Mojo") in h)
 
 
+def test_repr_and_str():
+ var l = [1, 2, 3]
+ assert_equal(str(l), "[1, 2, 3]")
+ assert_equal(repr(l), "[1, 2, 3]")
+ var l2 = [1, False, String("Mojo"), "is awesome 🔥"]
+ assert_equal(str(l2), "[1, False, 'Mojo', 'is awesome 🔥']")
+ assert_equal(repr(l2), "[1, False, 'Mojo', 'is awesome 🔥']")
+
+
 def main():
+ test_contains()
  test_list()
+ test_repr_and_str()
  test_variadic_list()
- test_contains()

stdlib/test/builtin/test_str.mojo

@@ -16,7 +16,10 @@ from testing import assert_equal
 
 
 def test_str_none():
- assert_equal(str(None), "None")
+ # TODO(#3393): Change to str(None) when MLIR types do not confuse overload resolution.
+ # The error we are receiving with str(None) is:
+ # cannot bind MLIR type 'None' to trait 'RepresentableCollectionElement'
+ assert_equal(str(NoneType()), "None")
 
 
 def main():