Split between Type and Codec

build.gradle

@@ -39,6 +39,7 @@ dependencies {
     compile 'com.google.guava:guava:21.0'
     compile 'org.apache.commons:commons-lang3:3.5'
     compile 'it.unimi.dsi:fastutil:7.1.0'
+    testCompile 'junit:junit-dep:4.10'
 }
 
 task sourcesJar(type: Jar) {

gradle.properties

@@ -1 +1 @@
-majorMinor: 2.0
+majorMinor: 3.0

src/main/java/com/mojang/datafixers/DSL.java

@@ -3,24 +3,11 @@
 package com.mojang.datafixers;
 
 import com.google.common.collect.Maps;
-import com.mojang.datafixers.util.Either;
-import com.mojang.datafixers.util.Pair;
-import com.mojang.datafixers.util.Unit;
-import com.mojang.datafixers.kinds.App2;
 import com.mojang.datafixers.schemas.Schema;
 import com.mojang.datafixers.types.Func;
 import com.mojang.datafixers.types.Type;
-import com.mojang.datafixers.types.constant.BoolType;
-import com.mojang.datafixers.types.constant.ByteType;
-import com.mojang.datafixers.types.constant.DoubleType;
-import com.mojang.datafixers.types.constant.FloatType;
-import com.mojang.datafixers.types.constant.IntType;
-import com.mojang.datafixers.types.constant.LongType;
-import com.mojang.datafixers.types.constant.NamespacedStringType;
-import com.mojang.datafixers.types.constant.NilDrop;
-import com.mojang.datafixers.types.constant.NilSave;
-import com.mojang.datafixers.types.constant.ShortType;
-import com.mojang.datafixers.types.constant.StringType;
+import com.mojang.datafixers.types.constant.EmptyPart;
+import com.mojang.datafixers.types.constant.EmptyPartPassthrough;
 import com.mojang.datafixers.types.templates.Check;
 import com.mojang.datafixers.types.templates.CompoundList;
 import com.mojang.datafixers.types.templates.Const;
@@ -33,13 +20,17 @@
 import com.mojang.datafixers.types.templates.Tag;
 import com.mojang.datafixers.types.templates.TaggedChoice;
 import com.mojang.datafixers.types.templates.TypeTemplate;
+import com.mojang.datafixers.util.Either;
+import com.mojang.datafixers.util.Pair;
+import com.mojang.datafixers.util.Unit;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.Dynamic;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.tuple.Triple;
 
 import java.util.Map;
 import java.util.function.Function;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
 
 public interface DSL {
     interface TypeReference {
@@ -84,24 +75,20 @@ static Type<String> string() {
         return Instances.STRING_TYPE;
     }
 
-    static Type<String> namespacedString() {
-        return Instances.NAMESPACED_STRING_TYPE;
-    }
-
-    static TypeTemplate nil() {
-        return constType(Instances.NIL_DROP);
+    static TypeTemplate emptyPart() {
+        return constType(Instances.EMPTY_PART);
     }
 
-    static Type<Unit> nilType() {
-        return Instances.NIL_DROP;
+    static Type<Unit> emptyPartType() {
+        return Instances.EMPTY_PART;
     }
 
     static TypeTemplate remainder() {
-        return constType(Instances.NIL_SAVE);
+        return constType(Instances.EMPTY_PASSTHROUGH);
     }
 
     static Type<Dynamic<?>> remainderType() {
-        return Instances.NIL_SAVE;
+        return Instances.EMPTY_PASSTHROUGH;
     }
 
     static TypeTemplate check(final String name, final int index, final TypeTemplate element) {
@@ -208,11 +195,11 @@ static <K> TaggedChoice<K> taggedChoice(final String name, final Type<K> keyType
     }
 
     static <K> TaggedChoice<K> taggedChoiceLazy(final String name, final Type<K> keyType, final Map<K, Supplier<TypeTemplate>> templates) {
-        return taggedChoice(name, keyType, templates.entrySet().stream().map(e -> Pair.of(e.getKey(), e.getValue().get())).collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
+        return taggedChoice(name, keyType, templates.entrySet().stream().map(e -> Pair.of(e.getKey(), e.getValue().get())).collect(Pair.toMap()));
     }
 
     @SuppressWarnings("unchecked")
-    static <K> Type<Pair<K, ?>> taggedChoiceType(final String name, final Type<K> keyType, final Map<K, Type<?>> types) {
+    static <K> Type<Pair<K, ?>> taggedChoiceType(final String name, final Type<K> keyType, final Map<K, ? extends Type<?>> types) {
         return (Type<Pair<K, ?>>) Instances.TAGGED_CHOICE_TYPE_CACHE.computeIfAbsent(Triple.of(name, keyType, types), k -> new TaggedChoice.TaggedChoiceType<>(k.getLeft(), (Type<K>) k.getMiddle(), (Map<K, Type<?>>) k.getRight()));
     }
 
@@ -223,11 +210,11 @@ static <A, B> Type<Function<A, B>> func(final Type<A> input, final Type<B> outpu
     // Helpers
 
     static <A> Type<Either<A, Unit>> optional(final Type<A> type) {
-        return or(type, nilType());
+        return or(type, emptyPartType());
     }
 
     static TypeTemplate optional(final TypeTemplate value) {
-        return or(value, nil());
+        return or(value, emptyPart());
     }
 
     static TypeTemplate fields(
@@ -443,24 +430,23 @@ static <FT> OpticFinder<FT> namedChoice(final String name, final Type<FT> type)
     }
 
     static Unit unit() {
-        return null;
+        return Unit.INSTANCE;
     }
 
     final class Instances {
-        private static final Type<Boolean> BOOL_TYPE = new BoolType();
-        private static final Type<Integer> INT_TYPE = new IntType();
-        private static final Type<Long> LONG_TYPE = new LongType();
-        private static final Type<Byte> BYTE_TYPE = new ByteType();
-        private static final Type<Short> SHORT_TYPE = new ShortType();
-        private static final Type<Float> FLOAT_TYPE = new FloatType();
-        private static final Type<Double> DOUBLE_TYPE = new DoubleType();
-        private static final Type<String> STRING_TYPE = new StringType();
-        private static final Type<String> NAMESPACED_STRING_TYPE = new NamespacedStringType();
-        private static final Type<Unit> NIL_DROP = new NilDrop();
-        private static final Type<Dynamic<?>> NIL_SAVE = new NilSave();
+        private static final Type<Boolean> BOOL_TYPE = new Const.PrimitiveType<>(Codec.BOOL);
+        private static final Type<Integer> INT_TYPE = new Const.PrimitiveType<>(Codec.INT);
+        private static final Type<Long> LONG_TYPE = new Const.PrimitiveType<>(Codec.LONG);
+        private static final Type<Byte> BYTE_TYPE = new Const.PrimitiveType<>(Codec.BYTE);
+        private static final Type<Short> SHORT_TYPE = new Const.PrimitiveType<>(Codec.SHORT);
+        private static final Type<Float> FLOAT_TYPE = new Const.PrimitiveType<>(Codec.FLOAT);
+        private static final Type<Double> DOUBLE_TYPE = new Const.PrimitiveType<>(Codec.DOUBLE);
+        private static final Type<String> STRING_TYPE = new Const.PrimitiveType<>(Codec.STRING);
+        private static final Type<Unit> EMPTY_PART = new EmptyPart();
+        private static final Type<Dynamic<?>> EMPTY_PASSTHROUGH = new EmptyPartPassthrough();
 
         private static final OpticFinder<Dynamic<?>> REMAINDER_FINDER = remainderType().finder();
 
-        private static final Map<Triple<String, Type<?>, Map<?, Type<?>>>, Type<? extends Pair<?, ?>>> TAGGED_CHOICE_TYPE_CACHE = Maps.newConcurrentMap();
+        private static final Map<Triple<String, Type<?>, Map<?, ? extends Type<?>>>, Type<? extends Pair<?, ?>>> TAGGED_CHOICE_TYPE_CACHE = Maps.newConcurrentMap();
     }
 }

src/main/java/com/mojang/datafixers/DataFix.java

@@ -3,14 +3,17 @@
 package com.mojang.datafixers;
 
 import com.mojang.datafixers.schemas.Schema;
-import com.mojang.datafixers.types.DynamicOps;
 import com.mojang.datafixers.types.Type;
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.Dynamic;
+import com.mojang.serialization.DynamicOps;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import javax.annotation.Nullable;
 import java.util.BitSet;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Function;
 
 public abstract class DataFix {
@@ -40,9 +43,17 @@ protected TypeRewriteRule writeAndRead(final String name, final Type<?> type, fi
     }
 
     protected <A, B> TypeRewriteRule writeFixAndRead(final String name, final Type<A> type, final Type<B> newType, final Function<Dynamic<?>, Dynamic<?>> fix) {
-        return fixTypeEverywhere(name, type, newType, ops -> input ->
-            newType.readTyped(fix.apply(type.writeDynamic(ops, input))).getSecond().orElseThrow(() -> new IllegalStateException("Could not read new type in \"" + name + "\"")).getValue()
-        );
+        return fixTypeEverywhere(name, type, newType, ops -> input -> {
+            final Optional<? extends Dynamic<?>> written = type.writeDynamic(ops, input).resultOrPartial(LOGGER::error);
+            if (!written.isPresent()) {
+                throw new RuntimeException("Could not write the object in " + name);
+            }
+            final Optional<? extends Pair<Typed<B>, ?>> read = newType.readTyped(fix.apply(written.get())).resultOrPartial(LOGGER::error);
+            if (!read.isPresent()) {
+                throw new RuntimeException("Could not read the new object in " + name);
+            }
+            return read.get().getFirst().getValue();
+        });
     }
 
     protected <A, B> TypeRewriteRule fixTypeEverywhere(final String name, final Type<A> type, final Type<B> newType, final Function<DynamicOps<?>, Function<A, B>> function) {

src/main/java/com/mojang/datafixers/DataFixUtils.java

@@ -6,6 +6,7 @@
 import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
 
 public class DataFixUtils {
     private DataFixUtils() {
@@ -93,4 +94,11 @@ public static int getVersion(final int key) {
     public static int getSubVersion(final int key) {
         return key % 10;
     }
+
+    public static <T> UnaryOperator<T> consumerToFunction(final Consumer<T> consumer) {
+        return s -> {
+            consumer.accept(s);
+            return s;
+        };
+    }
 }

src/main/java/com/mojang/datafixers/DataFixer.java

@@ -3,6 +3,7 @@
 package com.mojang.datafixers;
 
 import com.mojang.datafixers.schemas.Schema;
+import com.mojang.serialization.Dynamic;
 
 public interface DataFixer {
     <T> Dynamic<T> update(DSL.TypeReference type, Dynamic<T> input, int version, int newVersion);

src/main/java/com/mojang/datafixers/DataFixerUpper.java

@@ -4,19 +4,20 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
+import com.mojang.datafixers.functions.PointFreeRule;
+import com.mojang.datafixers.schemas.Schema;
+import com.mojang.datafixers.types.Type;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.Dynamic;
 import it.unimi.dsi.fastutil.ints.Int2ObjectSortedMap;
 import it.unimi.dsi.fastutil.ints.IntSortedSet;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
-import com.mojang.datafixers.functions.PointFreeRule;
-import com.mojang.datafixers.schemas.Schema;
-import com.mojang.datafixers.types.Type;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.util.List;
-import java.util.Optional;
 
 /*
  * Optimizing functions
@@ -78,18 +79,11 @@ protected DataFixerUpper(final Int2ObjectSortedMap<Schema> schemas, final List<D
 
     @Override
     public <T> Dynamic<T> update(final DSL.TypeReference type, final Dynamic<T> input, final int version, final int newVersion) {
-        try {
-            if (version < newVersion) {
-                final Type<?> dataType = getType(type, version);
-                final Optional<T> read = dataType.readAndWrite(input.getOps(), getType(type, newVersion), getRule(version, newVersion), OPTIMIZATION_RULE, input.getValue());
-                if (!read.isPresent()) {
-                    throw new IllegalStateException("Could not parse for fixing " + dataType);
-                }
-
-                return new Dynamic<>(input.getOps(), read.get());
-            }
-        } catch (final Throwable t) {
-            LOGGER.error("Something went wrong upgrading!", t);
+        if (version < newVersion) {
+            final Type<?> dataType = getType(type, version);
+            final DataResult<T> read = dataType.readAndWrite(input.getOps(), getType(type, newVersion), getRule(version, newVersion), OPTIMIZATION_RULE, input.getValue());
+            final T result = read.resultOrPartial(LOGGER::error).orElse(input.getValue());
+            return new Dynamic<>(input.getOps(), result);
         }
         return input;
     }