Balanced brackets

def is_balanced(s):
    need = {')': '(', ']': '[', '}': '{'}    # each closer -> the opener it must match
    stack = []
    for ch in s:
        if ch in need:
            if not stack or stack.pop() != need[ch]:
                return False       # nothing open, or the wrong thing open
        else:
            stack.append(ch)       # an opener waits for its partner
    return not stack               # anything left was never closed

#include <string>
#include <vector>

bool solve(const std::string& s) {
    std::vector<char> stack;
    for (char ch : s) {
        if (ch == '(' || ch == '[' || ch == '{') {
            stack.push_back(ch);            // an opener waits for its partner
            continue;
        }
        const char want = ch == ')' ? '(' : ch == ']' ? '[' : '{';
        if (stack.empty() || stack.back() != want) return false;
        stack.pop_back();
    }
    return stack.empty();                   // anything left was never closed
}

class Solution {
    public boolean isBalanced(String s) {
        char[] stack = new char[s.length()];
        int top = 0;
        for (char ch : s.toCharArray()) {
            if (ch == '(' || ch == '[' || ch == '{') {
                stack[top++] = ch;              // an opener waits for its partner
                continue;
            }
            char want = ch == ')' ? '(' : ch == ']' ? '[' : '{';
            if (top == 0 || stack[top - 1] != want) return false;
            top--;
        }
        return top == 0;                        // anything left was never closed
    }
}

function isBalanced(s) {
  const need = { ')': '(', ']': '[', '}': '{' };   // closer -> opener it must match
  const stack = [];
  for (const ch of s) {
    if (ch in need) {
      if (stack.length === 0 || stack.pop() !== need[ch]) return false;
    } else {
      stack.push(ch);            // an opener waits for its partner
    }
  }
  return stack.length === 0;     // anything left was never closed
}

fn solve(s: &str) -> bool {
    let mut stack: Vec<char> = Vec::new();
    for ch in s.chars() {
        let want = match ch {
            ')' => '(',
            ']' => '[',
            '}' => '{',
            _ => {
                stack.push(ch);             // an opener waits for its partner
                continue;
            }
        };
        if stack.pop() != Some(want) {
            return false;                   // nothing open, or the wrong thing open
        }
    }
    stack.is_empty()                        // anything left was never closed
}

-- The stack is a list with its top at the head.
solve :: String -> Bool
solve = go []
  where
    go stack []       = null stack             -- anything left was never closed
    go stack (c : cs)
      | c `elem` "([{" = go (c : stack) cs   -- an opener waits for its partner
      | otherwise      = case stack of
          (top : rest) | top == opener c -> go rest cs
          _                              -> False
    opener ')' = '('
    opener ']' = '['
    opener _   = '{'