diff --git a/examples/Examples.Any/Program.cs b/examples/Examples.Any/Program.cs
index b1c02dd..bbbf6c8 100644
--- a/examples/Examples.Any/Program.cs
+++ b/examples/Examples.Any/Program.cs
@@ -150,6 +150,71 @@
 Console.WriteLine($"tripleThird.TryAs<bool>(): success={t3Try}, value={t3Bool}");
 Console.WriteLine();
 
+// ============================================================================
+// INDEX PROPERTY
+// ============================================================================
+Console.WriteLine("--- Index Property ---");
+
+Any<string, int> anyStringIdx = Any<string, int>.First("hello");
+Any<string, int> anyIntIdx = Any<string, int>.Second(42);
+Console.WriteLine($"anyString.Index: {anyStringIdx.Index}");
+Console.WriteLine($"anyInt.Index: {anyIntIdx.Index}");
+Console.WriteLine();
+
+// ============================================================================
+// ANYACTIONSTATUS (FROM SWITCH RETURN VALUE)
+// ============================================================================
+Console.WriteLine("--- AnyActionStatus ---");
+
+Any<string, int> switchTarget = Any<string, int>.First("world");
+AnyActionStatus switchStatus = switchTarget.Switch(
+    first: v => Console.WriteLine($"  Switched first: {v}"),
+    second: v => Console.WriteLine($"  Switched second: {v}")
+);
+Console.WriteLine($"AnyActionStatus.Executed: {switchStatus == AnyActionStatus.Executed}");
+
+Any<string, int> emptyAny = default;
+AnyActionStatus emptyStatus = emptyAny.Switch(
+    first: v => Console.WriteLine($"  This won't run"),
+    second: v => Console.WriteLine($"  This won't run")
+);
+Console.WriteLine($"AnyActionStatus.NotExecuted: {emptyStatus == AnyActionStatus.NotExecuted}");
+Console.WriteLine();
+
+// ============================================================================
+// ANY<T0,T1,T2,T3> — FOUR-TYPE VARIANT (AnyT4)
+// ============================================================================
+Console.WriteLine("--- Any<T0,T1,T2,T3> (AnyT4) ---");
+
+Any<string, int, bool, Guid> quadThird = Any<string, int, bool, Guid>.Third(true);
+Console.WriteLine($"AnyT4.IsThird: {quadThird.IsThird}");
+Console.WriteLine($"AnyT4.IsFourth: {quadThird.IsFourth}");
+Console.WriteLine($"AnyT4.Index: {quadThird.Index}");
+Console.WriteLine($"AnyT4.GetThird(): {quadThird.GetThird()}");
+
+Any<string, int, bool, Guid> quadFourth = Any<string, int, bool, Guid>.Fourth(Guid.Empty);
+Console.WriteLine($"AnyT4 Fourth: IsFirst={quadFourth.IsFirst}, IsFourth={quadFourth.IsFourth}, Index={quadFourth.Index}");
+
+(string? q1, int? q2, bool? q3, Guid? q4) = quadFourth.ToTuple();
+Console.WriteLine($"AnyT4 ToTuple: q4={q4}");
+
+AnyActionResult<string> quadMatch = quadThird.Match(
+    first: s => $"string:{s}",
+    second: i => $"int:{i}",
+    third: b => $"bool:{b}",
+    fourth: g => $"guid:{g}"
+);
+Console.WriteLine($"AnyT4 Match: Result={quadMatch.Result}, Status={quadMatch.Status}");
+
+AnyActionStatus quadSwitch = quadFourth.Switch(
+    first: s => Console.WriteLine($"  quad first: {s}"),
+    second: i => Console.WriteLine($"  quad second: {i}"),
+    third: b => Console.WriteLine($"  quad third: {b}"),
+    fourth: g => Console.WriteLine($"  quad fourth: {g}")
+);
+Console.WriteLine($"AnyT4 Switch status: {quadSwitch}");
+Console.WriteLine();
+
 Console.WriteLine("========================================");
 Console.WriteLine("Demo complete.");
 Console.WriteLine("========================================");
diff --git a/examples/Examples.Errors/Program.cs b/examples/Examples.Errors/Program.cs
index 5408167..b493ae3 100644
--- a/examples/Examples.Errors/Program.cs
+++ b/examples/Examples.Errors/Program.cs
@@ -140,6 +140,98 @@
 }
 Console.WriteLine();
 
