basic: Add a generic Option class

Author: gnprice

lib/basic.dart

@@ -0,0 +1,56 @@
+
+/// Either a value, or the absence of a value.
+///
+/// An `Option<T>` is either an `OptionSome` representing a `T` value,
+/// or an `OptionNone` representing the absence of a value.
+///
+/// When `T` is non-nullable, this is the same information that is
+/// normally represented as a `T?`.
+/// This class is useful when T is nullable (or might be nullable).
+/// In that case `null` is already a T value,
+/// and so can't also be used to represent the absence of a T value,
+/// but `OptionNone()` is a different value from `OptionSome(null)`.
+///
+/// This interface is small because members are added lazily when needed.
+/// If adding another member, consider borrowing the naming from Rust:
+///   https://doc.rust-lang.org/std/option/enum.Option.html
+sealed class Option<T> {
+  const Option();
+
+  /// The value contained in this option, if any; else the given value.
+  T or(T optb);
+}
+
+class OptionNone<T> extends Option<T> {
+  const OptionNone();
+
+  @override
+  T or(T optb) => optb;
+
+  @override
+  bool operator ==(Object other) => other is OptionNone;
+
+  @override
+  int get hashCode => 'OptionNone'.hashCode;
+
+  @override
+  String toString() => 'OptionNone';
+}
+
+class OptionSome<T> extends Option<T> {
+  const OptionSome(this.value);
+
+  final T value;
+
+  @override
+  T or(T optb) => value;
+
+  @override
+  bool operator ==(Object other) => other is OptionSome && value == other.value;
+
+  @override
+  int get hashCode => Object.hash('OptionSome', value);
+
+  @override
+  String toString() => 'OptionSome($value)';
+}

test/basic_test.dart

@@ -0,0 +1,36 @@
+import 'package:checks/checks.dart';
+import 'package:test/scaffolding.dart';
+import 'package:zulip/basic.dart';
+
+void main() {
+  group('Option', () {
+    test('==/hashCode', () {
+      void checkEqual(Object a, Object b) {
+        check(a).equals(b);
+        check(a.hashCode).equals(b.hashCode);
+      }
+
+      void checkUnequal(Object a, Object b) {
+        check(a).not((it) => it.equals(b));
+      }
+
+      checkEqual(OptionNone<int>(), OptionNone<int?>());
+      checkEqual(OptionNone<int>(), OptionNone<String>());
+
+      checkEqual(OptionSome<int>(3), OptionSome<int?>(3));
+      checkEqual(OptionSome<int?>(null), OptionSome<String?>(null));
+      checkEqual(OptionSome(OptionSome(3)), OptionSome(OptionSome(3)));
+
+      checkUnequal(OptionNone<void>(), OptionSome<void>(null));
+      checkUnequal(OptionSome(3), OptionSome(OptionSome(3)));
+      checkUnequal(3, OptionSome(3));
+    });
+
+    test('or', () {
+      check(OptionSome<int>(3).or(4)).equals(3);
+      check(OptionSome<int?>(3).or(4)).equals(3);
+      check(OptionSome<int?>(null).or(4)).equals(null);
+      check(OptionNone<int?>().or(4)).equals(4);
+    });
+  });
+}