Update sum_types.md

Tests for maybe

Author: jokalode

GNUmakefile

@@ -1,6 +1,6 @@
 CXX=clang++
 CPPFLAGS=-std=c++20 -nostdinc
-CXXFLAGS=-fprebuilt-module-path=.pcm
+CXXFLAGS=-fprebuilt-module-path=.pcm -g -O0
 
 PRECOMPILE.cc=$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -x c++-module --precompile
 
@@ -12,13 +12,22 @@ clean:
 	-$(RM) .obj/*
 	-$(RM) .pcm/*
 
-test: .bin/list_test
+test: list_test maybe_test
+
+list_test: .bin/list_test
 	.bin/list_test
 
-.bin/list_test: .obj/list_test.o .obj/funcpp.o .obj/funcpp-list.o .obj/funcpp-maybe.o .obj/funcpp-common.o
+maybe_test: .bin/maybe_test
+	.bin/maybe_test
+
+.bin/list_test: .obj/list_test.o .obj/funcpp.o .obj/funcpp-list.o .obj/funcpp-common.o
 
 .obj/list_test.o: .pcm/funcpp.pcm
 
+.bin/maybe_test: .obj/maybe_test.o .obj/funcpp.o .obj/funcpp-maybe.o .obj/funcpp-common.o
+
+.obj/maybe_test.o: .pcm/funcpp.pcm
+
 .obj/funcpp.o .pcm/funcpp.pcm: .pcm/funcpp-common.pcm .pcm/funcpp-list.pcm .pcm/funcpp-maybe.pcm
 
 .obj/funcpp-list.o .pcm/funcpp-list.pcm: .pcm/funcpp-common.pcm

src/funcpp-maybe.cc

@@ -26,6 +26,18 @@ namespace funcpp {
   struct _some {
     /// @brief Reproduces `A`
     using type = A;
+    /// @brief A value of type `A`
+    type value;
+
+    friend bool operator==(_some a, _some b) = default;
+
+    friend auto operator==(_some s, type a) {
+      return s.value == a;
+    }
+
+    friend auto operator==(type a, _some s) {
+      return a == s.value;
+    }
   };
   /// @endcond
 

src/funcpp.cc

@@ -6,6 +6,7 @@
 export module funcpp;
 export import :common;
 export import :list;
+export import :maybe;
 
 /**
  * @brief Functional C++

test/maybe.cc

@@ -0,0 +1,71 @@
+import funcpp;
+
+using namespace funcpp;
+
+template<typename A>
+class maybe_var {
+  using n_type = typename nothing::type;
+  using s_type = typename some<A>::type;
+  enum {is_n, is_s} d = is_n;
+  union {n_type n; s_type s;};
+
+public:
+  maybe_var() : d{is_n} {
+  }
+
+  maybe_var(A a) : d{is_s}, s{a} {
+  }
+
+  ~maybe_var() {
+    if (d == is_s) s.~s_type();
+  }
+
+  operator bool() {
+    return d == is_s;
+  }
+
+  friend bool operator==(maybe_var m, maybe_var n) {
+    if (m.d == is_n) return n.d == is_n;
+    return n.d == is_s and m.s == n.s;
+  }
+
+  friend bool operator==(maybe_var m, A a) {
+    return m.d == is_s and m.s == a;
+  }
+
+  friend bool operator==(A a, maybe_var m) {
+    return m.d == is_s and a == m.s;
+  }
+
+  template<template<typename> typename F, typename... Args>
+  friend auto invoke(F<A> f, maybe_var m, Args&&...args) {
+    return m ? f(m.s, args...) : f(m.n, args...);
+  }
+};
+
+template<typename A>
+struct maybe_is7 {
+  bool operator()(nothing::type) { return false; }
+  bool operator()(some<A>::type s) { return s == 7; }
+};
+
+template<typename A>
+bool is7(maybe_var<A> m) {
+  return invoke(maybe_is7<A>{}, m);
+}
+
+int main() {
+  maybe_var<int> none;
+  maybe_var<int> some = 0;
+  int err = 0;
+  ++err; if (none) return err;
+  ++err; if (!some) return err;
+  ++err; if (some != 0) return err;
+  some = 7;
+  ++err; if (some != 7) return err;
+  ++err; if (!is7(some)) return err;
+  ++err; if (some == none) return err;
+  some = {};
+  ++err; if (some != none) return err;
+  return 0;
+}