From a66c2a07491257a226440cca51b53079c3d8f3f1 Mon Sep 17 00:00:00 2001
From: dfsek <dfsek@dfsek.com>
Date: Fri, 2 Jan 2026 17:12:30 -0700
Subject: [PATCH] Implement Monad Lazy

---
 .../dfsek/terra/api/util/generic/Lazy.java    | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java
index c9adddf1e..01aa65a01 100644
--- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java
+++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java
@@ -7,13 +7,21 @@
 
 package com.dfsek.terra.api.util.generic;
 
+import com.dfsek.terra.api.util.generic.control.Monad;
+import com.dfsek.terra.api.util.generic.data.Functor;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 
-public final class Lazy<T> {
+public final class Lazy<T> implements Monad<T, Lazy<?>> {
     private final Supplier<T> valueSupplier;
-    private T value;
-    private boolean got = false;
+    private volatile T value = null;
+    private final AtomicBoolean got = new AtomicBoolean(false);
 
     private Lazy(Supplier<T> valueSupplier) {
         this.valueSupplier = valueSupplier;
@@ -24,10 +32,24 @@ public final class Lazy<T> {
     }
 
     public T value() {
-        if(!got && value == null) {
-            got = true;
+        if(!got.compareAndExchange(false, true)) {
             value = valueSupplier.get();
         }
         return value;
     }
+
+    @Override
+    public @NotNull <T2> Lazy<T2> bind(@NotNull Function<T, Monad<T2, Lazy<?>>> map) {
+        return lazy(() -> ((Lazy<T2>) map.apply(value())).value());
+    }
+
+    @Override
+    public @NotNull <U> Lazy<U> map(@NotNull Function<T, U> map) {
+        return (Lazy<U>) Monad.super.map(map);
+    }
+
+    @Override
+    public @NotNull <T1> Lazy<T1> pure(@NotNull T1 t) {
+        return new Lazy<>(() -> t);
+    }
 }