fabric, take 3 or something

.checkstyle/checkstyle-suppressions.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE suppressions PUBLIC
+        "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
+        "https://checkstyle.org/dtds/suppressions_1_2.dtd">
+<suppressions>
+    <suppress checks="(?:(?:Member|Method)Name|DesignForExtension|Javadoc.*)" files=".*[\\/]mixin[\\/].*"/>
+</suppressions>

.checkstyle/checkstyle.xml

@@ -78,9 +78,8 @@
 
     <!-- https://checkstyle.org/config_filters.html#SuppressionFilter -->
     <module name="SuppressionFilter">
-        <property name="file" value="${org.checkstyle.sun.suppressionfilter.config}"
-                  default="checkstyle-suppressions.xml"/>
-        <property name="optional" value="true"/>
+        <property name="file" value="${config_loc}/checkstyle-suppressions.xml"/>
+        <property name="optional" value="false"/>
     </module>
 
     <!-- Checks that a package-info.java file exists for each package.     -->
@@ -101,6 +100,7 @@
     <module name="LineLength">
         <property name="fileExtensions" value="java"/>
         <property name="max" value="140"/>
+        <property name="ignorePattern" value="^ *\* "/> <!-- Ignore long JavaDoc lines (i.e. a link) -->
     </module>
 
     <!-- Checks for whitespace                               -->

.gitignore

@@ -222,3 +222,7 @@ gradle-app.setting
 **/build/
 
 # End of https://www.toptal.com/developers/gitignore/api/git,java,eclipse,jetbrains+all,gradle
+
+### Fabric Loom run files ###
+
+/run/

README.md

