[Feature Request] Implement intersection types

[affo]

I could not find this on the roadmap, so I proceeded to creare an idea as suggested.

Probably related to the issue about union types: #43.

Hello, these days I tried out Mojo and I liked it a lot.
However, when I started writing some sort of "hello world" program, I found myself into trouble when implementing a function to print the elements of a DynamicVector. E.g.:

fn printv[T: CollectionItem](borrowed v: DynamicVector[T]) -> None:
    let l = len(v)
    for i in range(len(v)):
        print_no_newline(v[i])

Clearly, print_no_newline(v[i]) fails at compile time as v[i] is not Stringable.

The perfection for me would have been something like this:

alias StringableCollectionElement = CollectionElement & Stringable

fn printv[T: StringableCollectionElement](borrowed v: DynamicVector[T]) -> None:
    let l = len(v)
    for i in range(len(v)):
        print_no_newline(v[i])

Very similar to what happens already in typescript.

Here I add all the code I needed to achieve the final result:

trait StringableCollectionElement(CollectionElement, Stringable):
    ...
    # fn __moveinit__(inout self, owned existing: Self): ...
    # fn __copyinit__(inout self, existing: Self): ...
    # fn __str__(self) -> String: ...

fn printv[T: StringableCollectionElement](borrowed v: DynamicVector[T]) -> None:
    let l = len(v)
    for i in range(l):
        if i == 0:
            print_no_newline("[")
        print_no_newline(v[i])
        if i < l - 1:
            print_no_newline(", ")
        else:
            print("]")

@value
struct MyInt(StringableCollectionElement):
    var wrapped: Int

    fn __str__(self) -> String:
        return str(self.wrapped)

    fn value(self) -> Int:
        return self.wrapped

fn main():
    var li = DynamicVector[MyInt]()
    li.append(MyInt(1))
    li.append(MyInt(2))
    printv[MyInt](li)

Also note that I had to wrap Int to achieve the result, quite inconvenient.
I think this would be already covered by a part of your roadmap: Support for a feature like Swift’s extensions, allowing you to add a trait to a preexisting type. If this is available, I could have implemented Stringable for Int without MyInt, still the intersection type would have been needed.

If I may ask also, why like Swift's extensions and not as it happens in Rust? Do you think that those are equivalent?

[Eprahim-taha]

What I referred to is actually present in the road map, see ⏬⬇️

https://docs.modular.com/mojo/roadmap.html#traits-support

We plan to expand traits support in future releases. Planned features include:

More traits built in to the standard library, and expanded use of traits throughout the standard library.

Support for default implementations of required methods.

Support for a feature like Swift’s extensions, allowing you to add a trait to a preexisting type.

[Eprahim-taha]

It is not just speculation. It seems that you did not read the roadmap well. The references in Mojo are still in their early stages and need further development. Chris Latner also said that Mojo 🔥 will be open source in the first quarter of the year. for traits Still under discussion and design, the Mojo development team is focusing on these features at the present time due to their importance in systems programming

[nmsmith]

I agree that you're definitely referring to features listed in the roadmap. However, you made a few claims about what might be in the 0.8 release, which is certainly speculation, because the release hasn't happened yet, and Modular hasn't stated what will be included.

I just wanted to clarify this to the OP because I wanted to make sure he wasn't misled as to what is coming in the 0.8 release.

[Eprahim-taha]

These things are indicated by the Mojo development team 🔥 at discord They also mentioned that there were references in version 0.7 before its release. Make sure you keep a good eye on Mojo discord

[affo]

@nmsmith thanks for your precise answer.

Not misled at all, not taking the statements as "contracts" at all :)

We'll see once next release is out 👍

[Eprahim-taha]

You are a wise man 👌

[nmsmith]

why like Swift's extensions and not as it happens in Rust? Do you think that those are equivalent?

Swift's extension blocks are more general than Rust impl blocks, because they allow you to add regular methods to an external data type, not just a trait implementation. This can be really convenient.

[Eprahim-taha]

I'm talking according to the roadmap

[affo]

@nmsmith yeah, seems quite a nice feature, I remind something like that in Ruby as well.
Problem in Ruby is that you could override default behaviors as well (I remember being able overriding the + operator for integers and breaking everything :)).

Thanks you for your clarification.