Option | extension methods simplifying work

lib/hmi_core_option.dart

@@ -1,3 +1,5 @@
 library hmi_core_option;
 
-export 'src/core/option/option.dart';
+export 'src/core/option/option.dart';
+export 'src/core/option/extension_extract.dart';
+export 'src/core/option/extension_transform.dart';

lib/hmi_core_result.dart

@@ -1,3 +1,8 @@
 library hmi_core_result;
 
-export 'src/core/result/result.dart';
+export 'src/core/result/result.dart';
+export 'src/core/result/extension_adapter.dart';
+export 'src/core/result/extension_boolean_operations.dart';
+export 'src/core/result/extension_extract.dart';
+export 'src/core/result/extension_querying.dart';
+export 'src/core/result/extension_transform.dart';

lib/src/core/option/extension_extract.dart

@@ -0,0 +1,211 @@
+import 'package:hmi_core/hmi_core_failure.dart';
+import 'package:hmi_core/hmi_core_option.dart';
+///
+/// Extracting contained values
+extension Extract<V> on Option<V> {
+  ///
+  /// Returns the contained [Some] value, consuming the `self` value.
+  ///
+  /// Because this function may panic, its use is generally discouraged.
+  /// Instead, prefer to use pattern matching and handle the [`None`]
+  /// case explicitly, or call [`unwrap_or`], [`unwrap_or_else`], or
+  /// [`unwrap_or_default`].
+  ///
+  /// [`unwrap_or`]: Option::unwrap_or
+  /// [`unwrap_or_else`]: Option::unwrap_or_else
+  /// [`unwrap_or_default`]: Option::unwrap_or_default
+  ///
+  /// Throws an [Failure] if the self value equals [`None`].
+  ///
+  /// # Examples
+  ///
+  /// ```dart
+  /// final Option<int> x = Ok(2);
+  /// x.unwrap(); // 2
+  /// ```
+  ///
+  /// Should throw a Failure:
+  /// ```dart
+  /// final Result<int, String> x = Err("emergency failure");
+  /// // throw Failure with message: "Called unwrap() on Result with error: emergency failure"
+  /// x.unwrap();
+  /// ```
+  V unwrap() {
+    return switch (this) {
+      Some(:final V value) => value,
+      None() => throw Failure(
+          message: "Called unwrap() on None",
+          stackTrace: StackTrace.current,
+        ),
+    };
+  }
+  ///
+  /// Returns the contained [Some] value, consuming the `self` value.
+  ///
+  /// # Throws an error if the value is a [None] with a custom error message provided by
+  /// `msg`.
+  ///
+  /// # Examples
+  ///
+  /// Basic usage:
+  /// 
+  /// ```dart
+  /// final Option<int> x = Some(2);
+  /// x.expect("A custom message"); // 2
+  /// ```
+  ///
+  /// Should throw a Failure:
+  /// 
+  /// ```dart
+  /// final Option<int> x = None();
+  /// // throw Failure with message: "Testing expect: emergency failure"
+  /// x.expect("Testing expect");
+  /// ```
+  V expect(String message) {
+    return switch (this) {
+      Some(:final V value) => value,
+      None() => throw Failure(
+          message: message,
+          stackTrace: StackTrace.current,
+        ),
+    };
+  }
+
+  // ///
+  // /// # Examples
+  // ///
+  // /// ```dart
+  // /// final Option<int> = None();
+  // /// x.unwrapErr(); // "emergency failure"
+  // /// ```
+  // /// 
+  // /// Should throw a Failure:
+  // /// 
+  // /// ```dart
+  // /// final Result<int, String> x = Ok(2);
+  // /// // throw Failure with message: "Called unwrapErr() on Result with value: 2"
+  // /// x.unwrapErr();
+  // /// ```
+  // E unwrapErr() {
+  //   return switch (this) {
+  //     Ok(:final V value) => throw Failure(
+  //         message: "Called unwrapErr() on Result with value: $value",
+  //         stackTrace: StackTrace.current,
+  //       ),
+  //     Err(:final E error) => error,
+  //   };
+  // }
+  // ///
+  // /// Returns the contained [Err] error, consuming the `this` value.
+  // ///
+  // /// ### Throws an error
+  // ///
+  // /// Throws an [Failure] if the value is an [Ok], with a failure message including the
+  // /// passed message, and the content of the [Ok].
+  // ///
+  // ///
+  // /// ### Examples
+  // ///
+  // /// Basic usage:
+  // /// ```dart
+  // /// final Result<int, String> x = Err("emergency failure");
+  // /// x.expectErr("A custom message"); // "emergency failure"
+  // /// ```
+  // ///
+  // /// Should throw a Failure:
+  // /// ```dart
+  // /// final Result<int, String> x = Ok(2);
+  // /// // throw Failure with message: "Testing expectErr: 2"
+  // /// x.expectErr("Testing expectErr");
+  // /// ```
+  // E expectErr(String message) {
+  //   return switch (this) {
+  //     Ok(:final V value) => throw Failure(
+  //         message: "$message: $value",
+  //         stackTrace: StackTrace.current,
+  //       ),
+  //     Err(:final E error) => error,
+  //   };
+  // }
+  ///
+  /// Returns the contained [Some] value or a provided default.
+  ///
+  /// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing
+  /// the result of a function call, it is recommended to use [`unwrap_or_else`],
+  /// which is lazily evaluated.
+  ///
+  /// ### Examples
+  /// 
+  /// ```dart
+  /// final defaultValue = 2;
+  /// final Option<int> x = Some(9);
+  /// x.unwrapOr(defaultValue); // 9
+  /// //
+  /// final Option<int> y = None();
+  /// y.unwrapOr(defaultValue); // 2
+  /// ```
+  V unwrapOr(V d) {
+    return switch (this) {
+      Some(:final V value) => value,
+      None() => d,
+    };
+  }
+  ///
+  /// Returns the contained [`Some`] value or computes it from a closure.
+  ///
+  /// ### Examples
+  /// 
+  /// ```dart
+  /// int onNone() => 'sNone';
+  ///
+  /// final Option<int> x = Some('isSome');
+  /// x.unwrapOrElse(onNone); // 'isSome'
+  ///
+  /// final Option<int> y = None();
+  /// y.unwrapOrElse(onNone); // 'isNone'
+  /// ```
+  V unwrapOrElse(V Function() d) {
+    return switch (this) {
+      Some(:final V value) => value,
+      None() => d(),
+    };
+  }
+}
+// ///
+// /// Extracting contained values for [Ok]
+// extension ExtractOk<V> on Result<V, Never> {
+//   ///
+//   /// Returns the contained [Ok] value, but never throw an error.
+//   ///
+//   /// It can be used as a maintainability safeguard that will fail
+//   /// to compile if the error type of the [Result] is later changed
+//   /// from [Never] to a type that can actually occur.
+//   ///
+//   /// ### Examples
+//   /// ```dart
+//   /// Result<String, Never> onlyGoodNews() => Ok("this is fine");
+//   /// onlyGoodNews().intoOk(); // "this is fine"
+//   /// ```
+//   V intoOk() {
+//     return (this as Ok).value;
+//   }
+// }
+// ///
+// /// Extracting contained values for [Err]
+// extension ExtractErr<E> on Result<Never, E> {
+//   ///
+//   /// Returns the contained [Err] value, but never throw an error.
+//   ///
+//   /// It can be used as a maintainability safeguard that will fail
+//   /// to compile if the ok type of the [Result] is later changed
+//   /// from [Never] to a type that can actually occur.
+//   ///
+//   /// ### Examples
+//   /// ```dart
+//   /// Result<String, Never> onlyBadNews() => Err("Oops, it failed");
+//   /// onlyBadNews().intoErr(); // "Oops, it failed"
+//   /// ```
+//   E intoErr() {
+//     return (this as Err).error;
+//   }
+// }

lib/src/core/option/extension_transform.dart

@@ -0,0 +1,35 @@
+import 'package:hmi_core/hmi_core_option.dart';
+import 'package:hmi_core/hmi_core_result.dart';
+
+///
+/// Transforming contained values
+extension Transform<V, E> on Option<V> {
+  ///
+  /// Transforms the `Option<T>` into a [Result<T, E>],
+  /// mapping [Some(v)] to [Ok(v)] and [None] to [Err(err)].
+  ///
+  /// Arguments passed to `ok_or` are eagerly evaluated; if you are passing the
+  /// result of a function call, it is recommended to use [`ok_or_else`], which is
+  /// lazily evaluated.
+  ///
+  /// [`Ok(v)`]: Ok
+  /// [`Err(err)`]: Err
+  /// [`Some(v)`]: Some
+  /// [`ok_or_else`]: Option::ok_or_else
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// let x = Some("foo");
+  /// assert_eq!(x.ok_or(0), Ok("foo"));
+  ///
+  /// let x: Option<&str> = None;
+  /// assert_eq!(x.ok_or(0), Err(0));
+  /// ```
+  Result<V, E> okOr(E err) {
+      return switch (this) {
+          Some(:final value) => Ok(value),
+          None() => Err(err),
+      };
+  }
+}

pubspec.yaml

@@ -1,6 +1,6 @@
 name: hmi_core
 description: A Flutter core package of hmi_widgets package which is helps to visualize states, values, changes and other artefacts from technological processes.
-version: 2.0.0
+version: 2.1.2
 homepage: https://github.com/a-givertzman/hmi_core
 
 environment: