Pull Request: Add Switch Statement Utility

[Kode-Red]

Description

This PR introduces a new lib.switch utility function for Lua that provides a flexible, readable alternative to long if/elseif chains. The implementation supports value-based matching, lists of possible values, predicate functions, and a "default" fallback, with optional JavaScript-style fallthrough behavior.

Changes Made

• Added lib.switch(valueOrList, fallthrough, cases, ...) API:
  • Value-first signature for natural usage.
  • First parameter can be a single value or a list of values to test.
  • Arguments are always provided as variadic parameters (4th, 5th, 6th… positions).
• Implemented compile step with weak-key caching to minimize recomputation.
• Supported match types:
  • Single values (number, string, etc.).
  • Multi-value case matches ({2,4,6}).
  • Predicate functions (function(v) return v < 0 end).
  • "default" (fallback if no match found).
• Supported behaviors:
  • fallthrough = true: executes multiple cases sequentially until breakFn() is called.
  • fallthrough = false (default): executes only the first matching case.
  • Explicit breakFn() can halt fallthrough early.
• Returned the result of the executed action (last case result in fallthrough mode).

Testing

• Verified exact matches return correct result.
• Verified lists of possible values ({'foo','bar'}) resolve to the earliest matching case.
• Verified multi-value case matches ({2,4,6}) trigger correctly.
• Verified predicate functions work as expected.
• Verified "default" triggers when no matches exist.
• Verified fallthrough behavior matches JavaScript semantics.
• Verified variadic arguments (4th, 5th, etc.) are passed through correctly.
• Verified breakFn() stops fallthrough early.

Performance Impact

• Uses O(1) map lookups for single values and list entries.
• Predicate checks only run when no value/list match exists.
• Weak-key cache ensures compilation overhead happens once per cases table.
• Efficient loop structure with minimal allocations.

Example Usages

Example 1 – Basic Value Match

local cases = {
  { match = 2, action = function(_, n) return n .. " is two" end },
  { match = function(v) return v > 5 end, action = function(_, n) return n .. " is greater than 5" end },
  { match = "default", action = function(_, n) return n .. " didn't match anything else" end },
}
local result = lib.switch(2, false, cases, 2)
print(result) -- "2 is two"

Example 2 – Fallthrough with List of Values

local cases = {
  { match = "concat",    action = function(_, a, b) print(a .. b) end },
  { match = "nonconcat", action = function(_, a, b) print(a) end },
  { match = "default",   action = function() print("no match") end },
}

lib.switch({"concat", "nonconcat"}, true, cases, "Hello ", "World")
-- Output:
-- Hello World
-- Hello
-- no match

Additional Notes

• Initial implementation request for a structured switch-case utility in ox_lib.
• Recommended to use the variadic form (lib.switch(value, false, cases, ...)) in hot code paths.
• "default" case should be placed last for clarity.

EDIT: Updated to reflect recent changes. The first argument, if a table, is now treated as a list of values to match.
Arguments are no longer accepted inside that table and must always be passed as variadic parameters (4th, 5th, 6th…).

[Kode-Red]

Should also note, I have documentation ready if this is approved.

[Kr3mu]

That's a cool concept