Add case-when expression support

Author: mgomes

ROADMAP.md

@@ -212,7 +212,7 @@ Goal: improve language ergonomics for complex script logic and recovery behavior
 - [x] Add `while` loops.
 - [x] Add `until` loops.
 - [x] Add loop control keywords: `break` and `next`.
-- [ ] Add `case/when` expression support (if approved).
+- [x] Add `case/when` expression support (if approved).
 - [x] Define behavior for nested loop control and block boundaries.
 
 ### Error Handling Constructs

docs/control-flow.md

@@ -3,6 +3,7 @@
 VibeScript supports these control-flow forms:
 
 - `if` / `elsif` / `else`
+- `case` / `when` expressions
 - `for` loops over arrays and ranges
 - `while` and `until` loops
 - loop control with `break` and `next`
@@ -20,6 +21,23 @@ def sum_first_five()
 end
 ```
 
+## `case` / `when` expressions
+
+`case` evaluates to the matching branch expression (or `nil` when no branch matches and no `else` is provided).
+
+```vibe
+def label(score)
+  case score
+  when 100
+    "perfect"
+  when 90, 95
+    "great"
+  else
+    "ok"
+  end
+end
+```
+
 ## `while` and `until`
 
 ```vibe

examples/control_flow/case_when.vibe

@@ -0,0 +1,14 @@
+def label(score)
+  case score
+  when 100
+    "perfect"
+  when 90, 95
+    "great"
+  else
+    "ok"
+  end
+end
+
+def run()
+  [label(100), label(95), label(70)]
+end

vibes/ast.go

