1 files changed, 0 insertions, 212 deletions
diff --git a/js/scripting-lang/tutorials/05_When_Expressions_Pattern_Matching.md b/js/scripting-lang/tutorials/05_When_Expressions_Pattern_Matching.md
deleted file mode 100644
index a13f773..0000000
--- a/js/scripting-lang/tutorials/05_When_Expressions_Pattern_Matching.md
+++ /dev/null
@@ -1,212 +0,0 @@
-# `when` Expressions (Pattern Matching)
-
-## What are `when` Expressions?
-
-`when` expressions provide pattern matching functionality, allowing you to match values against patterns and execute different code based on the match.
-
-```plaintext
-/* Pattern matching with when expressions */
-result : when x is
-  0 then "zero"
-  1 then "one"
-  _ then "other";
-```
-
-## Why is This Esoteric?
-
-Pattern matching is common in functional languages but rare in imperative/OOP languages. The `when` syntax with `then` clauses and `_` wildcards is unique to our language.
-
-## Basic Examples
-
-```plaintext
-/* Simple pattern matching */
-x : 5;
-result : when x is
-  0 then "zero"
-  1 then "one"
-  2 then "two"
-  _ then "other";
-/* Result: "other" */
-
-/* Pattern matching with numbers */
-grade : 85;
-letter_grade : when grade is
-  90 then "A"
-  80 then "B"
-  70 then "C"
-  60 then "D"
-  _ then "F";
-/* Result: "B" */
-```
-
-## Pattern Types
-
-### Literal Patterns
-```plaintext
-/* Match exact values */
-result : when value is
-  true then "yes"
-  false then "no"
-  _ then "maybe";
-```
-
-### Wildcard Pattern
-```plaintext
-/* _ matches anything */
-result : when x is
-  0 then "zero"
-  _ then "not zero";
-```
-
-### Function Reference Patterns
-```plaintext
-/* Match function references */
-double : x -> x * 2;
-square : x -> x * x;
-
-result : when function is
-  @double then "doubling function"
-  @square then "squaring function"
-  _ then "other function";
-```
-
-### Boolean Patterns
-```plaintext
-/* Match boolean values */
-result : when condition is
-  true then "condition is true"
-  false then "condition is false";
-```
-
-## Complex Examples
-
-```plaintext
-/* Grade classification with ranges */
-score : 85;
-grade : when score is
-  when score >= 90 then "A"
-  when score >= 80 then "B"
-  when score >= 70 then "C"
-  when score >= 60 then "D"
-  _ then "F";
-/* Result: "B" */
-
-/* Multiple conditions */
-x : 5;
-y : 10;
-result : when x is
-  when x = y then "equal"
-  when x > y then "x is greater"
-  when x < y then "x is less"
-  _ then "impossible";
-/* Result: "x is less" */
-```
-
-## Nested `when` Expressions
-
-You can nest `when` expressions for complex logic:
-
-```plaintext
-/* Nested pattern matching */
-x : 5;
-y : 10;
-result : when x is
-  0 then when y is
-    0 then "both zero"
-    _ then "x is zero"
-  1 then when y is
-    1 then "both one"
-    _ then "x is one"
-  _ then when y is
-    0 then "y is zero"
-    1 then "y is one"
-    _ then "neither special";
-/* Result: "neither special" */
-```
-
-## Using `when` with Functions
-
-```plaintext
-/* Function that uses pattern matching */
-classify_number : x -> when x is
-  0 then "zero"
-  when x % 2 = 0 then "even"
-  when x % 2 = 1 then "odd"
-  _ then "unknown";
-
-/* Use the function */
-result1 : classify_number 0;   /* "zero" */
-result2 : classify_number 4;   /* "even" */
-result3 : classify_number 7;   /* "odd" */
-```
-
-## Common Patterns
-
-```plaintext
-/* Pattern 1: Value classification */
-classify_age : age -> when age is
-  when age < 13 then "child"
-  when age < 20 then "teenager"
-  when age < 65 then "adult"
-  _ then "senior";
-
-/* Pattern 2: Error handling */
-safe_divide : x y -> when y is
-  0 then "error: division by zero"
-  _ then x / y;
-
-/* Pattern 3: Status mapping */
-status_code : 404;
-status_message : when status_code is
-  200 then "OK"
-  404 then "Not Found"
-  500 then "Internal Server Error"
-  _ then "Unknown Error";
-```
-
-## When to Use `when` Expressions
-
-**Use `when` expressions when:**
-- You need to match values against multiple patterns
-- You want to replace complex if/else chains
-- You're working with enumerated values
-- You need to handle different cases based on value types
-- You want to make conditional logic more readable
-
-**Don't use `when` expressions when:**
-- You only have a simple true/false condition (use logical operators)
-- You need to perform side effects (use regular expressions)
-- You're working with complex nested conditions (consider breaking into functions)
-
-## Comparison with Traditional Conditionals
-
-```plaintext
-/* Traditional if/else approach (not available in our language) */
-/* if x = 0 then "zero" else if x = 1 then "one" else "other" */
-
-/* Our when expression approach */
-result : when x is
-  0 then "zero"
-  1 then "one"
-  _ then "other";
-```
-
-## Key Takeaways
-
-1. **Pattern matching** - match values against specific patterns
-2. **Wildcard support** - `_` matches anything
-3. **Exhaustive matching** - all cases must be covered
-4. **Nested support** - can nest `when` expressions
-5. **Functional style** - expressions return values
-
-## Why This Matters
-
-`when` expressions make conditional logic more functional and readable:
-
-- **Pattern-based thinking** - focus on what values match, not how to test them
-- **Exhaustive coverage** - ensures all cases are handled
-- **Functional style** - expressions return values rather than performing actions
-- **Readable syntax** - clear separation between patterns and results
-- **Composable** - can be used in function composition
-
-This feature makes the language feel more like functional programming languages like Haskell or ML! 🚀 
\ No newline at end of file