--- /dev/null	2015-01-19 11:28:01.396824775 +0100
+++ new/src/java.base/share/classes/java/util/Any.java	2015-02-04 10:44:13.988894732 +0100
@@ -0,0 +1,204 @@
+package javany.util;
+
+import javany.util.function.Function;
+
+import java.lang.reflect.Array;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A helper for common <any T> functionality
+ */
+public class Any<any T> {
+
+    // default value
+
+    public static <any T> T defaultValue() {
+        return new Any<T>().defaultValue;
+    }
+
+    // null-safe: equals, hashCode & toString
+
+    public static <any T> boolean equals(T a, T b) {
+        return new Any<T>().equalsImpl(a, b);
+    }
+
+    public static <any T> int hashCode(T a) {
+        return new Any<T>().hashCodeImpl(a);
+    }
+
+    public static <any T> String toString(T a) {
+        return new Any<T>().toStringImpl(a);
+    }
+
+    // array construction
+
+    public static <any T> T[] newArray(int length, Class<? extends T[]> type) {
+        return new Any<T>().newArrayImpl(length, type);
+    }
+
+    // array copying
+
+    @SuppressWarnings("unchecked")
+    public static <any S, any D> void arraycopy(S[] src,  int  srcPos,
+                                                D[] dest, int destPos,
+                                                int length) {
+        if (Function<S, D>.class == Function<S, S>.class) {
+            // erasure(S) == erasure(D)
+            System.arraycopy(src, srcPos, dest, destPos, length);
+        } else {
+            // assert src != dest;
+            if (srcPos < 0 || destPos < 0 || length < 0 ||
+                srcPos + length > src.length || destPos + length > dest.length) {
+                throw new IndexOutOfBoundsException(String.format(
+                    "src.length=%d, srcPos=%d, dest.length=%d, destPos=%d, length=%d",
+                    src.length, srcPos, dest.length, destPos, length
+                ));
+            }
+            Function<S, D> converter = converter();
+            while (length-- > 0) {
+                dest[destPos++] = converter.apply(src[srcPos++]);
+            }
+        }
+    }
+
+    // identity, widening, boxing and unboxing conversions
+
+    @SuppressWarnings("unchecked")
+    public static <any S, any T> Function<S, T> converter() {
+        Function<S, T> converter = (Function<S, T>) converters.get(Function<S, T>.class);
+        if (converter == null) {
+            throw new ClassCastException("No converter: " + Function<S, T>.class.getName());
+        }
+        return converter;
+    }
+
+    public static <any S, any T> T convert(S source) {
+        return Any.<S, T>converter().apply(source);
+    }
+
+    private static final Map<Class<?>, Object> converters = new HashMap<>();
+
+    @SuppressWarnings("unchecked")
+    private static <any S, any T> void putConverter(Function<S, T> converter) {
+        converters.put(Function<S, T>.class, converter);
+    }
+
+    static {
+        // identity conversions
+
+        putConverter(Function.<boolean>identity());
+        putConverter(Function.<byte>identity());
+        putConverter(Function.<short>identity());
+        putConverter(Function.<char>identity());
+        putConverter(Function.<int>identity());
+        putConverter(Function.<long>identity());
+        putConverter(Function.<float>identity());
+        putConverter(Function.<double>identity());
+        putConverter(Function.<Object>identity());
+
+        // widening conversions
+
+        putConverter((Function<byte, short>) (x) -> (short)x);
+        putConverter((Function<byte, int>) (x) -> (int)x);
+        putConverter((Function<byte, long>) (x) -> (long)x);
+        putConverter((Function<byte, float>) (x) -> (float)x);
+        putConverter((Function<byte, double>) (x) -> (double)x);
+
+        putConverter((Function<short, int>) (x) -> (int)x);
+        putConverter((Function<short, long>) (x) -> (long)x);
+        putConverter((Function<short, float>) (x) -> (float)x);
+        putConverter((Function<short, double>) (x) -> (double)x);
+
+        putConverter((Function<char, int>) (x) -> (int)x);
+        putConverter((Function<char, long>) (x) -> (long)x);
+        putConverter((Function<char, float>) (x) -> (float)x);
+        putConverter((Function<char, double>) (x) -> (double)x);
+
+        putConverter((Function<int, long>) (x) -> (long)x);
+        putConverter((Function<int, float>) (x) -> (float)x);
+        putConverter((Function<int, double>) (x) -> (double)x);
+
+        putConverter((Function<float, double>) (x) -> (double)x);
+
+        // boxing conversions
+
+        putConverter((Function<boolean, Boolean>) Boolean::valueOf);
+        putConverter((Function<byte, Byte>) Byte::valueOf);
+        putConverter((Function<short, Short>) Short::valueOf);
+        putConverter((Function<char, Character>) Character::valueOf);
+        putConverter((Function<int, Integer>) Integer::valueOf);
+        putConverter((Function<long, Long>) Long::valueOf);
+        putConverter((Function<float, Float>) Float::valueOf);
+        putConverter((Function<double, Double>) Double::valueOf);
+
+        // unboxing conversions
+
+        putConverter((Function<Boolean, boolean>) Boolean::booleanValue);
+        putConverter((Function<Byte, byte>) Byte::byteValue);
+        putConverter((Function<Short, short>) Short::shortValue);
+        putConverter((Function<Character, char>) Character::charValue);
+        putConverter((Function<Integer, int>) Integer::intValue);
+        putConverter((Function<Long, long>) Long::longValue);
+        putConverter((Function<Float, float>) Float::floatValue);
+        putConverter((Function<Double, double>) Double::doubleValue);
+    }
+
+    // private instance implementation
+
+    private Any() {}
+
+    private T defaultValue;
+
+    private boolean equalsImpl(T a, T b) {
+        __WhereVal(T) {
+            return equalsNonNullImpl(a, b);
+        }
+        __WhereRef(T) {
+            return a == b || (a != null && equalsNonNullImpl(a, b));
+        }
+    }
+
+    private boolean equalsNonNullImpl(T a, T b) {
+        return a.equals(b);
+    }
+
+    private int hashCodeImpl(T a) {
+        __WhereVal(T) {
+            return hashCodeNonNullImpl(a);
+        }
+        __WhereRef(T) {
+            return (a == null) ? 0 : hashCodeNonNullImpl(a);
+        }
+    }
+
+    private int hashCodeNonNullImpl(T a) {
+        return a.hashCode();
+    }
+
+    private String toStringImpl(T a) {
+        __WhereVal(T) {
+            return toStringNonNullImpl(a);
+        }
+        __WhereRef(T) {
+            return (a == null) ? "null" : toStringNonNullImpl(a);
+        }
+    }
+
+    private String toStringNonNullImpl(T a) {
+        return a.toString();
+    }
+
+    private T[] newArrayImpl(int length, Class<? extends T[]> type) {
+        __WhereVal(T) {
+            return new T[length];
+        }
+        __WhereRef(T) {
+            @SuppressWarnings("unchecked")
+            T[] array = ((Object) type == (Object) Object[].class)
+                ? (T[]) new Object[length]
+                : (T[]) Array.newInstance(type.getComponentType(), length);
+            return array;
+        }
+    }
+}