@@ -308,6 +308,21 @@ type RangeExpr struct {
 func (e *RangeExpr) exprNode()     {}
 func (e *RangeExpr) Pos() Position { return e.position }
 
+type CaseWhenClause struct {
+	Values []Expression
+	Result Expression
+}
+
+type CaseExpr struct {
+	Target   Expression
+	Clauses  []CaseWhenClause
+	ElseExpr Expression
+	position Position
+}
+
+func (e *CaseExpr) exprNode()     {}
+func (e *CaseExpr) Pos() Position { return e.position }
+
 type BlockLiteral struct {
 	Params   []Param
 	Body     []Statement

vibes/execution.go

@@ -555,6 +555,8 @@ func (exec *Execution) evalExpressionWithAuto(expr Expression, env *Env, autoCal
 		return exec.evalBinaryExpr(e, env)
 	case *RangeExpr:
 		return exec.evalRangeExpr(e, env)
+	case *CaseExpr:
+		return exec.evalCaseExpr(e, env)
 	case *MemberExpr:
 		obj, err := exec.evalExpressionWithAuto(e.Object, env, true)
 		if err != nil {
@@ -1102,6 +1104,57 @@ func (exec *Execution) evalRangeExpr(expr *RangeExpr, env *Env) (Value, error) {
 	return NewRange(Range{Start: start, End: end}), nil
 }
 
+func (exec *Execution) evalCaseExpr(expr *CaseExpr, env *Env) (Value, error) {
+	target, err := exec.evalExpression(expr.Target, env)
+	if err != nil {
+		return NewNil(), err
+	}
+	if err := exec.checkMemoryWith(target); err != nil {
+		return NewNil(), err
+	}
+
+	for _, clause := range expr.Clauses {
+		matched := false
+		for _, candidateExpr := range clause.Values {
+			candidate, err := exec.evalExpression(candidateExpr, env)
+			if err != nil {
+				return NewNil(), err
+			}
+			if err := exec.checkMemoryWith(candidate); err != nil {
+				return NewNil(), err
+			}
+			if target.Equal(candidate) {
+				matched = true
+				break
+			}
+		}
+		if !matched {
+			continue
+		}
+		result, err := exec.evalExpressionWithAuto(clause.Result, env, true)
+		if err != nil {
+			return NewNil(), err
+		}
+		if err := exec.checkMemoryWith(result); err != nil {
+			return NewNil(), err
+		}
+		return result, nil
+	}
+
+	if expr.ElseExpr != nil {
+		result, err := exec.evalExpressionWithAuto(expr.ElseExpr, env, true)
+		if err != nil {
+			return NewNil(), err
+		}
+		if err := exec.checkMemoryWith(result); err != nil {
+			return NewNil(), err
+		}
+		return result, nil
+	}
+
+	return NewNil(), nil
+}
+
 func (exec *Execution) evalForStatement(stmt *ForStmt, env *Env) (Value, bool, error) {
 	exec.loopDepth++
 	defer func() {

vibes/lexer.go

@@ -427,6 +427,10 @@ func lookupIdent(ident string) TokenType {
 		return tokenIn
 	case "if":
 		return tokenIf
+	case "case":
+		return tokenCase
+	case "when":
+		return tokenWhen
 	case "elsif":
 		return tokenElsif
 	case "else":

vibes/parser.go

@@ -66,6 +66,7 @@ func newParser(input string) *parser {
 	p.registerPrefix(tokenBang, p.parsePrefixExpression)
 	p.registerPrefix(tokenMinus, p.parsePrefixExpression)
 	p.registerPrefix(tokenYield, p.parseYieldExpression)
+	p.registerPrefix(tokenCase, p.parseCaseExpression)
 
 	p.infixFns[tokenPlus] = p.parseInfixExpression
 	p.infixFns[tokenMinus] = p.parseInfixExpression
@@ -659,6 +660,66 @@ func (p *parser) parseYieldExpression() Expression {
 	return &YieldExpr{Args: args, position: pos}
 }
 
+func (p *parser) parseCaseExpression() Expression {
+	pos := p.curToken.Pos
+	p.nextToken()
+	target := p.parseExpression(lowestPrec)
+	if target == nil {
+		return nil
+	}
+
+	p.nextToken()
+	clauses := []CaseWhenClause{}
+	for p.curToken.Type == tokenWhen {
+		p.nextToken()
+		values := []Expression{}
+		first := p.parseExpression(lowestPrec)
+		if first == nil {
+			return nil
+		}
+		values = append(values, first)
+		for p.peekToken.Type == tokenComma {
+			p.nextToken()
+			p.nextToken()
+			value := p.parseExpression(lowestPrec)
+			if value == nil {
+				return nil
+			}
+			values = append(values, value)
+		}
+
+		p.nextToken()
+		result := p.parseExpressionWithBlock()
+		if result == nil {
+			return nil
+		}
+		clauses = append(clauses, CaseWhenClause{Values: values, Result: result})
+		p.nextToken()
+	}
+
+	if len(clauses) == 0 {
+		p.errorExpected(p.curToken, "when")
+		return nil
+	}
+
+	var elseExpr Expression
+	if p.curToken.Type == tokenElse {
+		p.nextToken()
+		elseExpr = p.parseExpressionWithBlock()
+		if elseExpr == nil {
+			return nil
+		}
+		p.nextToken()
+	}
+
+	if p.curToken.Type != tokenEnd {
+		p.errorExpected(p.curToken, "end")
+		return nil
+	}
+
+	return &CaseExpr{Target: target, Clauses: clauses, ElseExpr: elseExpr, position: pos}
+}
+
 func (p *parser) parseGroupedExpression() Expression {
 	p.nextToken()
 	expr := p.parseExpression(lowestPrec)

vibes/runtime_test.go

@@ -862,6 +862,80 @@ func TestUntilLoops(t *testing.T) {
 	}
 }
 
+func TestCaseWhenExpressions(t *testing.T) {
+	script := compileScript(t, `
+    def label(score)
+      case score
+      when 100
+        "perfect"
+      when 90, 95
+        "great"
+      else
+        "ok"
+      end
+    end
+
+    def classify(value)
+      case value
+      when nil
+        "missing"
+      when true
+        "yes"
+      else
+        "other"
+      end
+    end
+
+    def assign_case(v)
+      result = case v
+      when 1
+        10
+      else
+        20
+      end
+      result
+    end
+
+    def unmatched(v)
+      case v
+      when 1
+        "one"
+      end
+    end
+    `)
+
+	if got := callFunc(t, script, "label", []Value{NewInt(100)}); !got.Equal(NewString("perfect")) {
+		t.Fatalf("label(100) mismatch: %v", got)
+	}
+	if got := callFunc(t, script, "label", []Value{NewInt(95)}); !got.Equal(NewString("great")) {
+		t.Fatalf("label(95) mismatch: %v", got)
+	}
+	if got := callFunc(t, script, "label", []Value{NewInt(70)}); !got.Equal(NewString("ok")) {
+		t.Fatalf("label(70) mismatch: %v", got)
+	}
+
+	if got := callFunc(t, script, "classify", []Value{NewNil()}); !got.Equal(NewString("missing")) {
+		t.Fatalf("classify(nil) mismatch: %v", got)
+	}
+	if got := callFunc(t, script, "classify", []Value{NewBool(true)}); !got.Equal(NewString("yes")) {
+		t.Fatalf("classify(true) mismatch: %v", got)
+	}
+	if got := callFunc(t, script, "classify", []Value{NewInt(1)}); !got.Equal(NewString("other")) {
+		t.Fatalf("classify(1) mismatch: %v", got)
+	}
+
+	if got := callFunc(t, script, "assign_case", []Value{NewInt(1)}); !got.Equal(NewInt(10)) {
+		t.Fatalf("assign_case(1) mismatch: %v", got)
+	}
+	if got := callFunc(t, script, "assign_case", []Value{NewInt(2)}); !got.Equal(NewInt(20)) {
+		t.Fatalf("assign_case(2) mismatch: %v", got)
+	}
+
+	if got := callFunc(t, script, "unmatched", []Value{NewInt(7)}); !got.Equal(NewNil()) {
+		t.Fatalf("unmatched(7) expected nil, got %v", got)
+	}
+}
+
 func TestLoopControlBreakAndNext(t *testing.T) {
 	script := compileScript(t, `
     def for_break()

vibes/token.go

@@ -62,6 +62,8 @@ const (
 	tokenNext     TokenType = "NEXT"
 	tokenIn       TokenType = "IN"
 	tokenIf       TokenType = "IF"
+	tokenCase     TokenType = "CASE"
+	tokenWhen     TokenType = "WHEN"
 	tokenElsif    TokenType = "ELSIF"
 	tokenElse     TokenType = "ELSE"
 	tokenTrue     TokenType = "TRUE"