Optional field access with union type

[KavinduZoysa]

Description:

import ballerina/io;

type Foo record {
    int i;
};

type Bar record {
    string s;
};

public function main() {
    Foo f = {i:23};

    Foo|Bar fb = f;
    io:println(fb?.s);
}

Currently the type of expression fb.s is determined as string. Shouldn't that be anydata?

[jclark]

It's an interesting example.

The type should clearly be anydata|string which is the same as anydata.

But this example makes me think that we shouldn't allow E?.x when the static type of E is a union, unless x is an individual field in all branches of the union.

Where the spec now says:

(if the type descriptor is a union, then this requirement must be satisfied by at least one member of the union)

I am thinking it ought instead to say:

(if the type descriptor is a union, then this requirement must be satisfied by all members of the union)

@hasithaa @sameerajayasoma Any thoughts?

[sanjiva]

Doesn't that kind of defeat the purpose of union for optional fields?

[MaryamZi]

Now that we have never, what if the requirement is something along the lines of

(if the type descriptor is a union, then this requirement must be satisfied by at least one member of the union, and the rest of the members can never have a field-name field)

So, optional field access will still work for

type Foo record {
    int i;
};

type Bar record {|
    string s;
|};

public function main() {
    Foo|Bar fb = {i: 23};
    int? i = fb?.i;
}

and

type Foo record {
    int i;
};

type Bar record {
    string s;
    never i?;
};

public function main() {
    Foo|Bar fb = {i: 23};
    int? i = fb?.i;
}

But in other scenarios, such as the following, you'll have to use member-access?

type Foo record {
    int i;
};

type Bar record {
    string s;
};

public function main() {
    Foo|Bar fb = {i: 23};
    anydata i = fb["i"];
}

type Foo record {
    int i;
};

type Bar record {|
    string s;
    int...;
|};

public function main() {
    Foo|Bar fb = {i: 23};
    int? i = fb["i"]; // Will be `int?`.
}

[jclark]

There are four possibilities for each branch of the union for an expression E.s

1. required individual field e.g. record { string s; }
2. optional individual field e.g. record { string s?; }
3. not allowed as a field e.g. record {| int x; |}
4. allowed as a non-individual mapping member e.g. map<string> or record { int x; }

In the case above, we have one branch is case 1 and one branch is case 4: that seems to me really weird, not useful and most likely to be an error.

Above, I suggested that they requirement should be that all branches are case 1 or case 2. But I think that's too restrictive, since it would disallow a combination of case 3 with case 1 or 2.

So a better restriction (this is for the non-lax case):

• at least one branch has case 1 or 2 (which is the current restriction), and
• no branch has case 4

With this restriction, if E?.s is allowed, then there are two runtime possibilities:

• there is no field s, in which case the the result with be ()
• there is an field s and it corresponds to an individually declared field

Note that we don't allow E.s when E has static type of case 4.