+// ============================================================================
+// FAILURE / UNEXPECTED / UNAUTHORIZED / FORBIDDEN / EXCEPTION
+// ============================================================================
+Console.WriteLine("--- Failure / Unexpected / Unauthorized / Forbidden / Exception ---");
+
+Error failure = Error.Failure("Op.Failed", "The operation failed.");
+Console.WriteLine($"Failure: Code={failure.Code}, Type={failure.Type}");
+
+Error unexpected = Error.Unexpected("Sys.Crash", "An unexpected error occurred.");
+Console.WriteLine($"Unexpected: Code={unexpected.Code}, Type={unexpected.Type}");
+
+Error unauthorized = Error.Unauthorized("Auth.NoToken", "Access token is missing.");
+Console.WriteLine($"Unauthorized: Code={unauthorized.Code}, Type={unauthorized.Type}");
+
+Error forbidden = Error.Forbidden("Perm.Denied", "Insufficient permissions.");
+Console.WriteLine($"Forbidden: Code={forbidden.Code}, Type={forbidden.Type}");
+
+try { throw new InvalidOperationException("Disk full"); }
+catch (Exception ex)
+{
+    Error fromEx = Error.Exception(ex);
+    Console.WriteLine($"Exception: Code={fromEx.Code}, Description={fromEx.Description}");
+
+    Error fromExWithCode = Error.Exception("Storage.Full", ex);
+    Console.WriteLine($"Exception with code: Code={fromExWithCode.Code}");
+}
+Console.WriteLine();
+
+// ============================================================================
+// CREATE MANY
+// ============================================================================
+Console.WriteLine("--- CreateMany ---");
+
+Error[] many = Error.CreateMany(
+    Error.Validation("Name.Empty", "Name is required"),
+    Error.Validation("Email.Invalid", "Email is invalid"),
+    Error.Validation("Age.Range", "Age out of range")
+);
+Console.WriteLine($"CreateMany: {many.Length} errors");
+foreach (Error e in many)
+    Console.WriteLine($"  {e.Code}");
+Console.WriteLine();
+
+// ============================================================================
+// SENTINEL VALUES: NOFIRSTERROR / NOERRORS / FALSE
+// ============================================================================
+Console.WriteLine("--- Sentinel Values ---");
+
+Console.WriteLine($"NoFirstError: Code={Error.NoFirstError.Code}, Type={Error.NoFirstError.Type}");
+Console.WriteLine($"NoErrors: Code={Error.NoErrors.Code}");
+Console.WriteLine($"False: Code={Error.False.Code}, Type={Error.False.Type}");
+Console.WriteLine();
+
+// ============================================================================
+// ERRORTYPE ENUM / TOINTTYPE / TOERRORTYPE / TOHTTPSTATUSCODE
+// ============================================================================
+Console.WriteLine("--- ErrorType Enum / ToIntType / ToErrorType ---");
+
+ErrorType[] types =
+{
+    ErrorType.Failure, ErrorType.Validation, ErrorType.NotFound,
+    ErrorType.Unauthorized, ErrorType.Forbidden, ErrorType.Conflict, ErrorType.Unexpected
+};
+
+foreach (ErrorType t in types)
+{
+    int intType = t.ToIntType();
+    int httpCode = t.ToHttpStatusCode();
+    Console.WriteLine($"  {t}: numeric={intType}, http={httpCode}");
+}
+
+ErrorType fromHttp404 = 404.ToErrorType();
+Console.WriteLine($"404.ToErrorType(): {fromHttp404}");
+
+ErrorType fromHttp400 = 400.ToErrorType();
+Console.WriteLine($"400.ToErrorType(): {fromHttp400}");
+Console.WriteLine();
+
+// ============================================================================
+// IERROR INTERFACE
+// ============================================================================
+Console.WriteLine("--- IError Interface ---");
+
+Error sample = Error.NotFound("Sample.Missing", "Sample not found");
+IError asInterface = sample;
+Console.WriteLine($"IError.Code={asInterface.Code}");
+Console.WriteLine($"IError.Description={asInterface.Description}");
+Console.WriteLine($"IError.Type={asInterface.Type}");
+Console.WriteLine($"IError.NumericType={asInterface.NumericType}");
+Console.WriteLine($"IError.Metadata={asInterface.Metadata}");
+Console.WriteLine();
+
 Console.WriteLine("========================================");
 Console.WriteLine("Demo complete.");
 Console.WriteLine("========================================");
diff --git a/examples/Examples.Maybe/Program.cs b/examples/Examples.Maybe/Program.cs
index 1b17166..72a5157 100644
--- a/examples/Examples.Maybe/Program.cs
+++ b/examples/Examples.Maybe/Program.cs
@@ -164,6 +164,154 @@ from b in 3.AsMaybe()
 Console.WriteLine($"Choose: [{string.Join(", ", chosen)}]");
 Console.WriteLine();
 
