This is a really poorly done question on your part -- You haven't described what you're doing or exactly what you have in mind.

I'm going to assume you have an elevator, and either an "up", "down", and "stop" button, and a "call to this floor" button (maybe a few of these).

That means the elevator has a few states: moving up, moving down, or stopped.

Based on the last button that was pressed, it has a particular state (or we could get more complicated).

At this point, there are two approaches. Since the important state changes are when you press buttons, it might actually be best to not have some constant loop and just do work when the buttons are pressed. This gets a little complicated, but I'll outline it first, because it sometimes looks nice.

The other option is for something to constantly be looking at the elevator's state and make sure it is appropriate based on the last button pressed. I'll do this second.

Events

I'm going to use a "hypothetical" elevator where the only thing I do is set a variable velocity -- 1 for up, -1 for down, 0 for stopped.

function stopButton()
    velocity = 0
end

function upButton()
    velocity = 1
end

function downButton()
    velocity = -1
end

This is remarkably simple -- no loops required.

Now, let's consider a "call" button. For this, we need to know where the elevator is. We'll use y to mean the elevator's position (but we won't set y, only read from it). I'll use ty as the "target y" (the y of the given floor) in this event:

function callTo(ty)
    if ty == y then
        -- You would actually want a small
        -- tolerance, since it probably won't ever be exact
        velocity = 0
    elseif ty < y then
        velocity = -1
    else
        velocity = 1
    end
end

This will make the elevator go towards the floor, but it won't stop when it gets there.

An idiomatic way would be to use a while loop (though a repeat until would be equivalent)

function callTo(ty)
    while ty ~= y do
        -- again, a tolerance would be better
        if ty < y then
            velocity = -1
        else
            velocity = 1
        end
        wait() -- Some pause, to not freeze
    end
    velocity = 0
end

This will work -- but it will only work with 1 call at a time.

One simple solution is the debounce pattern - we essentially "disable" calling as long as it is still going to its floor:

canCall = true

function callTo(ty)
    if not canCall then
        return
    end
    canCall = false -- No one *else* can call
    while ty ~= y do
        --.....
    end
    velocity  = 0
    canCall = true -- Now someone else can call
end

This may be what we want, but it may not. We may want to interrupt the current action whenever we press a button (this would be more sensical to most users, though probably isn't what a real elevator would do)

To do that, we will keep track of something like a reverse debounce, where any other call will inform all previous ones to stop operating.

controller = nil -- which call is controlling the elevator?

function callTo(ty)
    local myControl = math.random()
    -- Or, equivalently, = {}, which I like for succinctness
    controller = myControl
    while controller == myControl and ty ~= y do
        -- .... (same body)
    end
    velocity = 0
end

Now, whenever callTo gets called, it changes controller, but it doesn't change myControl -- so controller == myControl becomes false and the old call stops working.

Single, Constant Loop

The final design that we have is essentially just one loop -- it just gets traded off between different calls to the function with a different ty variable.

With that in mind, we can make a much simpler system:

target = 0 -- ground floor?

function callTo(ty)
    target = ty -- Store most recent call to target
end

while true do
    wait()
    if y == target then
        velocity = 0
    elseif y < target then
        velocity = -1
    else
        velocity = 1
    end
end

This is all we need. If we wanted to put some sort of "debounce", we could do that, too:

target = 0

function callTo(ty)
    target = ty
end

local realTarget = 0
while true do
    wait()
    if y == realTarget then
        velocity = 0
    elseif y < realTarget then
        velocity - 1
    else
        velocity = 1
    end
    if velocity == 0 then
        -- I'm at my floor, so now I can go to the next one
        -- (Maybe also a `wait(1)` in here to stay at the
        -- floor for a least a moment?)
        realTarget = target
        -- Accept the most recent button press.
    end
end

One interesting difference between this and the debounce above is that this will still hear when you press. It just waits until it's done, and then does it. (You could, with the above system, do this by instead repeat wait() until canCall, but this would be a problem if multiple buttons were pressed in that time -- since they might all start more or less at the same time but don't check the debounce -- or, worse, make a big stack of different locations to track to -- so the elevator would be "frozen" in an odd path for however many times people pressed buttons)

Real-er elevator?

I would like to think that real elevators aren't so dumb. I will write more about this shortly.

Here is what I would suggest a real elevator does:

Keeps a list of all floors that need to be visited. A floor needs to be visited because either it was called to that floor, or because that floor was indicated while inside the elevator. I am not going to make any distinction about priority between the two types of calls, though you could if you wanted to.

Whenever a floor that needs to be visited is passed, stop and open the doors -- then continue on.

Here is what it might look like:

-- finds `val` in table `tab`, returning position found
-- warning: false is a valid key.
-- Returns `nil` when not found.
function find(tab, val)
    for i,v in pairs(tab) do
        if v == val then
            return i
        end
    end
end

local visits = {} -- Floors to visit
-- Guaranteed to not contain repeats of any value

function callTo(ty)
    if not find(visits, ty) then
        -- If the list doesn't already contain this target,
        -- then add it.
        table.insert(visits, ty)
    end
end


local target = y -- Ground floor?

while true do
    wait()
    if find(visits, y) then
        -- I'm on a floor that's wanted!
        -- (Thus the elevator will stop on its way rather than
        -- go all the way up then back down to floors in
        -- the middle)

        open = true -- Open doors
        wait(1)
        open = false -- Close doors

        table.remove(visits, find(visits, y))
        -- remove this floor from the list to visit
    end
    if y == target then
        if #visits > 0 then
            target = table.remove(1) -- Attend to oldest first.
        else
            -- No floors to visit. Stop and wait
            velocity = 0
        end
    end
end