feat: Added async Scopes

Author: julian-siebert

src/main/java/gentle/async/AsyncError.java

@@ -0,0 +1,16 @@
+package gentle.async;
+
+import gentle.Error;
+import lombok.NonNull;
+
+public record AsyncError(@NonNull Throwable throwable) implements Error {
+    @Override
+    public int code() {
+        return 1;
+    }
+
+    @Override
+    public @NonNull String message() {
+        return throwable.getMessage();
+    }
+}

src/main/java/gentle/async/Scope.java

@@ -0,0 +1,66 @@
+package gentle.async;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+public final class Scope implements AutoCloseable {
+    private final ExecutorService executor;
+    private final List<Task<?>> tasks = new ArrayList<>();
+    private volatile boolean closed = false;
+
+    public static Scope open() {
+        return new Scope(Executors.newCachedThreadPool());
+    }
+
+    public static Scope open(@NonNull ExecutorService executor) {
+        return new Scope(executor);
+    }
+
+    public synchronized <T> Task<T> async(@NonNull Callable<T> supplier) {
+        if (closed) throw new IllegalStateException("Scope already closed");
+        Task<T> task = new Task<>(executor.submit(supplier));
+        tasks.add(task);
+        return task;
+    }
+
+    public synchronized int size() {
+        return tasks.size();
+    }
+
+    @Override
+    public void close() throws Exception {
+        List<Throwable> errors = new ArrayList<>();
+        synchronized (this) {
+            closed = true;
+            for (var t : tasks) {
+                try {
+                    t.cancel();
+                } catch (Throwable ex) {
+                    errors.add(ex);
+                }
+            }
+            executor.shutdownNow();
+        }
+        if (errors.isEmpty()) return;
+        var primary = errors.getFirst();
+        for (int i = 1; i < errors.size(); i++) {
+            primary.addSuppressed(errors.get(i));
+        }
+        if (primary instanceof Exception e) throw e;
+        if (primary instanceof Error err) throw err;
+        throw new RuntimeException(primary);
+    }
+
+    @Override
+    public String toString() {
+        return "Scope[size=" + size() + ", closed=" + closed + "]";
+    }
+}

src/main/java/gentle/async/Task.java

@@ -0,0 +1,50 @@
+package gentle.async;
+
+import gentle.Result;
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.function.Function;
+
+import static gentle.Result.err;
+import static gentle.Result.ok;
+
+@RequiredArgsConstructor (access = AccessLevel.PACKAGE)
+public final class Task<T> {
+    private final Future<T> future;
+
+    public void cancel() {
+        future.cancel(true);
+    }
+
+    public boolean isCancelled() {
+        return future.isCancelled();
+    }
+
+    public boolean isDone() {
+        return future.isDone();
+    }
+
+    public Result<T, AsyncError> await() {
+        try {
+            return ok(future.get());
+        } catch (CancellationException | ExecutionException exception) {
+            return err(new AsyncError(exception));
+        } catch (InterruptedException exception) {
+            Thread.currentThread().interrupt();
+            return err(new AsyncError(exception));
+        }
+    }
+
+    public <U> Result<U, AsyncError> map(@NonNull Function<? super T, ? extends U> f) {
+        return await().map(f);
+    }
+
+    public <U> Result<U, AsyncError> flatMap(@NonNull Function<? super T, ? extends Result<U, AsyncError>> f) {
+        return await().flatMap(f);
+    }
+}