+// ============================================================================
+// BIND
+// ============================================================================
+Console.WriteLine("--- Bind ---");
+
+Maybe<string> bindName = "alice".AsMaybe();
+Maybe<int> nameLength = bindName.Bind(n => n.Length > 0 ? Maybe<int>.From(n.Length) : Maybe<int>.None);
+Console.WriteLine($"Bind Some: {nameLength.Value}");
+
+Maybe<int> emptyBound = Maybe<string>.None.Bind(n => Maybe<int>.From(n.Length));
+Console.WriteLine($"Bind None: HasValue={emptyBound.HasValue}");
+Console.WriteLine();
+
+// ============================================================================
+// GET VALUE OR DEFAULT / GET VALUE OR THROW
+// ============================================================================
+Console.WriteLine("--- GetValueOrDefault / GetValueOrThrow ---");
+
+Maybe<int> someInt = 42.AsMaybe();
+Maybe<int> noneInt = Maybe<int>.None;
+
+int gvod = noneInt.GetValueOrDefault(-1);
+Console.WriteLine($"GetValueOrDefault (None): {gvod}");
+
+int gvod2 = noneInt.GetValueOrDefault(() => 99);
+Console.WriteLine($"GetValueOrDefault factory (None): {gvod2}");
+
+int gvod3 = someInt.GetValueOrDefault(-1);
+Console.WriteLine($"GetValueOrDefault (Some): {gvod3}");
+
+int gvot = someInt.GetValueOrThrow();
+Console.WriteLine($"GetValueOrThrow (Some): {gvot}");
+
+try { noneInt.GetValueOrThrow("No value!"); }
+catch (InvalidOperationException ex) { Console.WriteLine($"GetValueOrThrow (None) threw: {ex.Message}"); }
+Console.WriteLine();
+
+// ============================================================================
+// TRY FIRST / TRY LAST / TRY FIND
+// ============================================================================
+Console.WriteLine("--- TryFirst / TryLast / TryFind ---");
+
+int[] nums = { 3, 7, 2, 9, 1 };
+Maybe<int> firstVal = nums.TryFirst();
+Console.WriteLine($"TryFirst: {firstVal.Value}");
+
+Maybe<int> firstMatch = nums.TryFirst(x => x > 5);
+Console.WriteLine($"TryFirst (predicate): {firstMatch.Value}");
+
+Maybe<int> noMatch = nums.TryFirst(x => x > 100);
+Console.WriteLine($"TryFirst (no match): HasValue={noMatch.HasValue}");
+
+Maybe<int> lastVal = nums.TryLast();
+Console.WriteLine($"TryLast: {lastVal.Value}");
+
+Maybe<int> lastMatch = nums.TryLast(x => x > 5);
+Console.WriteLine($"TryLast (predicate): {lastMatch.Value}");
+
+IReadOnlyDictionary<string, int> dict = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } };
+Maybe<int> found = dict.TryFind("b");
+Console.WriteLine($"TryFind found: {found.Value}");
+Maybe<int> notFoundVal = dict.TryFind("z");
+Console.WriteLine($"TryFind not found: HasValue={notFoundVal.HasValue}");
+Console.WriteLine();
+
+// ============================================================================
+// AS NULLABLE
+// ============================================================================
+Console.WriteLine("--- AsNullable ---");
+
+int? nullable = someInt.AsNullable();
+Console.WriteLine($"AsNullable (Some): {nullable}");
+
+int? nullableNone = noneInt.AsNullable();
+Console.WriteLine($"AsNullable (None): {nullableNone.HasValue}");
+Console.WriteLine();
+
+// ============================================================================
+// EXECUTE / EXECUTE NO VALUE
+// ============================================================================
+Console.WriteLine("--- Execute / ExecuteNoValue ---");
+
+someInt.Execute(v => Console.WriteLine($"  Execute (Some): {v}"));
+noneInt.Execute(v => Console.WriteLine("  This won't print"));
+
+noneInt.ExecuteNoValue(() => Console.WriteLine("  ExecuteNoValue (None) fired"));
+someInt.ExecuteNoValue(() => Console.WriteLine("  This won't print"));
+Console.WriteLine();
+
+// ============================================================================
+// FLATTEN
+// ============================================================================
+Console.WriteLine("--- Flatten ---");
+
+Maybe<Maybe<int>> nested = Maybe<Maybe<int>>.From(42.AsMaybe());
+Maybe<int> flat = nested.Flatten();
+Console.WriteLine($"Flatten: {flat.Value}");
+
+Maybe<Maybe<int>> nestedNone = Maybe<Maybe<int>>.None;
+Maybe<int> flatNone = nestedNone.Flatten();
+Console.WriteLine($"Flatten None: HasValue={flatNone.HasValue}");
+Console.WriteLine();
+
+// ============================================================================
+// DECONSTRUCT
+// ============================================================================
+Console.WriteLine("--- Deconstruct ---");
+
+(bool hasValue, int? val) = someInt;
+Console.WriteLine($"Deconstruct Some: hasValue={hasValue}, value={val}");
+
+(bool hasValueNone, int? valNone) = noneInt;
+Console.WriteLine($"Deconstruct None: hasValue={hasValueNone}, value={valNone}");
+Console.WriteLine();
+
+// ============================================================================
+// TO MAYBE UNIT RESULT
+// ============================================================================
+Console.WriteLine("--- ToMaybeUnitResult ---");
+
+Result unitOk = someInt.ToMaybeUnitResult();
+Console.WriteLine($"ToMaybeUnitResult (Some): IsSuccess={unitOk.IsSuccess}");
+
+Result unitNone = noneInt.ToMaybeUnitResult(Error.NotFound("Val", "No value"));
+Console.WriteLine($"ToMaybeUnitResult (None): IsFailure={unitNone.IsFailure}, Code={unitNone.FirstError.Code}");
+Console.WriteLine();
+
+// ============================================================================
+// COLLECTION: SEQUENCE / TRAVERSE / PARTITION
+// ============================================================================
+Console.WriteLine("--- Collection: Sequence / Traverse / Partition ---");
+
+List<Maybe<int>> allSome = new() { 1.AsMaybe(), 2.AsMaybe(), 3.AsMaybe() };
+Maybe<int[]> sequenced = allSome.Sequence();
+Console.WriteLine($"Sequence (all Some): [{string.Join(", ", sequenced.Value)}]");
+
+List<Maybe<int>> withNone = new() { 1.AsMaybe(), Maybe<int>.None, 3.AsMaybe() };
+Maybe<int[]> sequencedNone = withNone.Sequence();
+Console.WriteLine($"Sequence (has None): HasValue={sequencedNone.HasValue}");
+
+Maybe<int[]> traversed = new[] { "1", "2", "3" }
+    .Traverse(s => int.TryParse(s, out int n) ? Maybe<int>.From(n) : Maybe<int>.None);
+Console.WriteLine($"Traverse: [{string.Join(", ", traversed.Value)}]");
+
+(int[] values, int noneCount) = withNone.Partition();
+Console.WriteLine($"Partition: {values.Length} values, {noneCount} None(s)");
+Console.WriteLine();
+
 Console.WriteLine("========================================");
 Console.WriteLine("Demo complete.");
 Console.WriteLine("========================================");
