Need clarification on Table constraint type & Table constructor

[mohanvive]

I am expecting some clarification on the below statement regarding the Table.

"If there is no contextually expected type, then the member type of the inherent type is derived from the static type of the expressions for the members: the member type will be the smallest record type that is a supertype of the static types of all the expressions in the expr-list.
"

var tab = table [{ id: 13 , name: "Sanjiva", lname: "Weerawarana" },
                            { id: 23 , name: "James" },
                            { id: 133 , name: "Mohan", lname: "JJ" , address: "Colombo"} ];

1. If we consider the above example what would be the member type. Whether below one is correct?

record {| 
    int id; 
    string name; 
    string lname?; 
    string address?; 
|}

Another question is, as per the spec table constraint type should be a subtype of map<any|error>. Then, it is possible to have a table as given below.

type CustomerTable table<map<any>>;
CustomerTable customerTable = table [{ id: 13 , name: "Sanjiva", lname: "Weerawarana" },
              { id: 23 , name: "James" , lname: "Clark" }];

But, in the spec when we talk about key specifiers and key constraint it is somewhat bound to record fields (i.e, record type).

2. Is that meant, if the constraint type is other than record (for example, map) then it is always a keyless table?

[jclark]

There are three expressions for the members:

{ id: 13 , name: "Sanjiva", lname: "Weerawarana" }, // 1
 { id: 23 , name: "James" }, //2
 { id: 133 , name: "Mohan", lname: "JJ" , address: "Colombo"} //3

The static types of those expressions are determined as specified by the mapping constructor section of the spec:

record {| int id; string name; string lname; |} // 1
record {| int id; string name;  |} // 2
record {| int id; string name; string lname; string address; |} // 3

You get the smallest record type by unioning the types of the members, and making the fields that are not always present be optional, giving

record {| int id; string name; string lname?; string address?; |}

as you correctly deduced.

As for your question 2, if a table has an inherent type that is table<map<T>> key(S), then S must be empty. However, if a table belongs to type table<map<T>>, it means just that all we know about the table is that its rows belong to map<T>.

[mohanvive]

Thanks James for the prompt reply..

[mohanvive]

@jclark , there is a followup question on this. I appreciate, your input on this.
Let's take the below example,

var tabObj = table key(id) [];

As per the current grammar, the above syntax is possible. Then what is the member of the table?
Whether below is correct?

record {| int id; |}

or do you have any other suggestions?

[jclark]

I would either make this a compile-time error, or infer a type of

record {  // NB: open
  (anydata & readonly) id;
};

since there is no information that indicates a more restrictive type than this.

[jclark]

The spec should say something about this.

[mohanvive]

I have mixed opinions on both options.
If we consider the option #2, then for below example

var tabObj = table [];

member type needs to be something like below,

record {  // NB: open

};

Providing a compile error might be a simple and good solution. Then, we could simply mention that mapping constructor exprs are a must to infer the member type.

[jclark]

I am fine with a compile error. If it turns out to be a problem, we can always relax the constraint.

[pcnfernando]

As for your question 2, if a table has an inherent type that is table<map<T>> key(S), then S must be empty. However, if a table belongs to type table<map<T>>, it means just that all we know about the table is that its rows belong to map<T>.

Should the spec say something about this?

[jclark]

@pcnfernando If there's something that's still not clear in the spec after 65074f9, please open a new issue with an example that the spec is not clear about and link to this issue.