Possible confusion about interfaces

[igor-elovikov]

While the documentation emphasizes that interfaces are more similar to Rust traits and Swift protocols, there are some caveats to keep in mind:

import playground;

// This is illegal usage, that compiles, but crashes compiler on instantiation
struct Printer {
    IFloat value;

    void print() {
        printf("%f\n", value.toFloat());
    }
}

// Correct one
struct CorrectPrinter<T: IFloat> {
    T value;

    void print() {
        printf("%f\n", value.toFloat());
    }
}

void printMain()
{
    // Works only if two lines below commented
    let printer = Printer(42.0);
    printer.print();

    let correct_printer = CorrectPrinter<float>(42.0);
    correct_printer.print();

    // Below works but is it supposed to?
    IFloat v = 42.0;
    printf("%f\n", v.toFloat());
}

Playground Link

It makes sense that IFloat is not a type, but this behavior is very unclear. Currently, the compiler not only fails to provide an error message, but it can also hard crash in cases like Printer. This can be especially confusing for an experienced C# programmer who might find the usage of Printer very natural. Adding to the confusion is the fact that interfaces can be used to declare variables.

[jkwak-work]

I think the playground needs some improvement on how to handle the error cases. When I compiled locally with slangc.exe, I get an error message as following,

core(569): error 50100: No type conformances are found for interface '__BuiltinFloatingPointType'. Code generation for current target requires at least one implementation type present in the linkage.

I don't think the document describes the different explicitly but here is how I understood.
When you use an interface as a type, it will have to find the members at runtime through the dynamic dispatching.
With generic, the type is known at compile time and the dynamic dispatching will not happen.
It is because the syntax with generic requires a type to conform to an interface at the compile time.

I tried to make an example but the compiler optimization step removes all my tricks to make the difference obvious.
I hope the following example shows my intention.

void PrintWithInterface(IFloat v)
{
    // Uses dynamic dispatch to find `toFloat` at runtime
    printf("%f\n", v.toFloat());
}

void PrintWithGeneric<T : IFloat>(T v)
{
    // No dynamic dispatch, because the type `T` is known at compile-time
    printf("%f\n", v.toFloat());
}

[igor-elovikov]

Sorry, I was assuming that dynamic dispatch is not supported, but it turns out that's not the case. Basically, I thought that using interfaces as struct fields was ill-formed, and the compiler simply didn't catch it.

Actually, we discussed this on Discord, and the error above is about something else. When slang introduces an explicit dynamic keyword, there will be much less confusion.

[cheneym2]

Hi Igor, is your question is answered? If so, would you mind hitting "Close discussion"? Thanks!