@@ -86,6 +86,7 @@ The code is based on a (W.I.P) paper that can be found [here](https://github.com
 - **cloud-minecraft/cloud-bungee**: BungeeCord 1.8.8+ implementation of Cloud
 - **cloud-minecraft/cloud-velocity**: Velocity v1.1.0 implementation of cloud
 - **cloud-minecraft/cloud-cloudburst**: Cloudburst v1.0.0+ implementation of cloud
+- **cloud-minecraft/cloud-fabric**: Fabric implementation of Cloud
 - **cloud-minecraft/cloud-minecraft-extras**: Opinionated Extra Features for cloud-minecraft
 - **cloud-discord/cloud-jda**: JDA v4.2.0_209+ implementation of cloud
 - **cloud-discord/cloud-javacord**: Javacord v3.1.1+ implementation of cloud

buildSrc/src/main/kotlin/Versions.kt

@@ -23,6 +23,10 @@ object Versions {
     const val spongeApi7 = "7.3.0"
     const val jetbrainsAnnotations = "20.1.0"
     const val guava = "21.0-jre"
+    const val fabricLoader = "0.11.1"
+    const val fabricMc = "1.16.5"
+    const val fabricYarn = "1"
+    const val fabricApi = "0.31.0+1.16"
 
     // IRC DEPENDENCIES
     const val pircbotx = "83a4c22e80"

cloud-core/src/main/java/cloud/commandframework/arguments/CommandArgument.java

@@ -739,6 +739,98 @@ protected final boolean isRequired() {
             return this.defaultDescription;
         }
 
+        protected final @NonNull TypeToken<T> getValueType() {
+            return this.valueType;
+        }
+
+    }
+
+    /**
+     * A variant of builders designed for subclassing, that returns a self type .
+     *
+     * @param <C> sender type
+     * @param <T> argument value type
+     * @param <B> the subclass type
+     * @since 1.5.0
+     */
+    public abstract static class TypedBuilder<C, T, B extends Builder<C, T>> extends Builder<C, T> {
+
+        protected TypedBuilder(
+                final @NonNull TypeToken<T> valueType,
+                final @NonNull String name
+        ) {
+            super(valueType, name);
+        }
+
+        protected TypedBuilder(
+                final @NonNull Class<T> valueType,
+                final @NonNull String name
+        ) {
+            super(valueType, name);
+        }
+
+        @SuppressWarnings("unchecked")
+        protected final B self() {
+            return (B) this;
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NonNull B manager(final @NonNull CommandManager<C> manager) {
+            super.manager(manager);
+            return this.self();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NonNull B asRequired() {
+            super.asRequired();
+            return this.self();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NonNull B asOptional() {
+            super.asOptional();
+            return this.self();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NonNull B asOptionalWithDefault(final @NonNull String defaultValue) {
+            super.asOptionalWithDefault(defaultValue);
+            return this.self();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NonNull B withParser(final @NonNull ArgumentParser<@NonNull C, @NonNull T> parser) {
+            super.withParser(parser);
+            return this.self();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public @NonNull Builder<@NonNull C, @NonNull T> withSuggestionsProvider(
+                final @NonNull BiFunction<@NonNull CommandContext<C>,
+                        @NonNull String, @NonNull List<String>> suggestionsProvider
+        ) {
+            super.withSuggestionsProvider(suggestionsProvider);
+            return this.self();
+        }
+
     }
 
 }

cloud-core/src/main/java/cloud/commandframework/arguments/parser/ArgumentParseResult.java

@@ -26,6 +26,7 @@
 import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.Optional;
+import java.util.function.Function;
 
 /**
  * Result of the parsing done by a {@link ArgumentParser}
@@ -66,13 +67,42 @@ private ArgumentParseResult() {
      */
     public abstract @NonNull Optional<T> getParsedValue();
 
+    /**
+     * If this result is successful, transform the output value.
+     *
+     * @param mapper the transformation
+     * @param <U> the result type
+     * @return a new result if successful, otherwise a failure
+     * @since 1.5.0
+     */
+    public abstract <U> @NonNull ArgumentParseResult<U> mapParsedValue(Function<T, U> mapper);
+
+    /**
+     * If this result is successful, transform the output value, returning another parse result.
+     *
+     * @param mapper the transformation
+     * @param <U> the result type
+     * @return a new result if successful, otherwise a failure
+     * @since 1.5.0
+     */
+    public abstract <U> @NonNull ArgumentParseResult<U> flatMapParsedValue(Function<T, ArgumentParseResult<U>> mapper);
+
     /**
      * Get the failure reason, if it exists
      *
      * @return Optional containing the failure reason
      */
     public abstract @NonNull Optional<Throwable> getFailure();
 
+    /**
+     * If this result is a failure, transform the exception.
+     *
+     * @param mapper the exception transformation
+     * @return if this is a failure, a transformed result, otherwise this
+     * @since 1.5.0
+     */
+    public abstract @NonNull ArgumentParseResult<T> mapFailure(Function<Throwable, Throwable> mapper);
+
 
     private static final class ParseSuccess<T> extends ArgumentParseResult<T> {
 
@@ -90,13 +120,27 @@ private ParseSuccess(final @NonNull T value) {
             return Optional.of(this.value);
         }
 
+        @Override
+        public @NonNull <U> ArgumentParseResult<U> mapParsedValue(final Function<T, U> mapper) {
+            return new ParseSuccess<>(mapper.apply(this.value));
+        }
+
+        @Override
+        public @NonNull <U> ArgumentParseResult<U> flatMapParsedValue(final Function<T, ArgumentParseResult<U>> mapper) {
+             return mapper.apply(this.value);
+        }
+
         @Override
         public @NonNull Optional<Throwable> getFailure() {
             return Optional.empty();
         }
 
-    }
+        @Override
+        public @NonNull ArgumentParseResult<T> mapFailure(final Function<Throwable, Throwable> mapper) {
+            return this;
+        }
 
+    }
 
     private static final class ParseFailure<T> extends ArgumentParseResult<T> {
 
@@ -114,11 +158,27 @@ private ParseFailure(final @NonNull Throwable failure) {
             return Optional.empty();
         }
 
+        @Override
+        @SuppressWarnings("unchecked")
+        public @NonNull <U> ArgumentParseResult<U> mapParsedValue(final Function<T, U> mapper) {
+            return (ArgumentParseResult<U>) this;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public @NonNull <U> ArgumentParseResult<U> flatMapParsedValue(final Function<T, ArgumentParseResult<U>> mapper) {
+            return (ArgumentParseResult<U>) this;
+        }
+
         @Override
         public @NonNull Optional<Throwable> getFailure() {
             return Optional.of(this.failure);
         }
 
+        @Override
+        public @NonNull ArgumentParseResult<T> mapFailure(final Function<Throwable, Throwable> mapper) {
+            return new ParseFailure<>(mapper.apply(this.failure));
+        }
     }
 
 }

cloud-core/src/main/java/cloud/commandframework/arguments/parser/ArgumentParser.java

@@ -29,6 +29,9 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Queue;
+import java.util.function.BiFunction;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Parser that parses strings into values of a specific type
@@ -89,6 +92,18 @@ public interface ArgumentParser<C, T> {
         return Collections.emptyList();
     }
 
+    /**
+     * Create a derived argument parser preserving all properties of this parser, but converting the output type.
+     *
+     * @param mapper the mapper to apply
+     * @param <O> the result type
+     * @return a derived parser.
+     * @since 1.5.0
+     */
+    default <O> @NonNull ArgumentParser<C, O> map(final BiFunction<CommandContext<C>, T, ArgumentParseResult<O>> mapper) {
+        return new MappedArgumentParser<>(this, requireNonNull(mapper, "mapper"));
+    }
+
     /**
      * Check whether or not this argument parser is context free. A context free
      * parser will not use the provided command context, and so supports impromptu parsing