Computed<T> class

A derived signal that automatically recalculates when dependencies change.

Computed creates a read-only signal whose value is computed from other signals. It automatically detects dependencies and recalculates whenever any dependency changes.

Key Features

• Automatic dependency tracking: No need to manually list dependencies
• Lazy evaluation: Only computes when accessed and listeners exist
• Error handling: Captures computation errors gracefully
• Circular dependency detection: Throws clear error on cycles

Basic Usage

class CalculatorController extends NeuronController {
  late final width = Signal<double>(10).bind(this);
  late final height = Signal<double>(20).bind(this);

  // Dependencies detected automatically!
  late final area = Computed<double>(
    () => width.val * height.val,
  ).bind(this);
}

Error Handling

If the computation throws, the error is captured and can be checked:

late final ratio = Computed<double>(() {
  if (height.val == 0) throw ArgumentError('Cannot divide by zero');
  return width.val / height.val;
}).bind(this);

// Later:
if (ratio.hasError) {
  print('Error: ${ratio.error}');
} else {
  print('Ratio: ${ratio.val}');
}

Chaining

Computed signals can depend on other computed signals:

late final doubled = Computed<int>(() => count.val * 2).bind(this);
late final quadrupled = Computed<int>(() => doubled.val * 2).bind(this);

Initial Value

Provide an initial value to defer computation:

late final expensive = Computed<Data>(
  () => computeExpensiveValue(),
  initialValue: Data.empty(),
).bind(this);

Note: Computed signals are read-only. You cannot set their value. To change them, modify their dependencies.

See also:

• Signal - Basic reactive value
• Slot - Widget for binding to UI