diff --git a/examples/Examples.Results/Program.cs b/examples/Examples.Results/Program.cs
index 9891e0b..dc72428 100644
--- a/examples/Examples.Results/Program.cs
+++ b/examples/Examples.Results/Program.cs
@@ -218,6 +218,229 @@ Result<string> GetUserName(int id)
 Console.WriteLine(result);
 Console.WriteLine();
 
+// ============================================================================
+// MAP (TRANSFORM VALUE)
+// ============================================================================
+Console.WriteLine("--- Map ---");
+
+Result<int> doubled = Result.Success(21).Map(v => v * 2);
+Console.WriteLine($"Map: {doubled.Value}");
+
+Result<string> asString = Result.Success(42).Map(v => $"Value is {v}");
+Console.WriteLine($"Map to string: {asString.Value}");
+
+Result<string> mapFailed = Result.Failure<int>(Error.Validation("X", "Bad")).Map(v => $"Value is {v}");
+Console.WriteLine($"Map on failure propagates: {mapFailed.FirstError.Code}");
+Console.WriteLine();
+
+// ============================================================================
+// BIND (CHAIN WITH DIFFERENT RETURN TYPE)
+// ============================================================================
+Console.WriteLine("--- Bind ---");
+
+Result<int> parsed = Result.Success("123")
+    .Bind(s => int.TryParse(s, out int n) ? Result.Success(n) : Result.Failure<int>(Error.Validation("Parse", "Not a number")));
+Console.WriteLine($"Bind parse: {parsed.Value}");
+
+Result bindUnit = Result.Success("alice")
+    .Bind(s => s.Length > 0 ? Result.Success() : Result.Failure(Error.Validation("Name", "Empty")));
+Console.WriteLine($"Bind to unit: {bindUnit.IsSuccess}");
+Console.WriteLine();
+
+// ============================================================================
+// TAP (SIDE EFFECT ON SUCCESS)
+// ============================================================================
+Console.WriteLine("--- Tap ---");
+
+Result.Success(10)
+    .Tap(v => Console.WriteLine($"  Tap value: {v}"))
+    .Tap(() => Console.WriteLine("  Tap no-arg"))
+    .Tap(true, v => Console.WriteLine($"  Tap conditional true: {v}"))
+    .Tap(false, v => Console.WriteLine("  This won't print"))
+    .Tap(() => 5 > 3, v => Console.WriteLine($"  Tap predicate: {v}"));
+
+Result.Failure<int>(Error.NotFound("X", "Missing"))
+    .Tap(v => Console.WriteLine("  This won't print (failure)"));
+Console.WriteLine();
+
+// ============================================================================
+// ELSE (FALLBACK ON FAILURE)
+// ============================================================================
+Console.WriteLine("--- Else ---");
+
+Result<int> elseValue = Result.Failure<int>(Error.NotFound("X", "Missing")).Else(42);
+Console.WriteLine($"Else with value: {elseValue.Value}");
+
+Result<int> elseFromErrors = Result.Failure<int>(Error.Validation("X", "Bad")).Else(errors => -1);
+Console.WriteLine($"Else from errors: {elseFromErrors.Value}");
+
+Result<int> elseReplaceError = Result.Failure<int>(Error.Validation("Old", "Old error"))
+    .Else(Error.Conflict("New", "Replaced error"));
+Console.WriteLine($"Else replace error: {elseReplaceError.FirstError.Code}");
+
+Result<int> elseNoChange = Result.Success(99).Else(0);
+Console.WriteLine($"Else on success (no change): {elseNoChange.Value}");
+Console.WriteLine();
+
+// ============================================================================
+// FINALLY (ALWAYS EXECUTES)
+// ============================================================================
+Console.WriteLine("--- Finally ---");
+
+string finallySuccess = Result.Success(7).Finally(r => r.IsSuccess ? $"Ok: {r.Value}" : "Fail");
+Console.WriteLine($"Finally success: {finallySuccess}");
+
+string finallyFail = Result.Failure<int>(Error.NotFound("X", "Missing"))
+    .Finally(r => r.IsSuccess ? "Ok" : $"Fail: {r.FirstError.Code}");
+Console.WriteLine($"Finally failure: {finallyFail}");
+Console.WriteLine();
+
+// ============================================================================
+// GET VALUE OR DEFAULT / GET VALUE OR THROW
+// ============================================================================
+Console.WriteLine("--- GetValueOrDefault / GetValueOrThrow ---");
+
+int defaulted = Result.Failure<int>(Error.NotFound("X", "Missing")).GetValueOrDefault(-1);
+Console.WriteLine($"GetValueOrDefault: {defaulted}");
+
+int fromFactory = Result.Failure<int>(Error.NotFound("X", "Missing")).GetValueOrDefault(() => 99);
+Console.WriteLine($"GetValueOrDefault factory: {fromFactory}");
+
+int found = Result.Success(42).GetValueOrDefault(-1);
+Console.WriteLine($"GetValueOrDefault success: {found}");
+
+try
+{
+    Result.Failure<int>(Error.NotFound("X", "Missing")).GetValueOrThrow("Custom message");
+}
+catch (InvalidOperationException ex)
+{
+    Console.WriteLine($"GetValueOrThrow threw: {ex.Message}");
+}
+Console.WriteLine();
+
+// ============================================================================
+// UNWRAP / UNWRAP OR DEFAULT
+// ============================================================================
+Console.WriteLine("--- Unwrap / UnwrapOrDefault ---");
+
+int unwrapped = Result.Success(55).Unwrap();
+Console.WriteLine($"Unwrap success: {unwrapped}");
+
+int unwrapOr = Result.Failure<int>(Error.NotFound("X", "Missing")).UnwrapOrDefault(-999);
+Console.WriteLine($"UnwrapOrDefault: {unwrapOr}");
+
+try
+{
+    Result.Failure<int>(Error.Validation("X", "Bad")).Unwrap();
+}
+catch (ResultUnwrapException ex)
+{
+    Console.WriteLine($"Unwrap threw ResultUnwrapException: {ex.Errors.Length} error(s)");
+}
+Console.WriteLine();
+
+// ============================================================================
+// RECOVER / RECOVER FIRST
+// ============================================================================
+Console.WriteLine("--- Recover / RecoverFirst ---");
+
+Result<int> recovered = Result.Failure<int>(Error.NotFound("Cache.Miss", "Not in cache"))
+    .Recover(ErrorType.NotFound, _ => Result.Success(0));
+Console.WriteLine($"Recover NotFound: {recovered.Value}");
+
+Result<int> notRecovered = Result.Failure<int>(Error.Validation("X", "Bad"))
+    .Recover(ErrorType.NotFound, _ => Result.Success(0));
+Console.WriteLine($"Recover (wrong type, unchanged): {notRecovered.IsFailure}");
+
+Result<int> recoveredFirst = Result.Failure<int>(Error.Unauthorized("Auth", "No token"))
+    .RecoverFirst(ErrorType.Unauthorized, _ => Result.Success(-1));
+Console.WriteLine($"RecoverFirst Unauthorized: {recoveredFirst.Value}");
+Console.WriteLine();
+
+// ============================================================================
+// BINDIF (CONDITIONAL BIND)
+// ============================================================================
+Console.WriteLine("--- BindIf ---");
+
+bool isAdmin = true;
+Result<string> role = Result.Success("alice")
+    .BindIf(isAdmin, name => Result.Success($"{name}:admin"))
+    .BindIf(!isAdmin, name => Result.Success($"{name}:guest"));
+Console.WriteLine($"BindIf (bool): {role.Value}");
+
+Result<int> bindIfPredicate = Result.Success(10)
+    .BindIf(v => v > 5, v => Result.Success(v * 2));
+Console.WriteLine($"BindIf predicate: {bindIfPredicate.Value}");
+Console.WriteLine();
+
+// ============================================================================
+// FAILIF (FAIL WHEN CONDITION IS MET)
+// ============================================================================
+Console.WriteLine("--- FailIf ---");
+
+Result<int> failIfNeg = Result.Success(-5)
+    .FailIf(v => v < 0, Error.Validation("Range", "Must be non-negative"));
+Console.WriteLine($"FailIf (met): {failIfNeg.FirstError.Code}");
+
+Result<int> failIfOk = Result.Success(5)
+    .FailIf(v => v < 0, Error.Validation("Range", "Must be non-negative"));
+Console.WriteLine($"FailIf (not met): {failIfOk.Value}");
+Console.WriteLine();
+
+// ============================================================================
+// TRYCATCH (EXCEPTION-SAFE BIND)
+// ============================================================================
+Console.WriteLine("--- TryCatch ---");
+
+Result<int> tryCatchOk = Result.Success("42")
+    .TryCatch(s => Result.Success(int.Parse(s)));
+Console.WriteLine($"TryCatch success: {tryCatchOk.Value}");
+
+Result<int> tryCatchFail = Result.Success("not-a-number")
+    .TryCatch(s => Result.Success(int.Parse(s)));
+Console.WriteLine($"TryCatch caught exception: IsFailure={tryCatchFail.IsFailure}");
+Console.WriteLine();
+
+// ============================================================================
+// COLLECTION: SEQUENCE / TRAVERSE / PARTITION / FIRSTFAILUREORSUCCESSES
+// ============================================================================
+Console.WriteLine("--- Collection Extensions ---");
+
+List<Result<int>> allOkResults = new()
+{
+    Result.Success(1), Result.Success(2), Result.Success(3)
+};
+Result<int[]> sequenced = allOkResults.Sequence();
+Console.WriteLine($"Sequence (all ok): [{string.Join(", ", sequenced.Value)}]");
+
+List<Result<int>> withFailure = new()
+{
+    Result.Success(1),
+    Result.Failure<int>(Error.Validation("X", "Bad")),
+    Result.Success(3)
+};
+Result<int[]> sequencedFail = withFailure.Sequence();
+Console.WriteLine($"Sequence (has failure): IsFailure={sequencedFail.IsFailure}, errors={sequencedFail.Errors.Length}");
+
+Result<int[]> traversed = new[] { "1", "2", "3" }
+    .Traverse(s => int.TryParse(s, out int n) ? Result.Success(n) : Result.Failure<int>(Error.Validation("Parse", "Bad")));
+Console.WriteLine($"Traverse: [{string.Join(", ", traversed.Value)}]");
+
+(int[] successes, Error[] errs) = withFailure.Partition();
+Console.WriteLine($"Partition: {successes.Length} successes, {errs.Length} errors");
+
+List<Result> mixedResults = new()
+{
+    Result.Success(), Result.Failure(Error.NotFound("X", "Missing")), Result.Success()
+};
+Result firstFail = mixedResults.FirstFailureOrSuccesses();
+Console.WriteLine($"FirstFailureOrSuccesses: {firstFail.FirstError.Code}");
+
+Result allOk = new List<Result> { Result.Success(), Result.Success() }.FirstFailureOrSuccesses();
+Console.WriteLine($"FirstFailureOrSuccesses (all ok): {allOk.IsSuccess}");
+Console.WriteLine();
+
 Console.WriteLine("========================================");
 Console.WriteLine("Demo complete.");
 Console.WriteLine("========================================");
