• Subject: Re: High-level vs low-level overrides / Multi-level overrides
• From: "Soni L." <fakedme@...>
• Date: Mon, 1 Aug 2016 18:24:55 -0300

```

On 01/08/16 04:48 PM, Nagaev Boris wrote:
```
```On Mon, Aug 1, 2016 at 8:50 PM, Soni L. <fakedme@gmail.com> wrote:
```
```Lua 5.2 introduced __ipairs. It's a high-level ipairs() override, as it
overrides ipairs() itself.

It overrides the primitive (low-level) operations used by ipairs(), instead
of ipairs() itself.

Why can't we have both? I.e. try __ipairs first, if that fails use __index,
etc.

We could also get a __next metamethod and a rawnext() function. pairs()
would then first try __pairs, then try __next.

--
Disclaimer: these emails may be made public at any given time, with or
without reason. If you don't agree with this, DO NOT REPLY.

```
```What is the motivation behind this proposal? I think the whole idea is
not ideal. It adds to complexity of the language.
```
```
stdlib.

```
```
PS. Given Lua had __pairs, ipairs (and __ipairs) would be unneeded. To
get current ipairs, one would set __pairs to current ipairs and invoke
pairs.

```
```
Yeah we don't need ipairs we could just do

local i = 1
local v = t[i]
while v ~= nil do
i = i + 1
v = t[i]
end

or

local function ipairs_aux(t, i)
i = i + 1
local v = t[i]
if v then return i, v end
return nil
end

function ipairs(t)
return ipairs_aux, t, 1
end

```
However, we do have ipairs, so it'd be nice to have multi-level overrides where it makes sense.
```
__next and __index is consistent.
__pairs and __ipairs is consistent.
__pairs and __index is not consistent.

Having the former 2 gives us the best of both worlds.

--
Disclaimer: these emails may be made public at any given time, with or without reason. If you don't agree with this, DO NOT REPLY.

```

• Follow-Ups:
• References: