guardSync<T> function

Result<T, BaseException> guardSync<T>(
  1. T compute(), {
  2. String? source,
  3. void onSuccess(
    1. T value
    )?,
  4. void onError(
    1. BaseException e
    )?,
  5. bool manual = false,
  6. Map<String, dynamic> additionalContext = const {},
})

Guards a synchronous computation with the same semantics as guard.

Implementation

Result<T, BaseException> guardSync<T>(
  T Function() compute, {
  String? source,
  void Function(T value)? onSuccess,
  void Function(BaseException e)? onError,
  bool manual = false,
  Map<String, dynamic> additionalContext = const {},
}) {
  try {
    final value = compute();
    onSuccess?.call(value);
    return Ok<T, BaseException>(value);
  } catch (error, stack) {
    final normalized = normalizeError(
      error,
      stack,
      source: source,
    );
    onError?.call(normalized);

    // Fire-and-forget reporting for sync guard to avoid blocking UI threads.
    unawaited(BugReportClient.instance.captureSafely(
      normalized,
      manual: manual,
      additionalContext: additionalContext,
    ));

    return Err<T, BaseException>(normalized);
  }
}