Clarify about future types used in wait expressions

[SasinduDilshara]

Description:

According to the current Ballerina specification under the Wait action topic,

A wait-future-expr is used by a wait-action to refer to the worker to be waited for. Its static type must be future<T> for some T. As elsewhere, a wait-future-expr can use an in-scope worker-name in a variable-reference-expr to refer to named worker.

So according to that future<T> will use as static type of wait-future-expr.
But in Ballerina future<T> | future<U> can be simplifies as future <T|U>. So according to that we can use future<T> | future<U> as the static type of wait-future-expr ryt?. So both future<T> and union of future<T> members can used as static type of wait-future-expr.

So Isn't it better if we update the spec saying,

A wait-future-expr is used by a wait-action to refer to the worker to be waited for. Its static type must be sub type of future<T> for some T. As elsewhere, a wait-future-expr can use an in-scope worker-name in a variable-reference-expr to refer to named worker.

[jclark]

future<T> | future<U> is not equivalent to future<T|U> just as (function() returns T)|(function() returns U) is not equivalent to function() returns (T|U).

If you still wish to propose a change to the spec, please reopen.

[SasinduDilshara]

Yes. It is not equivalent. my mistake. But I think it is a subtype.
So don't we need to change the spec like

A wait-future-expr is used by a wait-action to refer to the worker to be waited for. Its static type must be sub type of future<T> for some T. As elsewhere, a wait-future-expr can use an in-scope worker-name in a variable-reference-expr to refer to named worker.

[jclark]

Can you please explain why the spec is in need of improvement here?

[SasinduDilshara]

Can you please explain why the spec is in need of improvement here?

if it is changed like that we can allow following code sample also.

type WaitResult record {|
    boolean|error producer;
|};

function fn() {
    worker Producer1 returns boolean|error {
        return true;
    }

    worker Producer2 returns boolean|error {
        return true;
    }

    future<boolean|error>|future<boolean|error> x = Producer1;
    WaitResult r2 = wait {producer: x};
}

According to the spec Currently it should be a compile time error because the type needs to be future<T>.

[jclark]

But why do you want to do that? It's not a useful example.

Are there useful examples that cannot be handled with #1171?

[SasinduDilshara]

#1171

Useful examples can be handle.
I understand and agree with your opinion.
Hence, close this issue.