does carbon support type erasure for Comparable?

[fililili]

hi, all. I found Swift supports such usage for type erasure. It's interesting for me and I am looking for other language that supports same usage. So, Is such usage supported by carbon, too? thanks.

func selfc<T: Comparable>(_ a: T) -> Bool {
    print(a)
    return a < a;
}

/* cannot compile
func selfca(_ a: any Comparable) -> Bool {
    return a < a;
}
*/

struct Person: Comparable {
    var name: String
    var age: Int
    
    static func < (lhs: Person, rhs: Person) -> Bool {
        return lhs.age < rhs.age
    }
}
let person1 = Person(name: "Alice", age: 30)
let person2 = Person(name: "Bob", age: 25)

var cs : [any Comparable] = [person1, person2, 1, 2.4]
for c in cs {
    print(selfc(c))
}

[danakj]

Yes, what you're describing is what Carbon calls checked generics. See https://github.com/carbon-language/carbon-lang/tree/trunk/docs/design/generics for the design.

[fililili]

hi, @danakj . In the Swift code, it creates a list of Comparable objects from different types var cs : [any Comparable] = [person1, person2, 1, 2.4]. But I have read the page https://github.com/carbon-language/carbon-lang/blob/trunk/docs/design/generics/overview.md and search for "type erasure", it doesn't show such usage.

[danakj]

Thanks, I think what you're looking for then is variadics with checked generics which is not finished but is mentioned here with some links: https://github.com/carbon-language/carbon-lang/blob/trunk/docs/design/generics/details.md#variadic-arguments

Edit: If not, then maybe you're looking for a container, which would use checked generics as its type. That should follow from the original link, it may just not be called "type erasure" directly. But a checked generic can be used as a type for a container.

[geoffromer]

A checked generic type can be used as the element type of an array, but that still requires all elements of the array to have the same runtime type, just like with C++ templates. Variadics will let you form a tuple whose elements have different runtime types that all implement some interface, and then iterate over them using that interface, but it's still a tuple, not an array. For example, you can't index into it with a runtime subscript.

If I understand the Swift example correctly, var cs : [any Comparable] = [person1, person2, 1, 2.4] is doing something different from either of those: it's forming an array, not a tuple, and its elements have different runtime types. The Carbon generics design refers to that kind of feature as "dynamic types", and it's currently marked as future work.