Stack

stack = []                    # indices still waiting
for i, x in enumerate(a):
    while stack and a[stack[-1]] < x:
        j = stack.pop()           # x settles j
        answer[j] = i             # first larger value after j
    stack.append(i)               # i waits for its own answer

std::vector<int> stack;            // indices still waiting
for (int i = 0; i < (int)a.size(); ++i) {
    while (!stack.empty() && a[stack.back()] < a[i]) {
        answer[stack.back()] = i;       // first larger value after it
        stack.pop_back();
    }
    stack.push_back(i);
}

int[] stack = new int[a.length];         // indices; top is stack[top - 1]
int top = 0;
for (int i = 0; i < a.length; i++) {
    while (top > 0 && a[stack[top - 1]] < a[i])
        answer[stack[--top]] = i;       // first larger value after it
    stack[top++] = i;
}

const stack = [];                  // indices still waiting
for (let i = 0; i < a.length; i++) {
  while (stack.length && a[stack[stack.length - 1]] < a[i]) {
    const j = stack.pop();
    answer[j] = i;                     // first larger value after j
  }
  stack.push(i);
}

let mut stack: Vec<usize> = Vec::new();   // indices still waiting
for i in 0..a.len() {
    while let Some(&j) = stack.last() {
        if a[j] >= a[i] { break; }
        answer[j] = i;                  // first larger value after j
        stack.pop();
    }
    stack.push(i);
}

-- The stack is a list, top at the head. x pops what it beats.
step (stack, settled) (i, x) =
  let (beaten, rest) = span (\j -> arr ! j < x) stack
  in (i : rest, [(j, i) | j <- beaten] ++ settled)