diff --git a/examples/Examples.Rules/Program.cs b/examples/Examples.Rules/Program.cs
index 25f8d53..28ccfc9 100644
--- a/examples/Examples.Rules/Program.cs
+++ b/examples/Examples.Rules/Program.cs
@@ -170,6 +170,43 @@
 );
 Console.WriteLine();
 
+// ============================================================================
+// NEXT COMBINATOR (PIPELINE CHAIN)
+// ============================================================================
+Console.WriteLine("--- Next Combinator ---");
+
+IRule<int> mustBePositive = ((Func<int, Result>)(x =>
+    x > 0 ? Result.Success() : Result.Failure(Error.Validation("Positive", "Must be positive")))).ToRule();
+
+IRule<int> mustBeEven = ((Func<int, Result>)(x =>
+    x % 2 == 0 ? Result.Success() : Result.Failure(Error.Validation("Even", "Must be even")))).ToRule();
+
+IRule<int> mustBeLessThan100 = ((Func<int, Result>)(x =>
+    x < 100 ? Result.Success() : Result.Failure(Error.Validation("Range", "Must be less than 100")))).ToRule();
+
+IRuleBase<int> chain = mustBePositive.Next(mustBeEven).Next(mustBeLessThan100);
+
+RuleEngine.Evaluate(chain, 4).Switch(
+    onSuccess: () => Console.WriteLine("4: passes all chained rules"),
+    onFailure: errors => Console.WriteLine($"4 failed: {errors[0].Description}")
+);
+
+RuleEngine.Evaluate(chain, -2).Switch(
+    onSuccess: () => Console.WriteLine("-2 passed"),
+    onFailure: errors => Console.WriteLine($"-2 failed at first rule: {errors[0].Code}")
+);
+
+RuleEngine.Evaluate(chain, 3).Switch(
+    onSuccess: () => Console.WriteLine("3 passed"),
+    onFailure: errors => Console.WriteLine($"3 (odd) failed: {errors[0].Code}")
+);
+
+RuleEngine.Evaluate(chain, 200).Switch(
+    onSuccess: () => Console.WriteLine("200 passed"),
+    onFailure: errors => Console.WriteLine($"200 (>=100) failed: {errors[0].Code}")
+);
+Console.WriteLine();
+
 Console.WriteLine("========================================");
 Console.WriteLine("Demo complete.");
 Console.WriteLine("========================================");
