Revamp results to support value returns

src/main/java/com/onarandombox/MultiverseCore/commands/CloneCommand.java

@@ -73,12 +73,12 @@ public class CloneCommand extends MultiverseCommand {
                 .keepWorldConfig(!parsedFlags.hasFlag("--reset-world-config"))
                 .keepGameRule(!parsedFlags.hasFlag("--reset-gamerules"))
                 .keepWorldBorder(!parsedFlags.hasFlag("--reset-world-border"))
-        ).onSuccess((success) -> {
+        ).onSuccess(success -> {
             Logging.fine("World remove success: " + success);
-            issuer.sendInfo(success.getReasonMessage());
+            issuer.sendInfo(success.getMessage());
-        }).onFailure((failure) -> {
+        }).onFailure(failure -> {
             Logging.fine("World remove failure: " + failure);
-            issuer.sendError(failure.getReasonMessage());
+            issuer.sendError(failure.getMessage());
         });
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/CreateCommand.java

@@ -104,12 +104,12 @@ public class CreateCommand extends MultiverseCommand {
                 .useSpawnAdjust(!parsedFlags.hasFlag("--no-adjust-spawn"))
                 .generator(parsedFlags.flagValue("--generator", "", String.class))
                 .generateStructures(!parsedFlags.hasFlag("--no-structures"))
-        ).onSuccess((success) -> {
+        ).onSuccess(success -> {
             Logging.fine("World create success: " + success);
-            issuer.sendInfo(success.getReasonMessage());
+            issuer.sendInfo(success.getMessage());
-        }).onFailure((failure) -> {
+        }).onFailure(failure -> {
             Logging.fine("World create failure: " + failure);
-            issuer.sendError(failure.getReasonMessage());
+            issuer.sendError(failure.getMessage());
         });
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/DeleteCommand.java

@@ -49,14 +49,18 @@ public class DeleteCommand extends MultiverseCommand {
                 issuer.getIssuer(),
                 () -> {
                     issuer.sendInfo(MVCorei18n.DELETE_DELETING, "{world}", worldName);
-                    worldManager.deleteWorld(worldName)
+                    try {
-                            .onSuccess((success) -> {
+                        worldManager.deleteWorld(worldName)
-                                Logging.fine("World delete success: " + success);
+                                .onSuccess(success -> {
-                                issuer.sendInfo(success.getReasonMessage());
+                                    Logging.fine("World delete success: " + success);
-                            }).onFailure((failure) -> {
+                                    issuer.sendInfo(success.getMessage());
-                                Logging.fine("World delete failure: " + failure);
+                                }).onFailure(failure -> {
-                                issuer.sendError(failure.getReasonMessage());
+                                    Logging.fine("World delete failure: " + failure);
-                            });
+                                    issuer.sendError(failure.getMessage());
+                                });
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
                 },
                 this.commandManager.formatMessage(
                         issuer,

src/main/java/com/onarandombox/MultiverseCore/commands/ImportCommand.java

@@ -79,12 +79,12 @@ public class ImportCommand extends MultiverseCommand {
                 .environment(environment)
                 .generator(parsedFlags.flagValue("--generator", String.class))
                 .useSpawnAdjust(parsedFlags.hasFlag("--adjust-spawn"))
-        ).onSuccess((success) -> {
+        ).onSuccess(success -> {
             Logging.fine("World create success: " + success);
-            issuer.sendInfo(success.getReasonMessage());
+            issuer.sendInfo(success.getMessage());
-        }).onFailure((failure) -> {
+        }).onFailure(failure -> {
             Logging.fine("World create failure: " + failure);
-            issuer.sendError(failure.getReasonMessage());
+            issuer.sendError(failure.getMessage());
         });
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/LoadCommand.java

@@ -45,12 +45,12 @@ public class LoadCommand extends MultiverseCommand {
     ) {
         issuer.sendInfo(MVCorei18n.LOAD_LOADING, "{world}", worldName);
         worldManager.loadWorld(worldName)
-                .onSuccess((success) -> {
+                .onSuccess(success -> {
                     Logging.fine("World load success: " + success);
-                    issuer.sendInfo(success.getReasonMessage());
+                    issuer.sendInfo(success.getMessage());
-                }).onFailure((failure) -> {
+                }).onFailure(failure -> {
                     Logging.fine("World load failure: " + failure);
-                    issuer.sendError(failure.getReasonMessage());
+                    issuer.sendError(failure.getMessage());
                 });
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/RegenCommand.java

@@ -85,12 +85,12 @@ public class RegenCommand extends MultiverseCommand {
                             .keepWorldConfig(!parsedFlags.hasFlag("--reset-world-config"))
                             .keepGameRule(!parsedFlags.hasFlag("--reset-gamerules"))
                             .keepWorldBorder(!parsedFlags.hasFlag("--reset-world-border"))
-                    ).onSuccess((success) -> {
+                    ).onSuccess(success -> {
                         Logging.fine("World create success: " + success);
-                        issuer.sendInfo(success.getReasonMessage());
+                        issuer.sendInfo(success.getMessage());
-                    }).onFailure((failure) -> {
+                    }).onFailure(failure -> {
                         Logging.fine("World create failure: " + failure);
-                        issuer.sendError(failure.getReasonMessage());
+                        issuer.sendError(failure.getMessage());
                     });
                 },
                 this.commandManager.formatMessage(

src/main/java/com/onarandombox/MultiverseCore/commands/RemoveCommand.java

@@ -43,12 +43,12 @@ public class RemoveCommand extends MultiverseCommand {
                                 String worldName
     ) {
         worldManager.removeWorld(worldName)
-                .onSuccess((success) -> {
+                .onSuccess(success -> {
                     Logging.fine("World remove success: " + success);
-                    issuer.sendInfo(success.getReasonMessage());
+                    issuer.sendInfo(success.getMessage());
-                }).onFailure((failure) -> {
+                }).onFailure(failure -> {
                     Logging.fine("World remove failure: " + failure);
-                    issuer.sendError(failure.getReasonMessage());
+                    issuer.sendError(failure.getMessage());
                 });
     }
 }

src/main/java/com/onarandombox/MultiverseCore/commands/UnloadCommand.java

@@ -42,12 +42,12 @@ public class UnloadCommand extends MultiverseCommand {
     ) {
         issuer.sendInfo(MVCorei18n.UNLOAD_UNLOADING, "{world}", world.getAlias());
         worldManager.unloadWorld(world)
-                .onSuccess((success) -> {
+                .onSuccess(success -> {
                     Logging.fine("World unload success: " + success);
-                    issuer.sendInfo(success.getReasonMessage());
+                    issuer.sendInfo(success.getMessage());
-                }).onFailure((failure) -> {
+                }).onFailure(failure -> {
                     Logging.fine("World unload failure: " + failure);
-                    issuer.sendError(failure.getReasonMessage());
+                    issuer.sendError(failure.getMessage());
                 });
     }
 }

src/main/java/com/onarandombox/MultiverseCore/utils/result/Result.java

@@ -2,120 +2,189 @@ package com.onarandombox.MultiverseCore.utils.result;
 
 import com.onarandombox.MultiverseCore.utils.message.Message;
 import com.onarandombox.MultiverseCore.utils.message.MessageReplacement;
-import org.jetbrains.annotations.NotNull;
 
-import java.util.NoSuchElementException;
-import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
-public sealed interface Result<S extends SuccessReason, F extends FailureReason> permits Result.Success, Result.Failure {
+public interface Result<T, S extends SuccessReason, F extends FailureReason> {
-    static <F extends FailureReason, S extends SuccessReason> Result<S, F> success() {
+
-        return new Success<>(null, Message.of("Success!"));
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> success() {
+        return new Success<>(null, null, Message.of("Success!"));
     }
 
-    static <F extends FailureReason, S extends SuccessReason> Result<S, F> success(S successReason, MessageReplacement...replacements) {
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> success(
-        return new Success<>(successReason, replacements);
+            S successReason, MessageReplacement... messageReplacements) {
+        return new Success<>(null, successReason, Message.of(successReason, "Success!", messageReplacements));
     }
 
-    static <F extends FailureReason, S extends SuccessReason> Result<S, F> success(S successReason, Message message) {
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> success(
-        return new Success<>(successReason, message);
+            S successReason, Message message) {
+        return new Success<>(null, successReason, message);
     }
 
-    static <F extends FailureReason, S extends SuccessReason> Result<S, F> failure() {
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> successValue(T value) {
+        return new Success<>(value, null, Message.of("Success!"));
+    }
+
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> successValue(
+            T value, S successReason, MessageReplacement... messageReplacements) {
+        return new Success<>(value, successReason, Message.of(successReason, "Success!", messageReplacements));
+    }
+
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> successValue(
+            T value, S successReason, Message message) {
+        return new Success<>(value, successReason, message);
+    }
+
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> failure() {
         return new Failure<>(null, Message.of("Failed!"));
     }
 
-    static <F extends FailureReason, S extends SuccessReason> Result<S, F> failure(F failureReason, MessageReplacement...replacements) {
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> failure(
-        return new Failure<>(failureReason, replacements);
+            F failureReason, MessageReplacement... messageReplacements) {
+        return new Failure<>(failureReason, Message.of(failureReason, "Failed!", messageReplacements));
     }
 
-    static <F extends FailureReason, S extends SuccessReason> Result<S, F> failure(F failureReason, Message message) {
+    static <T, S extends SuccessReason, F extends FailureReason> Result<T, S, F> failure(
+            F failureReason, Message message) {
         return new Failure<>(failureReason, message);
     }
-    boolean isSuccess();
 
-    boolean isFailure();
+    T getValue();
 
     S getSuccessReason();
 
     F getFailureReason();
 
-    @NotNull Message getReasonMessage();
+    Message getMessage();
 
-    default Result<S, F> onSuccess(Consumer<Success<F, S>> consumer) {
+    default boolean isSuccess() {
+        return this instanceof Success;
+    }
+
+    default boolean isFailure() {
+        return this instanceof Failure;
+    }
+
+    default Result<T, S, F> peek(Consumer<T> consumer) {
         if (this instanceof Success) {
-            consumer.accept((Success<F, S>) this);
+            consumer.accept(getValue());
         }
         return this;
     }
 
-    default Result<S, F> onFailure(Consumer<Failure<S, F>> consumer) {
+    default <N> Result<N, S, F> map(Function<Success<T, S, F>, Result<N, S, F>> mapper) {
-        if (this instanceof Failure) {
-            consumer.accept((Failure<S, F>) this);
-        }
-        return this;
-    }
-
-    default Result<S, F> onSuccessReason(S successReason, Consumer<S> consumer) {
-        if (this.isSuccess() && this.getSuccessReason() == successReason) {
-            consumer.accept(this.getSuccessReason());
-        }
-        return this;
-    }
-
-    default Result<S, F> onFailureReason(F failureReason, Consumer<F> consumer) {
-        if (this.isFailure() && this.getFailureReason() == failureReason) {
-            consumer.accept(this.getFailureReason());
-        }
-        return this;
-    }
-
-    default Result<S, F> onSuccessThen(Function<Success<F, S>, Result<S, F>> function) {
         if (this instanceof Success) {
-            return function.apply((Success<F, S>) this);
+            return mapper.apply((Success<T, S, F>) this);
+        } else {
+            return new Failure<>(getFailureReason(), getMessage());
+        }
+    }
+
+    default <N> Result<N, S, F> map(Supplier<Result<N, S, F>> mapper) {
+        if (this instanceof Success) {
+            return mapper.get();
+        } else {
+            return new Failure<>(getFailureReason(), getMessage());
+        }
+    }
+
+    default <N> Result<N, S, F> mapValue(Function<T, Result<N, S, F>> mapper) {
+        if (this instanceof Success) {
+            return mapper.apply(this.getValue());
+        } else {
+            return new Failure<>(getFailureReason(), getMessage());
+        }
+    }
+
+    default <NS extends SuccessReason, NF extends FailureReason> Result<T, NS, NF> convertReason(
+            NS success, NF failure) {
+        if (this instanceof Success) {
+            return new Success<>(getValue(), success, getMessage());
+        } else {
+            return new Failure<>(failure, getMessage());
+        }
+    }
+
+    default <N> N fold(Function<Failure<T, S, F>, N> failureMapper, Function<Success<T, S, F>, N> successMapper) {
+        if (this instanceof Success) {
+            return successMapper.apply((Success<T, S, F>) this);
+        } else {
+            return failureMapper.apply((Failure<T, S, F>) this);
+        }
+    }
+
+    default Result<T, S, F> onSuccess(Runnable runnable) {
+        if (this instanceof Success) {
+            runnable.run();
         }
         return this;
     }
 
-    default Result<S, F> onFailureThen(Function<Failure<S, F>, Result<S, F>> function) {
+    default Result<T, S, F> onSuccess(Consumer<Success<T, S, F>> consumer) {
-        if (this instanceof Failure) {
+        if (this instanceof Success) {
-            return function.apply((Failure<S, F>) this);
+            consumer.accept((Success<T, S, F>) this);
         }
         return this;
     }
 
-    default <R> R fold(Function<Failure<S, F>, R> failureFunc, Function<Success<F, S>, R> successFunc) {
+    default Result<T, S, F> onSuccessReason(S successReason, Runnable runnable) {
-        if (this instanceof Failure) {
+        if (this instanceof Success && this.getSuccessReason() == successReason) {
-            return failureFunc.apply((Failure<S, F>) this);
+            runnable.run();
-        } else if (this instanceof Success) {
-            return successFunc.apply((Success<F, S>) this);
         }
-        throw new IllegalStateException("Unknown result type: " + this.getClass().getName());
+        return this;
     }
 
-    final class Success<F extends FailureReason, S extends SuccessReason> implements Result<S, F> {
+    default Result<T, S, F> onSuccessValue(Consumer<T> consumer) {
+        if (this instanceof Success) {
+            consumer.accept(getValue());
+        }
+        return this;
+    }
+
+    default Result<T, S, F> onSuccessReason(Consumer<S> consumer) {
+        if (this instanceof Success) {
+            consumer.accept(getSuccessReason());
+        }
+        return this;
+    }
+
+    default Result<T, S, F> onFailure(Runnable runnable) {
+        if (this instanceof Failure) {
+            runnable.run();
+        }
+        return this;
+    }
+
+    default Result<T, S, F> onFailure(Consumer<Failure<T, S, F>> consumer) {
+        if (this instanceof Failure) {
+            consumer.accept((Failure<T, S, F>) this);
+        }
+        return this;
+    }
+
+    default Result<T, S, F> onFailureReason(Consumer<F> consumer) {
+        if (this instanceof Failure) {
+            consumer.accept(getFailureReason());
+        }
+        return this;
+    }
+
+    class Success<T, S extends SuccessReason, F extends FailureReason> implements Result<T, S, F> {
+        private final T value;
         private final S successReason;
         private final Message message;
 
-        public Success(S successReason, Message message) {
+        Success(T value, S successReason, Message message) {
+            this.value = value;
             this.successReason = successReason;
             this.message = message;
         }
 
-        public Success(S successReason, MessageReplacement[] replacements) {
-            this.successReason = successReason;
-            this.message = Message.of(successReason, "Success!", replacements);
-        }
-
         @Override
-        public boolean isSuccess() {
+        public T getValue() {
-            return true;
+            return value;
-        }
-
-        @Override
-        public boolean isFailure() {
-            return false;
         }
 
         @Override
@@ -125,49 +194,40 @@ public sealed interface Result<S extends SuccessReason, F extends FailureReason>
 
         @Override
         public F getFailureReason() {
-            throw new NoSuchElementException("No reason for failure");
+            return null;
         }
 
         @Override
-        public @NotNull Message getReasonMessage() {
+        public Message getMessage() {
             return message;
         }
 
         @Override
         public String toString() {
-            return "Success{" +
+            return "Success{"
-                    "reason=" + successReason +
+                    + "reason=" + successReason + ", "
-                    '}';
+                    + "value=" + value
+                    + '}';
         }
     }
 
-    final class Failure<S extends SuccessReason, F extends FailureReason> implements Result<S, F> {
+    class Failure<T, S extends SuccessReason, F extends FailureReason> implements Result<T, S, F> {
         private final F failureReason;
         private final Message message;
 
-        public Failure(F failureReason, Message message) {
+        Failure(F failureReason, Message message) {
             this.failureReason = failureReason;
             this.message = message;
         }
 
-        public Failure(F failureReason, MessageReplacement[] replacements) {
-            this.failureReason = failureReason;
-            this.message = Message.of(failureReason, "Success!", replacements);
-        }
-
         @Override
-        public boolean isSuccess() {
+        public T getValue() {
-            return false;
+            return null;
-        }
-
-        @Override
-        public boolean isFailure() {
-            return true;
         }
 
         @Override
         public S getSuccessReason() {
-            throw new NoSuchElementException("No reason for failure");
+            return null;
         }
 
         @Override
@@ -176,15 +236,15 @@ public sealed interface Result<S extends SuccessReason, F extends FailureReason>
         }
 
         @Override
-        public @NotNull Message getReasonMessage() {
+        public Message getMessage() {
             return message;
         }
 
         @Override
         public String toString() {
-            return "Failure{" +
+            return "Failure{"
-                    "reason=" + failureReason +
+                    + "reason=" + failureReason
-                    '}';
+                    + '}';
         }
     }
 }

src/main/java/com/onarandombox/MultiverseCore/utils/result/ResultChain.java

@@ -21,9 +21,9 @@ public class ResultChain {
     }
 
     private final boolean isSuccess;
-    private final List<Result<?, ?>> results;
+    private final List<Result<?, ?, ?>> results;
 
-    ResultChain(boolean isSuccess, List<Result<?, ?>> results) {
+    ResultChain(boolean isSuccess, List<Result<?, ?, ?>> results) {
         this.isSuccess = isSuccess;
         this.results = results;
     }
@@ -102,7 +102,7 @@ public class ResultChain {
     }
 
     public Message getLastResultMessage() {
-        return Iterables.getLast(results).getReasonMessage();
+        return Iterables.getLast(results).getMessage();
     }
 
     @Override
@@ -115,7 +115,7 @@ public class ResultChain {
 
     public static class Builder {
         private final boolean stopOnFailure;
-        private final List<Result<?, ?>> results;
+        private final List<Result<?, ?, ?>> results;
 
         private boolean isSuccess = true;
 
@@ -124,11 +124,11 @@ public class ResultChain {
             this.results = new ArrayList<>();
         }
 
-        public Builder then(Supplier<Result<?, ?>> resultSupplier) {
+        public Builder then(Supplier<Result<?, ?, ?>> resultSupplier) {
             if (!isSuccess && stopOnFailure) {
                 return this;
             }
-            Result<?, ?> result = resultSupplier.get();
+            Result<?, ?, ?> result = resultSupplier.get();
             if (result.isFailure()) {
                 isSuccess = false;
             }

src/main/java/com/onarandombox/MultiverseCore/worldnew/WorldManager.java

@@ -47,6 +47,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
 
 import static com.onarandombox.MultiverseCore.utils.message.MessageReplacement.replace;
 import static com.onarandombox.MultiverseCore.worldnew.helpers.DataStore.WorldBorderStore;
@@ -169,25 +170,22 @@ public class WorldManager {
      * @param options   The options for customizing the creation of a new world.
      * @return The result of the creation.
      */
-    public Result<CreateWorldResult.Success, CreateWorldResult.Failure> createWorld(CreateWorldOptions options) {
+    public Result<LoadedMultiverseWorld, CreateWorldResult.Success, CreateWorldResult.Failure> createWorld(CreateWorldOptions options) {
-        return invalidateCreateWorldOptions(options).getOrElse(() -> createValidatedWorld(options));
+        return validateCreateWorldOptions(options).mapValue(this::createValidatedWorld);
     }
 
-    private Option<Result<CreateWorldResult.Success, CreateWorldResult.Failure>> invalidateCreateWorldOptions(
+    private Result<CreateWorldOptions, CreateWorldResult.Success, CreateWorldResult.Failure> validateCreateWorldOptions(
             CreateWorldOptions options) {
-        Result<CreateWorldResult.Success, CreateWorldResult.Failure> result = null;
-
         if (!worldNameChecker.isValidWorldName(options.worldName())) {
-            result = worldActionResult(CreateWorldResult.Failure.INVALID_WORLDNAME, options.worldName());
+            return worldActionResult(CreateWorldResult.Failure.INVALID_WORLDNAME, options.worldName());
         } else if (getLoadedWorld(options.worldName()).isDefined()) {
-            result = worldActionResult(CreateWorldResult.Failure.WORLD_EXIST_LOADED, options.worldName());
+            return worldActionResult(CreateWorldResult.Failure.WORLD_EXIST_LOADED, options.worldName());
         } else if (getWorld(options.worldName()).isDefined()) {
-            result = worldActionResult(CreateWorldResult.Failure.WORLD_EXIST_UNLOADED, options.worldName());
+            return worldActionResult(CreateWorldResult.Failure.WORLD_EXIST_UNLOADED, options.worldName());
         } else if (hasWorldFolder(options.worldName())) {
-            result = worldActionResult(CreateWorldResult.Failure.WORLD_EXIST_FOLDER, options.worldName());
+            return worldActionResult(CreateWorldResult.Failure.WORLD_EXIST_FOLDER, options.worldName());
         }
-
+        return Result.successValue(options);
-        return Option.of(result);
     }
 
     private boolean hasWorldFolder(String worldName) {
@@ -195,21 +193,25 @@ public class WorldManager {
         return worldFolder.exists();
     }
 
-    private Result<CreateWorldResult.Success, CreateWorldResult.Failure> createValidatedWorld(
+    private Result<LoadedMultiverseWorld, CreateWorldResult.Success, CreateWorldResult.Failure> createValidatedWorld(
             CreateWorldOptions options) {
         String parsedGenerator = parseGenerator(options.worldName(), options.generator());
-        return createBukkitWorld(WorldCreator.name(options.worldName())
+        WorldCreator worldCreator = WorldCreator.name(options.worldName())
                 .environment(options.environment())
                 .generateStructures(options.generateStructures())
                 .generator(parsedGenerator)
                 .seed(options.seed())
-                .type(options.worldType())).fold(
+                .type(options.worldType());
-                        exception -> worldActionResult(CreateWorldResult.Failure.BUKKIT_CREATION_FAILED,
+        return createBukkitWorld(worldCreator).fold(
-                                options.worldName(), exception.getMessage()),
+                exception -> worldActionResult(CreateWorldResult.Failure.BUKKIT_CREATION_FAILED,
-                        world -> {
+                        options.worldName(), exception),
-                            newLoadedMultiverseWorld(world, parsedGenerator, options.useSpawnAdjust());
+                world -> {
-                            return worldActionResult(CreateWorldResult.Success.CREATED, world.getName());
+                    LoadedMultiverseWorld loadedWorld = newLoadedMultiverseWorld(
-                        });
+                            world,
+                            parsedGenerator,
+                            options.useSpawnAdjust());
+                    return worldActionResult(loadedWorld, CreateWorldResult.Success.CREATED, world.getName());
+                });
     }
 
     /**
@@ -218,39 +220,41 @@ public class WorldManager {
      * @param options   The options for customizing the import of an existing world folder.
      * @return The result of the import.
      */
-    public Result<ImportWorldResult.Success, ImportWorldResult.Failure> importWorld(ImportWorldOptions options) {
+    public Result<LoadedMultiverseWorld, ImportWorldResult.Success, ImportWorldResult.Failure> importWorld(
-        return invalidateImportWorldOptions(options).getOrElse(() -> importValidatedWorld(options));
-    }
-
-    private Option<Result<ImportWorldResult.Success, ImportWorldResult.Failure>> invalidateImportWorldOptions(
             ImportWorldOptions options) {
-        Result<ImportWorldResult.Success, ImportWorldResult.Failure> result = null;
+        return validateImportWorldOptions(options).mapValue(this::doImportWorld);
-
-        if (!worldNameChecker.isValidWorldName(options.worldName())) {
-            result = worldActionResult(ImportWorldResult.Failure.INVALID_WORLDNAME, options.worldName());
-        } else if (!worldNameChecker.isValidWorldFolder(options.worldName())) {
-            result = worldActionResult(ImportWorldResult.Failure.WORLD_FOLDER_INVALID, options.worldName());
-        } else if (isLoadedWorld(options.worldName())) {
-            result = worldActionResult(ImportWorldResult.Failure.WORLD_EXIST_LOADED, options.worldName());
-        } else if (isWorld(options.worldName())) {
-            result = worldActionResult(ImportWorldResult.Failure.WORLD_EXIST_UNLOADED, options.worldName());
-        }
-
-        return Option.of(result);
     }
 
-    private Result<ImportWorldResult.Success, ImportWorldResult.Failure> importValidatedWorld(
+    private Result<ImportWorldOptions, ImportWorldResult.Success, ImportWorldResult.Failure> validateImportWorldOptions(
+            ImportWorldOptions options) {
+        String worldName = options.worldName();
+        if (!worldNameChecker.isValidWorldName(worldName)) {
+            return worldActionResult(ImportWorldResult.Failure.INVALID_WORLDNAME, worldName);
+        } else if (!worldNameChecker.isValidWorldFolder(worldName)) {
+            return worldActionResult(ImportWorldResult.Failure.WORLD_FOLDER_INVALID, worldName);
+        } else if (isLoadedWorld(worldName)) {
+            return worldActionResult(ImportWorldResult.Failure.WORLD_EXIST_LOADED, worldName);
+        } else if (isWorld(worldName)) {
+            return worldActionResult(ImportWorldResult.Failure.WORLD_EXIST_UNLOADED, worldName);
+        }
+        return Result.successValue(options);
+    }
+
+    private Result<LoadedMultiverseWorld, ImportWorldResult.Success, ImportWorldResult.Failure> doImportWorld(
             ImportWorldOptions options) {
         String parsedGenerator = parseGenerator(options.worldName(), options.generator());
-        return createBukkitWorld(WorldCreator.name(options.worldName())
+        WorldCreator worldCreator = WorldCreator.name(options.worldName())
                 .environment(options.environment())
-                .generator(parsedGenerator)).fold(
+                .generator(parsedGenerator);
-                        exception -> worldActionResult(ImportWorldResult.Failure.BUKKIT_CREATION_FAILED,
+        return createBukkitWorld(worldCreator).fold(
-                                options.worldName(), exception.getMessage()),
+                exception -> worldActionResult(ImportWorldResult.Failure.BUKKIT_CREATION_FAILED,
-                        world -> {
+                        options.worldName(), exception),
-                            newLoadedMultiverseWorld(world, parsedGenerator, options.useSpawnAdjust());
+                world -> {
-                            return worldActionResult(ImportWorldResult.Success.IMPORTED, options.worldName());
+                    LoadedMultiverseWorld loadedWorld = newLoadedMultiverseWorld(world,
-                        });
+                            parsedGenerator,
+                            options.useSpawnAdjust());
+                    return worldActionResult(loadedWorld, ImportWorldResult.Success.IMPORTED, options.worldName());
+                });
     }
 
     /**
@@ -273,7 +277,8 @@ public class WorldManager {
      * @param generator     The generator string.
      * @param adjustSpawn   Whether to adjust spawn.
      */
-    private void newLoadedMultiverseWorld(@NotNull World world, @Nullable String generator, boolean adjustSpawn) {
+    private LoadedMultiverseWorld newLoadedMultiverseWorld(
+            @NotNull World world, @Nullable String generator, boolean adjustSpawn) {
         WorldConfig worldConfig = worldsConfigManager.addWorldConfig(world.getName());
         worldConfig.setAdjustSpawn(adjustSpawn);
         worldConfig.setGenerator(generator == null ? "" : generator);
@@ -289,6 +294,7 @@ public class WorldManager {
                 locationManipulation);
         loadedWorldsMap.put(loadedWorld.getName(), loadedWorld);
         saveWorldsConfig();
+        return loadedWorld;
     }
 
     /**
@@ -297,7 +303,7 @@ public class WorldManager {
      * @param worldName The name of the world to load.
      * @return The result of the load.
      */
-    public Result<LoadWorldResult.Success, LoadWorldResult.Failure> loadWorld(@NotNull String worldName) {
+    public Result<LoadedMultiverseWorld, LoadWorldResult.Success, LoadWorldResult.Failure> loadWorld(@NotNull String worldName) {
         return getWorld(worldName)
                 .map(this::loadWorld)
                 .getOrElse(() -> worldNameChecker.isValidWorldFolder(worldName)
@@ -311,34 +317,32 @@ public class WorldManager {
      * @param mvWorld  The world to load.
      * @return The result of the load.
      */
-    public Result<LoadWorldResult.Success, LoadWorldResult.Failure> loadWorld(@NotNull MultiverseWorld mvWorld) {
+    public Result<LoadedMultiverseWorld, LoadWorldResult.Success, LoadWorldResult.Failure> loadWorld(@NotNull MultiverseWorld mvWorld) {
-        return invalidateWorldToLoad(mvWorld).getOrElse(() -> loadValidatedWorld(mvWorld));
+        return validateWorldToLoad(mvWorld).map(() -> doLoadWorld(mvWorld));
     }
 
-    private Option<Result<LoadWorldResult.Success, LoadWorldResult.Failure>> invalidateWorldToLoad(
+    private Result<Void, LoadWorldResult.Success, LoadWorldResult.Failure> validateWorldToLoad(
             @NotNull MultiverseWorld mvWorld) {
-        Result<LoadWorldResult.Success, LoadWorldResult.Failure> result = null;
-
         if (loadTracker.contains(mvWorld.getName())) {
             // This is to prevent recursive calls by WorldLoadEvent
             Logging.fine("World already loading: " + mvWorld.getName());
-            result = worldActionResult(LoadWorldResult.Failure.WORLD_ALREADY_LOADING, mvWorld.getName());
+            return worldActionResult(LoadWorldResult.Failure.WORLD_ALREADY_LOADING, mvWorld.getName());
         } else if (isLoadedWorld(mvWorld)) {
             Logging.severe("World already loaded: " + mvWorld.getName());
-            result = worldActionResult(LoadWorldResult.Failure.WORLD_EXIST_LOADED, mvWorld.getName());
+            return worldActionResult(LoadWorldResult.Failure.WORLD_EXIST_LOADED, mvWorld.getName());
         }
 
-        return Option.of(result);
+        return Result.success();
     }
 
-    private Result<LoadWorldResult.Success, LoadWorldResult.Failure> loadValidatedWorld(
+    private Result<LoadedMultiverseWorld, LoadWorldResult.Success, LoadWorldResult.Failure> doLoadWorld(
             @NotNull MultiverseWorld mvWorld) {
         return createBukkitWorld(WorldCreator.name(mvWorld.getName())
                 .environment(mvWorld.getEnvironment())
                 .generator(Strings.isNullOrEmpty(mvWorld.getGenerator()) ? null : mvWorld.getGenerator())
                 .seed(mvWorld.getSeed())).fold(
                         exception -> worldActionResult(LoadWorldResult.Failure.BUKKIT_CREATION_FAILED,
-                                mvWorld.getName(), exception.getMessage()),
+                                mvWorld.getName(), exception),
                         world -> {
                             // TODO: Check worldConfig null
                             WorldConfig worldConfig = worldsConfigManager.getWorldConfig(mvWorld.getName());
@@ -350,7 +354,7 @@ public class WorldManager {
                                     locationManipulation);
                             loadedWorldsMap.put(loadedWorld.getName(), loadedWorld);
                             saveWorldsConfig();
-                            return worldActionResult(LoadWorldResult.Success.LOADED, loadedWorld.getName());
+                            return worldActionResult(loadedWorld, LoadWorldResult.Success.LOADED, loadedWorld.getName());
                         });
     }
 
@@ -360,7 +364,7 @@ public class WorldManager {
      * @param world The bukkit world to unload.
      * @return The result of the unload action.
      */
-    public Result<UnloadWorldResult.Success, UnloadWorldResult.Failure> unloadWorld(@NotNull World world) {
+    public Result<MultiverseWorld, UnloadWorldResult.Success, UnloadWorldResult.Failure> unloadWorld(@NotNull World world) {
         return unloadWorld(world.getName());
     }
 
@@ -370,7 +374,7 @@ public class WorldManager {
      * @param worldName The name of the world to unload.
      * @return The result of the unload action.
      */
-    public Result<UnloadWorldResult.Success, UnloadWorldResult.Failure> unloadWorld(@NotNull String worldName) {
+    public Result<MultiverseWorld, UnloadWorldResult.Success, UnloadWorldResult.Failure> unloadWorld(@NotNull String worldName) {
         return getLoadedWorld(worldName)
                 .map(this::unloadWorld)
                 .getOrElse(() -> isUnloadedWorld(worldName)
@@ -384,7 +388,7 @@ public class WorldManager {
      * @param world The multiverse world to unload.
      * @return The result of the unload action.
      */
-    public Result<UnloadWorldResult.Success, UnloadWorldResult.Failure> unloadWorld(
+    public Result<MultiverseWorld, UnloadWorldResult.Success, UnloadWorldResult.Failure> unloadWorld(
             @NotNull LoadedMultiverseWorld world) {
         if (unloadTracker.contains(world.getName())) {
             // This is to prevent recursive calls by WorldUnloadEvent
@@ -396,7 +400,7 @@ public class WorldManager {
 
         return unloadBukkitWorld(world.getBukkitWorld().getOrNull()).fold(
                 exception -> worldActionResult(UnloadWorldResult.Failure.BUKKIT_UNLOAD_FAILED,
-                        world.getName(), exception.getMessage()),
+                        world.getName(), exception),
                 success -> Option.of(loadedWorldsMap.remove(world.getName())).fold(
                         () -> {
                             Logging.severe("Failed to remove world from map: " + world.getName());
@@ -405,7 +409,8 @@ public class WorldManager {
                         mvWorld -> {
                             Logging.fine("Removed MultiverseWorld from map: " + world.getName());
                             mvWorld.getWorldConfig().deferenceMVWorld();
-                            return worldActionResult(UnloadWorldResult.Success.UNLOADED, world.getName());
+                            return worldActionResult(getWorld(mvWorld.getName()).getOrNull(),
+                                    UnloadWorldResult.Success.UNLOADED, world.getName());
                         }));
     }
 
@@ -416,7 +421,7 @@ public class WorldManager {
      * @param worldName The name of the world to remove.
      * @return The result of the remove.
      */
-    public Result<RemoveWorldResult.Success, RemoveWorldResult.Failure> removeWorld(
+    public Result<Void, RemoveWorldResult.Success, RemoveWorldResult.Failure> removeWorld(
             @NotNull String worldName) {
         return getWorld(worldName)
                 .map(this::removeWorld)
@@ -430,7 +435,7 @@ public class WorldManager {
      * @param world The multiverse world to remove.
      * @return The result of the remove.
      */
-    public Result<RemoveWorldResult.Success, RemoveWorldResult.Failure> removeWorld(@NotNull MultiverseWorld world) {
+    public Result<Void, RemoveWorldResult.Success, RemoveWorldResult.Failure> removeWorld(@NotNull MultiverseWorld world) {
         return getLoadedWorld(world).fold(
                 () -> removeWorldFromConfig(world),
                 this::removeWorld);
@@ -443,11 +448,11 @@ public class WorldManager {
      * @param loadedWorld The multiverse world to remove.
      * @return The result of the remove.
      */
-    public Result<RemoveWorldResult.Success, RemoveWorldResult.Failure> removeWorld(
+    public Result<Void, RemoveWorldResult.Success, RemoveWorldResult.Failure> removeWorld(
             @NotNull LoadedMultiverseWorld loadedWorld) {
         var result = unloadWorld(loadedWorld);
         if (result.isFailure()) {
-            return Result.failure(RemoveWorldResult.Failure.UNLOAD_FAILED, result.getReasonMessage());
+            return Result.failure(RemoveWorldResult.Failure.UNLOAD_FAILED, result.getMessage());
         }
         return removeWorldFromConfig(loadedWorld);
     }
@@ -458,14 +463,14 @@ public class WorldManager {
      * @param world The multiverse world to remove.
      * @return The result of the remove.
      */
-    private Result<RemoveWorldResult.Success, RemoveWorldResult.Failure>
+    private Result<Void, RemoveWorldResult.Success, RemoveWorldResult.Failure>
             removeWorldFromConfig(@NotNull MultiverseWorld world) {
         // Remove world from config
         worldsMap.remove(world.getName());
         worldsConfigManager.deleteWorldConfig(world.getName());
         saveWorldsConfig();
 
-        return Result.success(RemoveWorldResult.Success.REMOVED);
+        return worldActionResult(RemoveWorldResult.Success.REMOVED, world.getName());
     }
 
     /**
@@ -475,7 +480,7 @@ public class WorldManager {
      * @param worldName The name of the world to delete.
      * @return The result of the delete action.
      */
-    public Result<DeleteWorldResult.Success, DeleteWorldResult.Failure> deleteWorld(@NotNull String worldName) {
+    public Result<Void, DeleteWorldResult.Success, DeleteWorldResult.Failure> deleteWorld(@NotNull String worldName) {
         return getWorld(worldName)
                 .map(this::deleteWorld)
                 .getOrElse(() -> worldActionResult(DeleteWorldResult.Failure.WORLD_NON_EXISTENT, worldName));
@@ -488,15 +493,11 @@ public class WorldManager {
      * @param world The world to delete.
      * @return The result of the delete action.
      */
-    public Result<DeleteWorldResult.Success, DeleteWorldResult.Failure> deleteWorld(@NotNull MultiverseWorld world) {
+    public Result<Void, DeleteWorldResult.Success, DeleteWorldResult.Failure> deleteWorld(@NotNull MultiverseWorld world) {
         return getLoadedWorld(world).fold(
-                () -> {
+                () -> loadWorld(world)
-                    var result = loadWorld(world);
+                        .convertReason((DeleteWorldResult.Success) null, DeleteWorldResult.Failure.LOAD_FAILED)
-                    if (result.isFailure()) {
+                        .mapValue(this::deleteWorld),
-                        return worldActionResult(DeleteWorldResult.Failure.LOAD_FAILED, world.getName());
-                    }
-                    return deleteWorld(world);
-                },
                 this::deleteWorld);
     }
 
@@ -506,25 +507,27 @@ public class WorldManager {
      * @param world The multiverse world to delete.
      * @return The result of the delete action.
      */
-    public Result<DeleteWorldResult.Success, DeleteWorldResult.Failure>
+    public Result<Void, DeleteWorldResult.Success, DeleteWorldResult.Failure>
             deleteWorld(@NotNull LoadedMultiverseWorld world) {
+        // TODO: Possible config options to keep certain files
+        AtomicReference<File> worldFolder = new AtomicReference<>();
+        return validateWorldToDelete(world)
+                .peek(worldFolder::set)
+                .map(() -> removeWorld(world).convertReason(null, DeleteWorldResult.Failure.REMOVE_FAILED))
+                .map(() -> filesManipulator.deleteFolder(worldFolder.get()).fold(
+                        exception -> worldActionResult(DeleteWorldResult.Failure.FAILED_TO_DELETE_FOLDER,
+                                world.getName(), exception),
+                        success -> worldActionResult(DeleteWorldResult.Success.DELETED, world.getName())));
+    }
+
+    private Result<File, DeleteWorldResult.Success, DeleteWorldResult.Failure> validateWorldToDelete(
+            @NotNull LoadedMultiverseWorld world) {
         File worldFolder = world.getBukkitWorld().map(World::getWorldFolder).getOrNull();
         if (worldFolder == null || !worldNameChecker.isValidWorldFolder(worldFolder)) {
             Logging.severe("Failed to get world folder for world: " + world.getName());
             return worldActionResult(DeleteWorldResult.Failure.WORLD_FOLDER_NOT_FOUND, world.getName());
         }
-
+        return Result.successValue(worldFolder);
-        var result = removeWorld(world);
-        if (result.isFailure()) {
-            return Result.failure(DeleteWorldResult.Failure.REMOVE_FAILED, result.getReasonMessage());
-        }
-
-        // Erase world files from disk
-        // TODO: Possible config options to keep certain files
-        return filesManipulator.deleteFolder(worldFolder).fold(
-                exception -> worldActionResult(DeleteWorldResult.Failure.FAILED_TO_DELETE_FOLDER,
-                        world.getName(), exception.getMessage()),
-                success -> worldActionResult(DeleteWorldResult.Success.DELETED, world.getName()));
     }
 
     /**
@@ -533,29 +536,23 @@ public class WorldManager {
      * @param options   The options for customizing the cloning of a world.
      * @return The result of the clone.
      */
-    public Result<CloneWorldResult.Success, CloneWorldResult.Failure> cloneWorld(@NotNull CloneWorldOptions options) {
+    public Result<LoadedMultiverseWorld, CloneWorldResult.Success, CloneWorldResult.Failure> cloneWorld(@NotNull CloneWorldOptions options) {
         return cloneWorldValidateWorld(options)
-                .onSuccessThen(s -> cloneWorldCopyFolder(options))
+                .mapValue(this::cloneWorldCopyFolder)
-                .onSuccessThen(s -> importWorld(
+                .mapValue(validatedOptions -> {
-                        ImportWorldOptions.worldName(options.newWorldName())
+                    ImportWorldOptions importWorldOptions = ImportWorldOptions.worldName(validatedOptions.newWorldName())
-                                .environment(options.world().getEnvironment())
+                            .environment(validatedOptions.world().getEnvironment())
-                                .generator(options.world().getGenerator()))
+                            .generator(validatedOptions.world().getGenerator());
-                        .fold(
+                    return importWorld(importWorldOptions).convertReason(null, CloneWorldResult.Failure.IMPORT_FAILED);
-                                failure -> Result.failure(CloneWorldResult.Failure.IMPORT_FAILED,
+                })
-                                        failure.getReasonMessage()),
+                .mapValue(newWorld -> {
-                                success -> Result.success()))
+                    cloneWorldTransferData(options, newWorld);
-                .onSuccessThen(s -> getLoadedWorld(options.newWorldName()).fold(
+                    saveWorldsConfig();
-                        () -> worldActionResult(CloneWorldResult.Failure.MV_WORLD_FAILED, options.newWorldName()),
+                    return worldActionResult(CloneWorldResult.Success.CLONED, newWorld.getName());
-                        mvWorld -> {
+                });
-                            cloneWorldTransferData(options, mvWorld);
-                            saveWorldsConfig();
-                            return Result.success(CloneWorldResult.Success.CLONED,
-                                    replaceWorldName(options.world().getName()),
-                                    replace("{newworld}").with(mvWorld.getName()));
-                        }));
     }
 
-    private Result<CloneWorldResult.Success, CloneWorldResult.Failure> cloneWorldValidateWorld(
+    private Result<CloneWorldOptions, CloneWorldResult.Success, CloneWorldResult.Failure> cloneWorldValidateWorld(
             @NotNull CloneWorldOptions options) {
         String newWorldName = options.newWorldName();
         if (!worldNameChecker.isValidWorldName(newWorldName)) {
@@ -573,18 +570,18 @@ public class WorldManager {
             Logging.severe("World already exist unloaded: " + newWorldName);
             return worldActionResult(CloneWorldResult.Failure.WORLD_EXIST_UNLOADED, newWorldName);
         }
-        return Result.success();
+        return Result.successValue(options);
     }
 
-    private Result<CloneWorldResult.Success, CloneWorldResult.Failure> cloneWorldCopyFolder(
+    private Result<CloneWorldOptions, CloneWorldResult.Success, CloneWorldResult.Failure> cloneWorldCopyFolder(
             @NotNull CloneWorldOptions options) {
         // TODO: Check null?
         File worldFolder = options.world().getBukkitWorld().map(World::getWorldFolder).getOrNull();
         File newWorldFolder = new File(Bukkit.getWorldContainer(), options.newWorldName());
         return filesManipulator.copyFolder(worldFolder, newWorldFolder, CLONE_IGNORE_FILES).fold(
-                exception -> worldActionResult(CloneWorldResult.Failure.COPY_FAILED, options.world().getName(),
+                exception -> worldActionResult(CloneWorldResult.Failure.COPY_FAILED,
-                        exception.getMessage()),
+                        options.world().getName(), exception),
-                success -> Result.success());
+                success -> Result.successValue(options));
     }
 
     private void cloneWorldTransferData(@NotNull CloneWorldOptions options, @NotNull LoadedMultiverseWorld newWorld) {
@@ -615,12 +612,11 @@ public class WorldManager {
      * @param options   The options for customizing the regeneration of a world.
      * @return The result of the regeneration.
      */
-    public Result<RegenWorldResult.Success, RegenWorldResult.Failure> regenWorld(@NotNull RegenWorldOptions options) {
+    public Result<LoadedMultiverseWorld, RegenWorldResult.Success, RegenWorldResult.Failure> regenWorld(@NotNull RegenWorldOptions options) {
         // TODO: Teleport players out of world, and back in after regen
+
         LoadedMultiverseWorld world = options.world();
-
         DataTransfer<LoadedMultiverseWorld> dataTransfer = transferData(options, world);
-
         CreateWorldOptions createWorldOptions = CreateWorldOptions.worldName(world.getName())
                 .environment(world.getEnvironment())
                 .generateStructures(world.canGenerateStructures().getOrElse(true))
@@ -628,36 +624,40 @@ public class WorldManager {
                 .seed(options.seed())
                 .worldType(world.getWorldType().getOrElse(WorldType.NORMAL));
 
-        var deleteResult = deleteWorld(world);
+        return deleteWorld(world)
-        if (deleteResult.isFailure()) {
+                .convertReason((RegenWorldResult.Success) null, RegenWorldResult.Failure.DELETE_FAILED)
-            return Result.failure(RegenWorldResult.Failure.DELETE_FAILED, deleteResult.getReasonMessage());
+                .map(() -> createWorld(createWorldOptions).convertReason(null, RegenWorldResult.Failure.CREATE_FAILED))
-        }
+                .mapValue(newWorld -> {
-
+                    dataTransfer.pasteAllTo(newWorld);
-        var createResult = createWorld(createWorldOptions);
+                    saveWorldsConfig();
-        if (createResult.isFailure()) {
+                    return worldActionResult(newWorld, RegenWorldResult.Success.REGENERATED, newWorld.getName());
-            return Result.failure(RegenWorldResult.Failure.CREATE_FAILED, createResult.getReasonMessage());
+                });
-        }
-
-        getLoadedWorld(createWorldOptions.worldName()).peek(newWorld -> {
-            dataTransfer.pasteAllTo(newWorld);
-            saveWorldsConfig();
-        });
-        return worldActionResult(RegenWorldResult.Success.REGENERATED, world.getName());
     }
 
-    private <F extends FailureReason, S extends SuccessReason> Result<S, F> worldActionResult(
+    private <T, F extends FailureReason, S extends SuccessReason> Result<T, S, F> worldActionResult(
             @NotNull S messageKeyProvider, @NotNull String worldName) {
         return Result.success(messageKeyProvider, replaceWorldName(worldName));
     }
 
-    private <F extends FailureReason, S extends SuccessReason> Result<S, F> worldActionResult(
+    private <T, F extends FailureReason, S extends SuccessReason> Result<T, S, F> worldActionResult(
+            @NotNull T value, @NotNull S successReason, @NotNull String worldName) {
+        return Result.successValue(value, successReason, replaceWorldName(worldName));
+    }
+
+    private <T, F extends FailureReason, S extends SuccessReason> Result<T, S, F> worldActionResult(
+            @NotNull F failureReason, @NotNull Result<?, ?, ?> result) {
+        return Result.failure(failureReason, result.getMessage());
+    }
+
+    private <T, F extends FailureReason, S extends SuccessReason> Result<T, S, F> worldActionResult(
             @NotNull F messageKeyProvider, @NotNull String worldName) {
         return Result.failure(messageKeyProvider, replaceWorldName(worldName));
     }
 
-    private <F extends FailureReason, S extends SuccessReason> Result<S, F> worldActionResult(
+    private <T, F extends FailureReason, S extends SuccessReason> Result<T, S, F> worldActionResult(
-            @NotNull F messageKeyProvider, @NotNull String worldName, @NotNull String errorMessage) {
+            @NotNull F messageKeyProvider, @NotNull String worldName, @NotNull Throwable error) {
-        return Result.failure(messageKeyProvider, replaceWorldName(worldName), replaceError(errorMessage));
+        // TODO: Localize error message if its a MultiverseException
+        return Result.failure(messageKeyProvider, replaceWorldName(worldName), replaceError(error.getMessage()));
     }
 
     private MessageReplacement replaceWorldName(@NotNull String worldName) {

src/main/java/com/onarandombox/MultiverseCore/worldnew/entrycheck/WorldEntryChecker.java

@@ -50,7 +50,7 @@ public class WorldEntryChecker {
                 .build();
     }
 
-    public Result<WorldAccessResult.Success, WorldAccessResult.Failure> canAccessWorld(@NotNull MultiverseWorld world) {
+    public Result<Void, WorldAccessResult.Success, WorldAccessResult.Failure> canAccessWorld(@NotNull MultiverseWorld world) {
         if (!config.getEnforceAccess()) {
             return Result.success(WorldAccessResult.Success.NO_ENFORCE_WORLD_ACCESS);
         }
@@ -59,7 +59,7 @@ public class WorldEntryChecker {
                 : Result.failure(WorldAccessResult.Failure.NO_WORLD_ACCESS);
     }
 
-    public Result<PlayerLimitResult.Success, PlayerLimitResult.Failure> isWithinPlayerLimit(@NotNull LoadedMultiverseWorld world) {
+    public Result<Void, PlayerLimitResult.Success, PlayerLimitResult.Failure> isWithinPlayerLimit(@NotNull LoadedMultiverseWorld world) {
         final int playerLimit = world.getPlayerLimit();
         if (playerLimit <= -1) {
             return Result.success(PlayerLimitResult.Success.NO_PLAYERLIMIT);
@@ -72,7 +72,7 @@ public class WorldEntryChecker {
                 : Result.failure(PlayerLimitResult.Failure.EXCEED_PLAYERLIMIT);
     }
 
-    public Result<BlacklistResult.Success, BlacklistResult.Failure> isNotBlacklisted(@Nullable LoadedMultiverseWorld fromWorld, @NotNull LoadedMultiverseWorld toWorld) {
+    public Result<Void, BlacklistResult.Success, BlacklistResult.Failure> isNotBlacklisted(@Nullable LoadedMultiverseWorld fromWorld, @NotNull LoadedMultiverseWorld toWorld) {
         if (fromWorld == null) {
             return Result.success(BlacklistResult.Success.UNKNOWN_FROM_WORLD);
         }
@@ -81,7 +81,7 @@ public class WorldEntryChecker {
                 : Result.success(BlacklistResult.Success.NOT_BLACKLISTED);
     }
 
-    public Result<EntryFeeResult.Success, EntryFeeResult.Failure> canPayEntryFee(LoadedMultiverseWorld world) {
+    public Result<Void, EntryFeeResult.Success, EntryFeeResult.Failure> canPayEntryFee(LoadedMultiverseWorld world) {
         double price = world.getPrice();
         Material currency = world.getCurrency();
         if (price == 0D && (currency == null || currency == EntryFee.DISABLED_MATERIAL)) {

src/main/resources/multiverse-core_en.properties

@@ -130,12 +130,12 @@ mv-core.entrycheck.exceedplayerlimit=the world has reached its player limit.
 mv-core.entrycheck.noworldaccess=you do not have permissions to access the world.
 
 # world manager result
-mv-core.cloneworld.cloned=&aWorld '{world}' cloned to '{newworld}'!
+mv-core.cloneworld.cloned=&aWorld cloned to '{world}'!
 mv-core.cloneworld.invalidworldname=World '{world}' contains invalid characters!
 mv-core.cloneworld.worldexistfolder=World '{world}' exists in server folders! You need to delete it first before cloning.
 mv-core.cloneworld.worldexistunloaded=World '{world}' already exists and it's unloaded! You need to delete it first before cloning.
 mv-core.cloneworld.worldexistloaded=World '{world}' already exists! You need to delete it first before cloning.
-mv-core.cloneworld.copyfailed=Failed to copy world '{world}' to '{newworld}': {error}\n&fSee console for more details.
+mv-core.cloneworld.copyfailed=Failed to copy world to '{world}': {error}\n&fSee console for more details.
 
 mv-core.createworld.created=&aWorld '{world}' created!
 mv-core.createworld.invalidworldname=World '{world}' contains invalid characters!