[Feature Request] [stdlib] [proposal] Migrate/wrap String.join() methods into StringLiteral and add temp dict and list iter args

[martinvuyk]

Review Mojo's priorities

• I have read the roadmap and priorities and I believe this request falls within the priorities.

What is your request?

I would like to take this temporary implementation into StringLiteral (currently only the fn join[*Types: Stringable](self, *elems: *Types) -> String implementation is in String)

trait _StringableCollectableKey(StringableCollectionElement, KeyElement):
    ...


struct StringLiteral:
    ...
    fn join[*Types: Stringable](self, *elems: *Types) -> String:
        """Joins string elements using the current string as a delimiter.

        Parameters:
            Types: The types of the elements.

        Args:
            elems: The input values.

        Returns:
            The joined string.
        """
        var result = String("")

        @parameter
        fn add_elt[T: Stringable](a: T):
            result += self + str(a)

        elems.each[add_elt]()
        return result[len(self) :]

    fn join[T: StringableCollectionElement](self, elems: List[T]) -> String:
        """Joins string elements using the current string as a delimiter.

        Parameters:
            T: The Stringable type of the List.

        Args:
            elems: The input values.

        Returns:
            The joined string.
        """
        var result = String("")
        for elem in elems:
            result += self + elem[]
        return result[len(self) :] if len(result) > 0 else ""

    fn join[
        T: _StringableCollectableKey, A: CollectionElement, keys: Bool
    ](self, elems: Dict[T, A]) -> String:
        """Joins string elements using the current string as a delimiter.

        Parameters:
            T: The Stringable type of the Dict Keys.
            A: The type of the Values.
            keys: A temporary placeholder to differentiate between key
                and value iter.

        Args:
            elems: The input values.

        Returns:
            The joined string.
        """
        var result = String("")
        for elem in elems.keys():
            result += self + elem[]
        return result[len(self) :] if len(result) > 0 else ""

    fn join[
        T: KeyElement, A: StringableCollectionElement
    ](self, elems: Dict[T, A]) -> String:
        """Joins string elements using the current string as a delimiter.

        Parameters:
            T: The Stringable type of the Dict Keys.
            A: The type of the Values.

        Args:
            elems: The input values.

        Returns:
            The joined string.
        """
        var result = String("")
        for elem in elems.values():
            result += self + elem[]
        return result[len(self) :] if len(result) > 0 else ""

And later on when we have a generic Iterable trait as per isse #2629

trait _IterStringable:
    fn __iter__[T: StringableCollectionElement](self) -> Iterator[T]:
        ...

struct StringLiteral:
    ...

    fn join[T: _IterStringable](self, elems: T) -> String:
        """Joins string elements using the current string as a delimiter.

        Parameters:
            T: The Stringable type of the Iterator.

        Args:
            elems: The input values.

        Returns:
            The joined string.
        """
        var result = String("")
        for elem in elems:
            if not elem:
                break
            result += self + elem.value()
        return result[len(self) :] if len(result) > 0 else ""

What is your motivation for this change?

Being able to do ", ".join(List("hello", "world")) dynamically

Any other details?

No response