diff --git a/examples/Examples.Validation/Program.cs b/examples/Examples.Validation/Program.cs
index aacf0ae..63602b1 100644
--- a/examples/Examples.Validation/Program.cs
+++ b/examples/Examples.Validation/Program.cs
@@ -245,6 +245,100 @@
     });
 
 Console.WriteLine();
+// ============================================================================
+// 11. ADVANCED COMPARABLE VALIDATORS
+// ============================================================================
+Console.WriteLine("--- 11. LessThan / LessThanOrEqualTo / ExclusiveBetween / InclusiveBetween / Equal / NotEqual ---");
+
+Result<ProductModel> ltResult = await Validator.ValidateAsync(
+    new ProductModel("SKU-1", 150m, 5, null),
+    (m, rules) => rules.For(() => m.Price).LessThan(100m));
+Console.WriteLine($"Price 150 LessThan(100): IsFailure={ltResult.IsFailure}");
+
+Result<ProductModel> lteResult = await Validator.ValidateAsync(
+    new ProductModel("SKU-1", 100m, 5, null),
+    (m, rules) => rules.For(() => m.Price).LessThanOrEqualTo(100m));
+Console.WriteLine($"Price 100 LessThanOrEqualTo(100): IsSuccess={lteResult.IsSuccess}");
+
+Result<ProductModel> excResult = await Validator.ValidateAsync(
+    new ProductModel("SKU-1", 10m, 5, null),
+    (m, rules) => rules.For(() => m.Price).ExclusiveBetween(0m, 100m));
+Console.WriteLine($"Price 10 ExclusiveBetween(0,100): IsSuccess={excResult.IsSuccess}");
+
+Result<ProductModel> incResult = await Validator.ValidateAsync(
+    new ProductModel("SKU-1", 100m, 5, null),
+    (m, rules) => rules.For(() => m.Price).InclusiveBetween(0m, 100m));
+Console.WriteLine($"Price 100 InclusiveBetween(0,100): IsSuccess={incResult.IsSuccess}");
+
+Result<ProductModel> eqResult = await Validator.ValidateAsync(
+    new ProductModel("EXPECTED-SKU", 10m, 5, null),
+    (m, rules) => rules.For(() => m.Sku).Equal("EXPECTED-SKU"));
+Console.WriteLine($"Sku Equal('EXPECTED-SKU'): IsSuccess={eqResult.IsSuccess}");
+
+Result<ProductModel> neResult = await Validator.ValidateAsync(
+    new ProductModel("RESERVED", 10m, 5, null),
+    (m, rules) => rules.For(() => m.Sku).NotEqual("RESERVED"));
+Console.WriteLine($"Sku NotEqual('RESERVED'): IsFailure={neResult.IsFailure}");
+
+Console.WriteLine();
+
+// ============================================================================
+// 12. STRING VALIDATORS (StartsWith, EndsWith, NotNull)
+// ============================================================================
+Console.WriteLine("--- 12. StartsWith / EndsWith / NotNull ---");
+
+Result<CreateUserCommand> swResult = await Validator.ValidateAsync(
+    new CreateUserCommand("user@example.com", "Dr. Smith", 30, "P@ssw0rd!"),
+    (m, rules) => rules.For(() => m.Name).StartsWith("Dr."));
+Console.WriteLine($"Name StartsWith('Dr.'): IsSuccess={swResult.IsSuccess}");
+
+Result<CreateUserCommand> ewResult = await Validator.ValidateAsync(
+    new CreateUserCommand("user@example.com", "Smith Jr.", 30, "P@ssw0rd!"),
+    (m, rules) => rules.For(() => m.Name).EndsWith("Jr."));
+Console.WriteLine($"Name EndsWith('Jr.'): IsSuccess={ewResult.IsSuccess}");
+
+Result<CreateUserCommand> notNullResult = await Validator.ValidateAsync(
+    new CreateUserCommand("user@example.com", null, 30, "P@ssw0rd!"),
+    (m, rules) => rules.For(() => m.Name).NotNull());
+Console.WriteLine($"Name=null NotNull: IsFailure={notNullResult.IsFailure}");
+
+Console.WriteLine();
+
+// ============================================================================
+// 13. VALIDATEWITH (RAILWAY BINDING)
+// ============================================================================
+Console.WriteLine("--- 13. ValidateWith / ValidateWithAsync ---");
+
+Result<CreateUserCommand> invalidPipeline = Result.Success(new CreateUserCommand("bad-email", "Alice", 30, "P@ssw0rd!"))
+    .ValidateWith((m, rules) =>
+    {
+        rules.For(() => m.Email).NotEmpty().EmailAddress();
+        rules.For(() => m.Name).NotEmpty().MinLength(2);
+    });
+
+invalidPipeline.Switch(
+    onSuccess: v => Console.WriteLine($"ValidateWith success: {v.Email}"),
+    onError: errors =>
+    {
+        Console.WriteLine($"ValidateWith failed with {errors.Length} error(s):");
+        foreach (var e in errors)
+            Console.WriteLine($"  [{e.Code}] {e.Description}");
+    });
+
+Result<CreateUserCommand> validPipeline = Result.Success(new CreateUserCommand("alice@example.com", "Alice", 30, "P@ssw0rd!"))
+    .ValidateWith((m, rules) =>
+    {
+        rules.For(() => m.Email).NotEmpty().EmailAddress();
+        rules.For(() => m.Name).NotEmpty().MinLength(2);
+    });
+Console.WriteLine($"ValidateWith (valid): IsSuccess={validPipeline.IsSuccess}");
+
+Result<CreateUserCommand> alreadyFailed = Result.Failure<CreateUserCommand>(CSharpEssentials.Errors.Error.Validation("Pre", "Already failed"))
+    .ValidateWith((m, rules) => rules.For(() => m.Email).NotEmpty());
+Console.WriteLine($"ValidateWith short-circuits on pre-existing failure: IsFailure={alreadyFailed.IsFailure}");
+
+Console.WriteLine();
+
 Console.WriteLine("========================================");
 Console.WriteLine("Demo complete.");
 Console.WriteLine("========================================");