Add support for generic table indexers

[mathf-x]

Add support for generic table indexers

[mathf-x]

That is another option. It would probably be much easier than introducing new syntax right? I now realize that the only situations where generic table indexers would be actually useful is when you have a generic __index metamethod

[AmaranthineCodices]

Could you tell us more about the problem you're trying to solve with this behavior? I'm trying to understand the desire for an indexer with this behavior.

[mathf-x]

It is useful for tables with an __index/__newindex metamethod that is generic. In my case, I am making an entity-component-system library and I'd like to implement an "entity reference", which is basically a proxy table for the actual components in an entity. I'd like to be able to write:

local componentInstance = reference[component]

and make Luau infer the type for the component instance based on the component in the index. This is done easily in a __index function with the following type: <T>(tbl: {any}, key: Component<T>) -> T, and it works, but when you actually try it...

type Example = typeof(setmetatable({}, {} :: {__index: <T>(tbl: {any}, key: Component<T>) ->T}))

local example = {} :: Example
local str = example[{} :: Component<string>] -- Sadly, this is not inferred as string

So my hope would be that this could solve this issue. I'd be able to simply write:

type Reference = {
    <T>[Component<T>]: T
} 

Right now, I'm forced to use setters and getters, which not only looks very ugly, but makes it impossible to write nonverbose code.

ref.Set(Health, ref.Get(Health) - 10)
-- vs
ref[Health] -= 10

[andyfriesen]

It seems like it would make much more sense for us to make the __index metamethod typecheck as expected.

[alexmccord]

This looks related to the RFC luau-lang/rfcs#19 which was closed, so I'm gonna close this out. It seems like both solution, __index and simply changing the API surface would solve your issue.