PureComputed or Computed with deferEvaluation: Choosing the Right Approach for Automatic Disposal in Complex Dependency Chains

The Strategy for Automatic Disposal

In complex dependency chains, you should default to pureComputed for derived values where the lifecycle is tied to the UI or specific consumers. Use computed with deferEvaluation only for values that must persist in memory even when no active subscribers exist, provided you are prepared to manage their manual disposal.

How pureComputed Behaves in Chains

pureComputed is designed for memory efficiency through "active evaluation." In a nested chain (e.g., Observable A → pureComputed B → computed C), the behavior is as follows:

• Automatic Disposal: If C subscribes to B, B remains active. If C is disposed, B's subscriber count drops. If it reaches zero, B automatically suspends and disposes itself, which in turn removes its subscription to A.
• Downstream Safety: Disposing an intermediate pureComputed does not "break" downstream nodes because the downstream node is already in the process of being destroyed. The chain simply collapses upward and memory.
• Subscription Counts: When a pureComputed is removed, the subscription count on its dependencies decreases immediately. This prevents "zombie" dependencies from keeping large object graphs alive in memory.

Computed with deferEvaluation Risks

The deferEvaluation flag is a performance optimization that delays the initial calculation until the first subscriber arrives. However, it does not change the lifecycle model:

• Memory Leaks: A computed observable remains active indefinitely even if it has zero subscribers. In long-running applications where view models are created dynamically, failing to call dispose() will lead to memory leaks.
• Manual Cleanup: If you use this approach, you must store a reference to the computed and explicitly call computed.dispose() during the view model's unmount or cleanup phase.

Comparison Matrix

Feature	pureComputed	computed (deferEvaluation)
Disposal Strategy	Automatic (at 0 subscribers)	Manual (required)
Memory Usage	Lower (suspends when unused)	Higher (persists indefinitely)
Use Case	UI-bound derived data	Global state/Background tasks

Practical Recommendation

For large view models with thousands of changes, pureComputed yields significantly better performance because it avoids the CPU cost of calculating values for branches that are not currently visible or active. Use deferEvaluation only when the value is expensive to compute and you need it to stay ready regardless of the UI state.