1 files changed, 240 insertions, 0 deletions
diff --git a/js/baba-yaga/scratch/baba/crash-course-code.baba b/js/baba-yaga/scratch/baba/crash-course-code.baba
new file mode 100644
index 0000000..bae2810
--- /dev/null
+++ b/js/baba-yaga/scratch/baba/crash-course-code.baba
@@ -0,0 +1,240 @@
+// Baba Yaga in Y Minutes
+
+// Test 1: Basic with examples
+testBasicWith : x y ->
+  with (inc : x + 1; prod : inc * y;) -> inc + prod;
+
+testTypedWith : x y ->
+  with (nx Int; ny Int; nx : x + 1; ny : y + 1;) -> nx + ny;
+
+// Test 2: with rec examples
+testEvenOdd : z ->
+  with rec (
+    isEven : n -> when n is 0 then true _ then isOdd (n - 1);
+    isOdd : n -> when n is 0 then false _ then isEven (n - 1);
+  ) -> {even: isEven z, odd: isOdd z};
+
+// Test 3: Computed intermediate values
+testQuadraticRoots : a b c ->
+  with (
+    discriminant : b * b - 4 * a * c;
+    sqrtDisc : math.sqrt discriminant;
+    denominator : 2 * a;
+  ) ->
+    {
+      r1: (-b + sqrtDisc) / denominator,
+      r2: (-b - sqrtDisc) / denominator
+    };
+
+// Test 4: Complex calculations with named steps
+testCalculateTax : income deductions ->
+  with (
+    taxableIncome : income - deductions;
+    taxRate : when (taxableIncome <= 50000) is
+      true then 0.15
+      _ then when (taxableIncome <= 100000) is
+        true then 0.25
+        _ then 0.35;
+    baseTax : taxableIncome * taxRate;
+    finalTax : when (baseTax < 1000) is true then 1000 _ then baseTax;
+  ) ->
+    finalTax;
+
+// Test 5: Data transformation pipelines
+testProcessUserData : user ->
+  with (
+    normalizedName : str.upper (str.trim user.name);
+    ageGroup : when (user.age < 18) is
+      true then "minor"
+         _ then when (user.age < 65) is
+                true then "adult"
+                   _ then "senior";
+     status : when user.active is
+        true then "active"
+           _ then "inactive";
+  ) ->
+    {
+      id: user.id,
+      displayName: normalizedName,
+      category: ageGroup,
+      status: status
+    };
+
+// Test 6: Error handling with multiple validations
+testValidateOrder : order ->
+  with (
+    hasItems : (length order.items) > 0;
+    hasValidTotal : order.total > 0;
+    allValid : hasItems and hasValidTotal;
+  ) ->
+    when allValid is
+      true then Ok order
+      _    then Err "Order validation failed";
+
+// Test 7: Complex pattern matching with computed values
+testClassifyTriangle : a b c ->
+  with (
+    sorted : [math.min a b, math.max a b, math.max (math.max a b) c];
+    side1 : sorted.0;
+    side2 : sorted.1;
+    side3 : sorted.2;
+    isValid : ((side1 + side2) > side3);
+    isEquilateral : ((a = b) and (b = c));
+    isIsosceles : ((a = b) or (b = c) or (a = c));
+    isRight : (math.abs ((side1 * side1 + side2 * side2) - (side3 * side3))) < 0.001;
+  ) ->
+    when isValid is
+      false then "Invalid triangle"
+      _     then when isEquilateral is
+                 true then "Equilateral"
+                    _ then when isIsosceles is
+                           true then when isRight is
+                                     true then "Right isosceles"
+                                        _ then "Isosceles"
+                                        _ then when isRight is
+                                               true then "Right scalene"
+                                                  _ then "Scalene";
+
+// Test 8: Tree operations with with rec
+testTreeOperations : tree ->
+  with rec (
+    // Count total nodes
+    countNodes : t ->
+      when ((length (keys t)) = 0) is
+        true then 0
+        _ then 1 + (countNodes t.left) + (countNodes t.right);
+    
+    // Calculate tree height
+    treeHeight : t ->
+      when ((length (keys t)) = 0) is
+        true then 0
+        _ then 1 + (math.max (treeHeight t.left) (treeHeight t.right));
+    
+    // Check if tree is balanced
+    isBalanced : t ->
+      when ((length (keys t)) = 0) is
+        true then true
+        _ then 
+          (((math.abs ((treeHeight t.left) - (treeHeight t.right))) <= 1) and
+          (isBalanced t.left) and
+          (isBalanced t.right));
+  ) ->
+    {
+      nodeCount: countNodes tree,
+      height: treeHeight tree,
+      balanced: isBalanced tree
+    };
+
+// Test 9: State machine with recursive state transitions
+testTrafficLight : initialState ->
+  with rec (
+    // State transition function
+    nextState : current ->
+      when current is
+        "red" then "green"
+        "green" then "yellow"
+        _ then "red";
+    
+    // Count transitions until back to start
+    countCycles : start current count ->
+      when (current = start) is
+        true then count
+        _ then countCycles start (nextState current) (count + 1);
+    
+    // Get state after N transitions
+    stateAfter : current n ->
+      when n is
+        0 then current
+        _ then stateAfter (nextState current) (n - 1);
+  ) ->
+    {
+      cycles: countCycles initialState initialState 0,
+      after10: stateAfter initialState 10,
+      next: nextState initialState
+    };
+
+// Test 10: Combinatorial functions with shared helpers
+testCombinatorics : n r ->
+  with rec (
+    // Factorial function
+    factorial : k ->
+      when k is
+        0 then 1
+        1 then 1
+        _ then k * (factorial (k - 1));
+    
+    // Permutation: P(n,r) = n! / (n-r)!
+    permutation : n r ->
+      (factorial n) / (factorial (n - r));
+    
+    // Combination: C(n,r) = n! / (r! * (n-r)!)
+    combination : n r ->
+      (factorial n) / ((factorial r) * (factorial (n - r)));
+  ) ->
+    {
+      n: n,
+      r: r,
+      permutations: permutation n r,
+      combinations: combination n r
+    };
+
+// Test 11: Best practices examples
+testProcessData : data ->
+  with (
+    cleaned : str.trim data;
+    normalized : str.lower cleaned;
+    validated : (length normalized) > 0;
+  ) ->
+    when validated is
+      true then Ok normalized
+      _ then Err "Empty data";
+
+// Test 12: Validation examples
+testValidateUserBasic : user ->
+  with (
+    nameValid : (length user.name) > 0;
+    emailValid : (str.length user.email) > 0;  // Simplified validation
+    ageValid : (user.age >= 0) and (user.age <= 150);
+  ) ->
+    (nameValid and emailValid and ageValid);
+
+testValidateUserContact : user ->
+  with (
+    phoneValid : (length user.phone) >= 10;
+  ) ->
+    phoneValid;
+
+testProcessUser : user ->
+  when ((testValidateUserBasic user) and (testValidateUserContact user)) is
+    true then Ok user
+    _ then Err "Validation failed";
+
+// Execute tests
+result1 : testBasicWith 2 5;
+result2 : testTypedWith 3 4;
+result3 : testEvenOdd 10;
+result4 : testQuadraticRoots 1 -5 6;
+result5 : testCalculateTax 75000 10000;
+result6 : testProcessUserData { id: 1, name: "  john doe  ", age: 25, active: true };
+result7 : testValidateOrder { items: [1, 2, 3], total: 100 };
+result8 : testClassifyTriangle 3 4 5;
+result9 : testTreeOperations { left: { left: {}, right: {} }, right: {} };
+result10 : testTrafficLight "red";
+result11 : testCombinatorics 5 2;
+result12 : testProcessData "  Hello World  ";
+result13 : testProcessUser { name: "John", email: "john@example.com", age: 30, phone: "1234567890" };
+
+// Output results
+io.out result1;
+io.out result2;
+io.out result3;
+io.out result4;
+io.out result5;
+io.out result6;
+io.out result7;
+io.out result8;
+io.out result9;
+io.out result10;
+io.out result11;
+io.out result12;
+io.out result13;