🧹 Resetting the Global uCalc State

The static uCalc.DefaultClear() method provides a powerful way to reset the global uCalc environment. It unwinds the default instance stack and restores the original, built-in default instance to its pristine, startup condition.

⚙️ How the Default Instance Stack Works

uCalc maintains a stack of "default" instances. This allows different parts of an application to temporarily set their own uCalc instance as the active default without losing the previous one. This behavior is LIFO (Last-In, First-Out).

1. Initial State: At startup, there is one built-in default instance on the stack. You can access it via uCalc.GetDefaultInstance().
2. Pushing a New Default: When you call myInstance.IsDefault(true), myInstance is pushed onto the top of the stack. It becomes the new active default returned by uCalc.GetDefaultInstance().
3. Popping an Instance: When an instance that is on the stack is disposed of, or if you call myInstance.IsDefault(false), it is popped from the stack, and the previous instance becomes the active default again.
4. Clearing the Stack: uCalc.DefaultClear() removes all instances from the stack except for the original one. It then resets that original instance, clearing all user-defined variables, functions, and other settings.

🆚 Comparative Analysis: Global State Management

The Traditional Approach (e.g., C# / C++)

In a standard application, managing a global or shared "calculator" object is often done using a Singleton pattern or a simple static class.

// C# Singleton Examplepublic sealed class GlobalCalculator{    private static readonly GlobalCalculator instance = new GlobalCalculator();    private GlobalCalculator() { /* setup */ }    public static GlobalCalculator Instance { get { return instance; } }        public double Evaluate(string expression) { /* ... */ }    public void Reset() { /* ... */ }}// UsageGlobalCalculator.Instance.Evaluate("1+1");

While functional, this approach has drawbacks:

• Rigidity: There is only one global instance. If different components need different settings (e.g., custom functions, different number precision), they must manually configure and restore the single instance, which is error-prone.
• State Conflicts: Component A might change a setting that Component B relies on, leading to unexpected behavior.
• Testing: Tightly coupling to a global static instance makes unit testing difficult.

The uCalc Advantage

uCalc's default instance stack provides a more flexible and robust solution. It behaves like a managed, scoped global context.

• Scoped Overrides: A component can push its own configured uCalc instance onto the stack, perform its work, and then pop it off, automatically restoring the previous context. This prevents state conflicts.
• Centralized Reset: The uCalc.DefaultClear() method acts as a global "panic button." It's invaluable in scenarios like:
  • Tear-down logic in unit tests to ensure a clean state for every test run.
  • An "application reset" feature for end-users.
  • Recovering from an error state where the default stack might be corrupted.

In essence, uCalc provides a structured mechanism for managing a shared resource, avoiding the common pitfalls of global static objects.