From f03f39f1d7d245ade29bb8c0876c8a0b9e92f11b Mon Sep 17 00:00:00 2001
From: dfsek <dfsek@dfsek.com>
Date: Mon, 29 Dec 2025 17:05:18 -0700
Subject: [PATCH] implement Monad (Maybe a)

---
 .../terra/api/util/generic/control/Monad.java |  4 +--
 .../api/util/generic/data/types/Maybe.java    | 27 ++++++++++++++++++-
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/control/Monad.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/control/Monad.java
index dda469b54..29ae017c0 100644
--- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/control/Monad.java
+++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/control/Monad.java
@@ -10,9 +10,9 @@ import java.util.function.Function;
  * A monad is a monoid in the category of endofunctors.
  */
 public interface Monad<T, M extends Monad<?, M>> extends Functor<T, M>, K<M, T> {
-    <T2, M2 extends Monad<?, M2>> Monad<T2, M2> bind(Function<T, Monad<T2, M2>> map);
+    <T2> Monad<T2, M> bind(Function<T, Monad<T2, M>> map);
 
-    <T1, M1 extends Monad<?, M1>> Monad<T1, M1> pure(T1 t);
+    <T1> Monad<T1, M> pure(T1 t);
 
     @Override
     default <U> Monad<U, M> map(Function<T, U> map) {
diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/data/types/Maybe.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/data/types/Maybe.java
index 5973ef04c..5bce277fe 100644
--- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/data/types/Maybe.java
+++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/data/types/Maybe.java
@@ -6,19 +6,44 @@ import java.util.Optional;
 import java.util.function.Function;
 
 
-public interface Maybe<T>{
+public interface Maybe<T> extends Monad<T, Maybe<?>> {
+    @Override
+    default <T1> Maybe<T1> pure(T1 t) {
+        return just(t);
+    }
+
+    @Override
+    <T2> Maybe<T2> bind(Function<T, Monad<T2, Maybe<?>>> map);
 
     Optional<T> toOptional();
 
+    static <T1> Maybe<T1> just(T1 t) {
+        return new Just<>(t);
+    }
+
+    static <T1> Maybe<T1> nothing() {
+        return new Nothing<>();
+    }
+
     record Just<T>(T value) implements Maybe<T> {
 
         @Override
         public Optional<T> toOptional() {
             return Optional.of(value);
         }
+
+        @Override
+        public <T2> Maybe<T2> bind(Function<T, Monad<T2, Maybe<?>>> map) {
+            return (Maybe<T2>) map.apply(value);
+        }
     }
     record Nothing<T>() implements Maybe<T> {
 
+        @Override
+        public <T2> Maybe<T2> bind(Function<T, Monad<T2, Maybe<?>>> map) {
+            return nothing();
+        }
+
         @Override
         public Optional<T> toOptional() {
             return Optional.empty();