changeset 58920:096f30dfdbbc foreign+vector

Automatic merge with vectorIntrinsics
author mcimadamore
date Fri, 19 Apr 2019 04:44:47 +0200
parents 6988fa083a2e 0678bd75278c
children 82a6fe9fb2b8
files
diffstat 153 files changed, 5731 insertions(+), 7714 deletions(-) [+]
line wrap: on
line diff
--- a/src/hotspot/share/classfile/vmSymbols.hpp	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/hotspot/share/classfile/vmSymbols.hpp	Fri Apr 19 04:44:47 2019 +0200
@@ -84,8 +84,8 @@
   template(java_lang_Long_LongCache,                  "java/lang/Long$LongCache")                 \
   template(jdk_incubator_vector_VectorIntrinsics,        "jdk/incubator/vector/VectorIntrinsics")         \
   template(jdk_incubator_vector_Vector,                  "jdk/incubator/vector/Vector")                   \
-  template(jdk_incubator_vector_VectorSpecies,           "jdk/incubator/vector/Vector$Species")           \
-  template(jdk_incubator_vector_VectorMask,              "jdk/incubator/vector/Vector$Mask")              \
+  template(jdk_incubator_vector_VectorSpecies,           "jdk/incubator/vector/VectorSpecies")            \
+  template(jdk_incubator_vector_VectorMask,              "jdk/incubator/vector/VectorMask")               \
   template(jdk_incubator_vector_VectorAbstractMask,      "jdk/incubator/vector/AbstractMask")             \
   template(jdk_incubator_vector_FloatVector,             "jdk/incubator/vector/FloatVector")              \
   template(jdk_incubator_vector_FloatVector_FloatSpecies,"jdk/incubator/vector/FloatVector$FloatSpecies") \
@@ -1524,11 +1524,11 @@
    do_name(vector_ternary_op_name,     "ternaryOp")                                                                                            \
                                                                                                                                                \
   do_intrinsic(_VectorBroadcastCoerced, jdk_incubator_vector_VectorIntrinsics, vector_broadcast_coerced_name, vector_broadcast_coerced_sig, F_S) \
-   do_signature(vector_broadcast_coerced_sig, "(Ljava/lang/Class;Ljava/lang/Class;IJLjdk/incubator/vector/Vector$Species;Ljdk/incubator/vector/VectorIntrinsics$BroadcastOperation;)Ljava/lang/Object;")     \
+   do_signature(vector_broadcast_coerced_sig, "(Ljava/lang/Class;Ljava/lang/Class;IJLjdk/incubator/vector/VectorSpecies;Ljdk/incubator/vector/VectorIntrinsics$BroadcastOperation;)Ljava/lang/Object;")     \
    do_name(vector_broadcast_coerced_name, "broadcastCoerced")                                                                                  \
                                                                                                                                                \
   do_intrinsic(_VectorLoadOp, jdk_incubator_vector_VectorIntrinsics, vector_load_op_name, vector_load_op_sig, F_S)                             \
-   do_signature(vector_load_op_sig, "(Ljava/lang/Class;Ljava/lang/Class;ILjava/lang/Object;JLjava/lang/Object;ILjdk/incubator/vector/Vector$Species;Ljdk/incubator/vector/VectorIntrinsics$LoadOperation;)Ljava/lang/Object;") \
+   do_signature(vector_load_op_sig, "(Ljava/lang/Class;Ljava/lang/Class;ILjava/lang/Object;JLjava/lang/Object;ILjdk/incubator/vector/VectorSpecies;Ljdk/incubator/vector/VectorIntrinsics$LoadOperation;)Ljava/lang/Object;") \
    do_name(vector_load_op_name,     "load")                                                                                                    \
   do_intrinsic(_VectorStoreOp, jdk_incubator_vector_VectorIntrinsics, vector_store_op_name, vector_store_op_sig, F_S)                          \
    do_signature(vector_store_op_sig, "(Ljava/lang/Class;Ljava/lang/Class;ILjava/lang/Object;JLjdk/incubator/vector/Vector;Ljava/lang/Object;ILjdk/incubator/vector/VectorIntrinsics$StoreVectorOperation;)V") \
@@ -1544,19 +1544,19 @@
                                                                                                                                                \
   do_intrinsic(_VectorBlend, jdk_incubator_vector_VectorIntrinsics, vector_blend_name, vector_blend_sig, F_S)                                  \
    do_signature(vector_blend_sig, "(Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;I"                                                      \
-                                   "Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/Vector$Mask;"              \
+                                   "Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/VectorMask;"               \
                                    "Ljdk/incubator/vector/VectorIntrinsics$VectorBlendOp;)Ljdk/incubator/vector/Vector;")                      \
    do_name(vector_blend_name, "blend")                                                                                                         \
                                                                                                                                                \
   do_intrinsic(_VectorCompare, jdk_incubator_vector_VectorIntrinsics, vector_compare_name, vector_compare_sig, F_S)                            \
    do_signature(vector_compare_sig, "(ILjava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;I"                                                   \
                                     "Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/Vector;"                                               \
-                                    "Ljdk/incubator/vector/VectorIntrinsics$VectorCompareOp;)Ljdk/incubator/vector/Vector$Mask;")              \
+                                    "Ljdk/incubator/vector/VectorIntrinsics$VectorCompareOp;)Ljdk/incubator/vector/VectorMask;")               \
    do_name(vector_compare_name, "compare")                                                                                                     \
                                                                                                                                                \
   do_intrinsic(_VectorRearrange, jdk_incubator_vector_VectorIntrinsics, vector_rearrange_name, vector_rearrange_sig, F_S)                      \
    do_signature(vector_rearrange_sig, "(Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;I"                                                  \
-                                      "Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/Vector$Shuffle;"                                     \
+                                      "Ljdk/incubator/vector/Vector;Ljdk/incubator/vector/VectorShuffle;"                                     \
                                       "Ljdk/incubator/vector/VectorIntrinsics$VectorRearrangeOp;)Ljdk/incubator/vector/Vector;")               \
    do_name(vector_rearrange_name, "rearrangeOp")                                                                                               \
                                                                                                                                                \
@@ -1592,9 +1592,9 @@
    do_intrinsic(_VectorGatherOp, jdk_incubator_vector_VectorIntrinsics, vector_gather_name, vector_gather_sig, F_S)                            \
     do_signature(vector_gather_sig, "(Ljava/lang/Class;Ljava/lang/Class;ILjava/lang/Class;"                                                    \
                                    "Ljava/lang/Object;J"                                                                                       \
-                                   "Ljdk/incubator/vector/IntVector;"                                                                             \
+                                   "Ljdk/incubator/vector/IntVector;"                                                                          \
                                    "Ljava/lang/Object;I[II"                                                                                    \
-                                   "Ljdk/incubator/vector/Vector$Species;"                                       \
+                                   "Ljdk/incubator/vector/VectorSpecies;"                                                                      \
                                    "Ljdk/incubator/vector/VectorIntrinsics$LoadVectorOperationWithMap;)"                                       \
                                    "Ljdk/incubator/vector/Vector;")                                                                            \
     do_name(vector_gather_name, "loadWithMap")                                                                                                 \
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java	Fri Apr 19 04:44:47 2019 +0200
@@ -26,7 +26,7 @@
 
 import java.util.Arrays;
 
-abstract class AbstractMask<E> extends Vector.Mask<E> {
+abstract class AbstractMask<E> extends VectorMask<E> {
 
     /*package-private*/
     abstract boolean[] getBits();
@@ -45,7 +45,7 @@
         boolean apply(int i, boolean a, boolean b);
     }
 
-    abstract AbstractMask<E> bOp(Vector.Mask<E> o, MBinOp f);
+    abstract AbstractMask<E> bOp(VectorMask<E> o, MBinOp f);
 
     @Override
     public String toString() {
@@ -89,12 +89,12 @@
     }
 
     @Override
-    public AbstractMask<E> and(Vector.Mask<E> o) {
+    public AbstractMask<E> and(VectorMask<E> o) {
         return bOp(o, (i, a, b) -> a && b);
     }
 
     @Override
-    public AbstractMask<E> or(Vector.Mask<E> o) {
+    public AbstractMask<E> or(VectorMask<E> o) {
         return bOp(o, (i, a, b) -> a || b);
     }
 
@@ -118,4 +118,144 @@
         }
         return true;
     }
+
+    // @@@ This is a bad implementation -- makes lambdas capturing -- fix this
+    @SuppressWarnings("unchecked")
+    static <E> VectorMask<E> trueMask(VectorSpecies<E> species) {
+        Class<?> eType = species.elementType();
+
+        if (eType == byte.class) {
+            if (species.boxType() == ByteMaxVector.class)
+                return (VectorMask<E>) ByteMaxVector.ByteMaxMask.TRUE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Byte64Vector.Byte64Mask.TRUE_MASK;
+                case 128: return (VectorMask<E>) Byte128Vector.Byte128Mask.TRUE_MASK;
+                case 256: return (VectorMask<E>) Byte256Vector.Byte256Mask.TRUE_MASK;
+                case 512: return (VectorMask<E>) Byte512Vector.Byte512Mask.TRUE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == short.class) {
+            if (species.boxType() == ShortMaxVector.class)
+                return (VectorMask<E>) ShortMaxVector.ShortMaxMask.TRUE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Short64Vector.Short64Mask.TRUE_MASK;
+                case 128: return (VectorMask<E>) Short128Vector.Short128Mask.TRUE_MASK;
+                case 256: return (VectorMask<E>) Short256Vector.Short256Mask.TRUE_MASK;
+                case 512: return (VectorMask<E>) Short512Vector.Short512Mask.TRUE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == int.class) {
+            if (species.boxType() == IntMaxVector.class)
+                return (VectorMask<E>) IntMaxVector.IntMaxMask.TRUE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Int64Vector.Int64Mask.TRUE_MASK;
+                case 128: return (VectorMask<E>) Int128Vector.Int128Mask.TRUE_MASK;
+                case 256: return (VectorMask<E>) Int256Vector.Int256Mask.TRUE_MASK;
+                case 512: return (VectorMask<E>) Int512Vector.Int512Mask.TRUE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == long.class) {
+            if (species.boxType() == LongMaxVector.class)
+                return (VectorMask<E>) LongMaxVector.LongMaxMask.TRUE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Long64Vector.Long64Mask.TRUE_MASK;
+                case 128: return (VectorMask<E>) Long128Vector.Long128Mask.TRUE_MASK;
+                case 256: return (VectorMask<E>) Long256Vector.Long256Mask.TRUE_MASK;
+                case 512: return (VectorMask<E>) Long512Vector.Long512Mask.TRUE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == float.class) {
+            if (species.boxType() == FloatMaxVector.class)
+                return (VectorMask<E>) FloatMaxVector.FloatMaxMask.TRUE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Float64Vector.Float64Mask.TRUE_MASK;
+                case 128: return (VectorMask<E>) Float128Vector.Float128Mask.TRUE_MASK;
+                case 256: return (VectorMask<E>) Float256Vector.Float256Mask.TRUE_MASK;
+                case 512: return (VectorMask<E>) Float512Vector.Float512Mask.TRUE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == double.class) {
+            if (species.boxType() == DoubleMaxVector.class)
+                return (VectorMask<E>) DoubleMaxVector.DoubleMaxMask.TRUE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Double64Vector.Double64Mask.TRUE_MASK;
+                case 128: return (VectorMask<E>) Double128Vector.Double128Mask.TRUE_MASK;
+                case 256: return (VectorMask<E>) Double256Vector.Double256Mask.TRUE_MASK;
+                case 512: return (VectorMask<E>) Double512Vector.Double512Mask.TRUE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else {
+            throw new IllegalArgumentException("Bad element type of species");
+        }
+    }
+
+    // @@@ This is a bad implementation -- makes lambdas capturing -- fix this
+    @SuppressWarnings("unchecked")
+    static <E> VectorMask<E> falseMask(VectorSpecies<E> species) {
+        Class<?> eType = species.elementType();
+
+        if (eType == byte.class) {
+            if (species.boxType() == ByteMaxVector.class)
+                return (VectorMask<E>) ByteMaxVector.ByteMaxMask.FALSE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Byte64Vector.Byte64Mask.FALSE_MASK;
+                case 128: return (VectorMask<E>) Byte128Vector.Byte128Mask.FALSE_MASK;
+                case 256: return (VectorMask<E>) Byte256Vector.Byte256Mask.FALSE_MASK;
+                case 512: return (VectorMask<E>) Byte512Vector.Byte512Mask.FALSE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == short.class) {
+            if (species.boxType() == ShortMaxVector.class)
+                return (VectorMask<E>) ShortMaxVector.ShortMaxMask.FALSE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Short64Vector.Short64Mask.FALSE_MASK;
+                case 128: return (VectorMask<E>) Short128Vector.Short128Mask.FALSE_MASK;
+                case 256: return (VectorMask<E>) Short256Vector.Short256Mask.FALSE_MASK;
+                case 512: return (VectorMask<E>) Short512Vector.Short512Mask.FALSE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == int.class) {
+            if (species.boxType() == IntMaxVector.class)
+                return (VectorMask<E>) IntMaxVector.IntMaxMask.FALSE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Int64Vector.Int64Mask.FALSE_MASK;
+                case 128: return (VectorMask<E>) Int128Vector.Int128Mask.FALSE_MASK;
+                case 256: return (VectorMask<E>) Int256Vector.Int256Mask.FALSE_MASK;
+                case 512: return (VectorMask<E>) Int512Vector.Int512Mask.FALSE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == long.class) {
+            if (species.boxType() == LongMaxVector.class)
+                return (VectorMask<E>) LongMaxVector.LongMaxMask.FALSE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Long64Vector.Long64Mask.FALSE_MASK;
+                case 128: return (VectorMask<E>) Long128Vector.Long128Mask.FALSE_MASK;
+                case 256: return (VectorMask<E>) Long256Vector.Long256Mask.FALSE_MASK;
+                case 512: return (VectorMask<E>) Long512Vector.Long512Mask.FALSE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == float.class) {
+            if (species.boxType() == FloatMaxVector.class)
+                return (VectorMask<E>) FloatMaxVector.FloatMaxMask.FALSE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Float64Vector.Float64Mask.FALSE_MASK;
+                case 128: return (VectorMask<E>) Float128Vector.Float128Mask.FALSE_MASK;
+                case 256: return (VectorMask<E>) Float256Vector.Float256Mask.FALSE_MASK;
+                case 512: return (VectorMask<E>) Float512Vector.Float512Mask.FALSE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else if (eType == double.class) {
+            if (species.boxType() == DoubleMaxVector.class)
+                return (VectorMask<E>) DoubleMaxVector.DoubleMaxMask.FALSE_MASK;
+            switch (species.bitSize()) {
+                case 64: return (VectorMask<E>) Double64Vector.Double64Mask.FALSE_MASK;
+                case 128: return (VectorMask<E>) Double128Vector.Double128Mask.FALSE_MASK;
+                case 256: return (VectorMask<E>) Double256Vector.Double256Mask.FALSE_MASK;
+                case 512: return (VectorMask<E>) Double512Vector.Double512Mask.FALSE_MASK;
+                default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
+            }
+        } else {
+            throw new IllegalArgumentException("Bad element type of species");
+        }
+    }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractShuffle.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractShuffle.java	Fri Apr 19 04:44:47 2019 +0200
@@ -26,7 +26,7 @@
 
 import java.util.function.IntUnaryOperator;
 
-abstract class AbstractShuffle<E> extends Vector.Shuffle<E> {
+abstract class AbstractShuffle<E> extends VectorShuffle<E> {
     static final IntUnaryOperator IDENTITY = i -> i;
 
     // Internal representation allows for a maximum index of 256
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("cast")
 final class Byte128Vector extends ByteVector {
-    private static final Species<Byte> SPECIES = ByteVector.SPECIES_128;
+    private static final VectorSpecies<Byte> SPECIES = ByteVector.SPECIES_128;
 
     static final Byte128Vector ZERO = new Byte128Vector();
 
@@ -73,7 +73,7 @@
     }
 
     @Override
-    Byte128Vector uOp(Mask<Byte> o, FUnOp f) {
+    Byte128Vector uOp(VectorMask<Byte> o, FUnOp f) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         boolean[] mbits = ((Byte128Mask)o).getBits();
@@ -97,7 +97,7 @@
     }
 
     @Override
-    Byte128Vector bOp(Vector<Byte> o1, Mask<Byte> o2, FBinOp f) {
+    Byte128Vector bOp(Vector<Byte> o1, VectorMask<Byte> o2, FBinOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = this.getElements();
         byte[] vec2 = ((Byte128Vector)o1).getElements();
@@ -123,7 +123,7 @@
     }
 
     @Override
-    Byte128Vector tOp(Vector<Byte> o1, Vector<Byte> o2, Mask<Byte> o3, FTriOp f) {
+    Byte128Vector tOp(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> o3, FTriOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = getElements();
         byte[] vec2 = ((Byte128Vector)o1).getElements();
@@ -146,7 +146,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -163,7 +163,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -172,37 +172,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -211,11 +211,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(byte.class)) {
-            return (Vector<F>) reshape((Species<Byte>)s);
+            return (Vector<F>) reshape((VectorSpecies<Byte>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -225,7 +225,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -290,7 +290,7 @@
 
     @Override
     @ForceInline
-    public ByteVector reshape(Species<Byte> s) {
+    public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -353,7 +353,7 @@
 
     @Override
     @ForceInline
-    public ByteVector add(byte o, Mask<Byte> m) {
+    public ByteVector add(byte o, VectorMask<Byte> m) {
         return add((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -365,7 +365,7 @@
 
     @Override
     @ForceInline
-    public ByteVector sub(byte o, Mask<Byte> m) {
+    public ByteVector sub(byte o, VectorMask<Byte> m) {
         return sub((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -377,7 +377,7 @@
 
     @Override
     @ForceInline
-    public ByteVector mul(byte o, Mask<Byte> m) {
+    public ByteVector mul(byte o, VectorMask<Byte> m) {
         return mul((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -395,43 +395,43 @@
 
     @Override
     @ForceInline
-    public Mask<Byte> equal(byte o) {
+    public VectorMask<Byte> equal(byte o) {
         return equal((Byte128Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> notEqual(byte o) {
+    public VectorMask<Byte> notEqual(byte o) {
         return notEqual((Byte128Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThan(byte o) {
+    public VectorMask<Byte> lessThan(byte o) {
         return lessThan((Byte128Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThanEq(byte o) {
+    public VectorMask<Byte> lessThanEq(byte o) {
         return lessThanEq((Byte128Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThan(byte o) {
+    public VectorMask<Byte> greaterThan(byte o) {
         return greaterThan((Byte128Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThanEq(byte o) {
+    public VectorMask<Byte> greaterThanEq(byte o) {
         return greaterThanEq((Byte128Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public ByteVector blend(byte o, Mask<Byte> m) {
+    public ByteVector blend(byte o, VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -444,7 +444,7 @@
 
     @Override
     @ForceInline
-    public ByteVector and(byte o, Mask<Byte> m) {
+    public ByteVector and(byte o, VectorMask<Byte> m) {
         return and((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -456,7 +456,7 @@
 
     @Override
     @ForceInline
-    public ByteVector or(byte o, Mask<Byte> m) {
+    public ByteVector or(byte o, VectorMask<Byte> m) {
         return or((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -468,7 +468,7 @@
 
     @Override
     @ForceInline
-    public ByteVector xor(byte o, Mask<Byte> m) {
+    public ByteVector xor(byte o, VectorMask<Byte> m) {
         return xor((Byte128Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @ForceInline
     @Override
-    public Byte128Vector neg(Mask<Byte> m) {
+    public Byte128Vector neg(VectorMask<Byte> m) {
         return blend(neg(), m);
     }
 
@@ -497,7 +497,7 @@
 
     @ForceInline
     @Override
-    public Byte128Vector abs(Mask<Byte> m) {
+    public Byte128Vector abs(VectorMask<Byte> m) {
         return blend(abs(), m);
     }
 
@@ -513,7 +513,7 @@
 
     @ForceInline
     @Override
-    public Byte128Vector not(Mask<Byte> m) {
+    public Byte128Vector not(VectorMask<Byte> m) {
         return blend(not(), m);
     }
     // Binary operations
@@ -531,7 +531,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector add(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector add(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(add(v), m);
     }
 
@@ -548,7 +548,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector sub(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector sub(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(sub(v), m);
     }
 
@@ -565,7 +565,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector mul(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector mul(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(mul(v), m);
     }
 
@@ -582,7 +582,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector min(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector min(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(min(v), m);
     }
 
@@ -599,7 +599,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector max(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector max(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(max(v), m);
     }
 
@@ -638,19 +638,19 @@
 
     @Override
     @ForceInline
-    public Byte128Vector and(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector and(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(and(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte128Vector or(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector or(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(or(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte128Vector xor(Vector<Byte> v, Mask<Byte> m) {
+    public Byte128Vector xor(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(xor(v), m);
     }
 
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector shiftL(int s, Mask<Byte> m) {
+    public Byte128Vector shiftL(int s, VectorMask<Byte> m) {
         return blend(shiftL(s), m);
     }
 
@@ -680,7 +680,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector shiftR(int s, Mask<Byte> m) {
+    public Byte128Vector shiftR(int s, VectorMask<Byte> m) {
         return blend(shiftR(s), m);
     }
 
@@ -695,7 +695,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector aShiftR(int s, Mask<Byte> m) {
+    public Byte128Vector aShiftR(int s, VectorMask<Byte> m) {
         return blend(aShiftR(s), m);
     }
     // Ternary operations
@@ -723,7 +723,7 @@
 
     @Override
     @ForceInline
-    public byte andAll(Mask<Byte> m) {
+    public byte andAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, (byte) -1), m).andAll();
     }
 
@@ -765,7 +765,7 @@
 
     @Override
     @ForceInline
-    public byte orAll(Mask<Byte> m) {
+    public byte orAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).orAll();
     }
 
@@ -780,45 +780,45 @@
 
     @Override
     @ForceInline
-    public byte xorAll(Mask<Byte> m) {
+    public byte xorAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).xorAll();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(Mask<Byte> m) {
+    public byte addAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(Mask<Byte> m) {
+    public byte mulAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, (byte) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public byte minAll(Mask<Byte> m) {
+    public byte minAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(Mask<Byte> m) {
+    public byte maxAll(VectorMask<Byte> m) {
         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Byte> toShuffle() {
+    public VectorShuffle<Byte> toShuffle() {
         byte[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return ByteVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -840,7 +840,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(byte[] a, int ax, Mask<Byte> m) {
+    public final void intoArray(byte[] a, int ax, VectorMask<Byte> m) {
         ByteVector oldVal = ByteVector.fromArray(SPECIES, a, ax);
         ByteVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -864,7 +864,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Byte> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Byte> m) {
         Byte128Vector oldVal = (Byte128Vector) ByteVector.fromByteArray(SPECIES, a, ix);
         Byte128Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -893,7 +893,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Byte> m) {
         Byte128Vector oldVal = (Byte128Vector) ByteVector.fromByteBuffer(SPECIES, bb, ix);
         Byte128Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1018,7 +1018,7 @@
     }
 
     @Override
-    void forEach(Mask<Byte> o, FUnCon f) {
+    void forEach(VectorMask<Byte> o, FUnCon f) {
         boolean[] mbits = ((Byte128Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1075,13 +1075,13 @@
     @Override
     @ForceInline
     public Byte128Vector rearrange(Vector<Byte> v,
-                                  Shuffle<Byte> s, Mask<Byte> m) {
+                                  VectorShuffle<Byte> s, VectorMask<Byte> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte128Vector rearrange(Shuffle<Byte> o1) {
+    public Byte128Vector rearrange(VectorShuffle<Byte> o1) {
         Objects.requireNonNull(o1);
         Byte128Shuffle s =  (Byte128Shuffle)o1;
 
@@ -1096,7 +1096,7 @@
 
     @Override
     @ForceInline
-    public Byte128Vector blend(Vector<Byte> o1, Mask<Byte> o2) {
+    public Byte128Vector blend(Vector<Byte> o1, VectorMask<Byte> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Byte128Vector v = (Byte128Vector)o1;
@@ -1180,7 +1180,7 @@
         }
 
         @Override
-        Byte128Mask bOp(Mask<Byte> o, MBinOp f) {
+        Byte128Mask bOp(VectorMask<Byte> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Byte128Mask)o).getBits();
@@ -1191,7 +1191,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1210,23 +1210,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte128Vector.Byte128Mask(maskArray);
+                return (VectorMask <E>) new Byte128Vector.Byte128Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short128Vector.Short128Mask(maskArray);
+                return (VectorMask <E>) new Short128Vector.Short128Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int128Vector.Int128Mask(maskArray);
+                return (VectorMask <E>) new Int128Vector.Int128Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long128Vector.Long128Mask(maskArray);
+                return (VectorMask <E>) new Long128Vector.Long128Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float128Vector.Float128Mask(maskArray);
+                return (VectorMask <E>) new Float128Vector.Float128Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double128Vector.Double128Mask(maskArray);
+                return (VectorMask <E>) new Double128Vector.Double128Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1247,7 +1247,7 @@
 
         @Override
         @ForceInline
-        public Byte128Mask and(Mask<Byte> o) {
+        public Byte128Mask and(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte128Mask m = (Byte128Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Byte128Mask.class, byte.class, LENGTH,
@@ -1257,7 +1257,7 @@
 
         @Override
         @ForceInline
-        public Byte128Mask or(Mask<Byte> o) {
+        public Byte128Mask or(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte128Mask m = (Byte128Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte128Mask.class, byte.class, LENGTH,
@@ -1279,7 +1279,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Byte128Mask.class, byte.class, LENGTH,
-                                         this, ByteVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Byte128Mask)m).getBits()));
         }
     }
@@ -1304,7 +1304,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1320,30 +1320,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Byte128Shuffle rearrange(Vector.Shuffle<Byte> o) {
+        public Byte128Shuffle rearrange(VectorShuffle<Byte> o) {
             Byte128Shuffle s = (Byte128Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1353,10 +1353,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Byte> species() {
+    public VectorSpecies<Byte> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte256Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("cast")
 final class Byte256Vector extends ByteVector {
-    private static final Species<Byte> SPECIES = ByteVector.SPECIES_256;
+    private static final VectorSpecies<Byte> SPECIES = ByteVector.SPECIES_256;
 
     static final Byte256Vector ZERO = new Byte256Vector();
 
@@ -73,7 +73,7 @@
     }
 
     @Override
-    Byte256Vector uOp(Mask<Byte> o, FUnOp f) {
+    Byte256Vector uOp(VectorMask<Byte> o, FUnOp f) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         boolean[] mbits = ((Byte256Mask)o).getBits();
@@ -97,7 +97,7 @@
     }
 
     @Override
-    Byte256Vector bOp(Vector<Byte> o1, Mask<Byte> o2, FBinOp f) {
+    Byte256Vector bOp(Vector<Byte> o1, VectorMask<Byte> o2, FBinOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = this.getElements();
         byte[] vec2 = ((Byte256Vector)o1).getElements();
@@ -123,7 +123,7 @@
     }
 
     @Override
-    Byte256Vector tOp(Vector<Byte> o1, Vector<Byte> o2, Mask<Byte> o3, FTriOp f) {
+    Byte256Vector tOp(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> o3, FTriOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = getElements();
         byte[] vec2 = ((Byte256Vector)o1).getElements();
@@ -146,7 +146,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -163,7 +163,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -172,37 +172,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -211,11 +211,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(byte.class)) {
-            return (Vector<F>) reshape((Species<Byte>)s);
+            return (Vector<F>) reshape((VectorSpecies<Byte>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -225,7 +225,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -290,7 +290,7 @@
 
     @Override
     @ForceInline
-    public ByteVector reshape(Species<Byte> s) {
+    public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -353,7 +353,7 @@
 
     @Override
     @ForceInline
-    public ByteVector add(byte o, Mask<Byte> m) {
+    public ByteVector add(byte o, VectorMask<Byte> m) {
         return add((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -365,7 +365,7 @@
 
     @Override
     @ForceInline
-    public ByteVector sub(byte o, Mask<Byte> m) {
+    public ByteVector sub(byte o, VectorMask<Byte> m) {
         return sub((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -377,7 +377,7 @@
 
     @Override
     @ForceInline
-    public ByteVector mul(byte o, Mask<Byte> m) {
+    public ByteVector mul(byte o, VectorMask<Byte> m) {
         return mul((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -395,43 +395,43 @@
 
     @Override
     @ForceInline
-    public Mask<Byte> equal(byte o) {
+    public VectorMask<Byte> equal(byte o) {
         return equal((Byte256Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> notEqual(byte o) {
+    public VectorMask<Byte> notEqual(byte o) {
         return notEqual((Byte256Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThan(byte o) {
+    public VectorMask<Byte> lessThan(byte o) {
         return lessThan((Byte256Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThanEq(byte o) {
+    public VectorMask<Byte> lessThanEq(byte o) {
         return lessThanEq((Byte256Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThan(byte o) {
+    public VectorMask<Byte> greaterThan(byte o) {
         return greaterThan((Byte256Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThanEq(byte o) {
+    public VectorMask<Byte> greaterThanEq(byte o) {
         return greaterThanEq((Byte256Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public ByteVector blend(byte o, Mask<Byte> m) {
+    public ByteVector blend(byte o, VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -444,7 +444,7 @@
 
     @Override
     @ForceInline
-    public ByteVector and(byte o, Mask<Byte> m) {
+    public ByteVector and(byte o, VectorMask<Byte> m) {
         return and((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -456,7 +456,7 @@
 
     @Override
     @ForceInline
-    public ByteVector or(byte o, Mask<Byte> m) {
+    public ByteVector or(byte o, VectorMask<Byte> m) {
         return or((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -468,7 +468,7 @@
 
     @Override
     @ForceInline
-    public ByteVector xor(byte o, Mask<Byte> m) {
+    public ByteVector xor(byte o, VectorMask<Byte> m) {
         return xor((Byte256Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @ForceInline
     @Override
-    public Byte256Vector neg(Mask<Byte> m) {
+    public Byte256Vector neg(VectorMask<Byte> m) {
         return blend(neg(), m);
     }
 
@@ -497,7 +497,7 @@
 
     @ForceInline
     @Override
-    public Byte256Vector abs(Mask<Byte> m) {
+    public Byte256Vector abs(VectorMask<Byte> m) {
         return blend(abs(), m);
     }
 
@@ -513,7 +513,7 @@
 
     @ForceInline
     @Override
-    public Byte256Vector not(Mask<Byte> m) {
+    public Byte256Vector not(VectorMask<Byte> m) {
         return blend(not(), m);
     }
     // Binary operations
@@ -531,7 +531,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector add(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector add(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(add(v), m);
     }
 
@@ -548,7 +548,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector sub(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector sub(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(sub(v), m);
     }
 
@@ -565,7 +565,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector mul(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector mul(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(mul(v), m);
     }
 
@@ -582,7 +582,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector min(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector min(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(min(v), m);
     }
 
@@ -599,7 +599,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector max(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector max(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(max(v), m);
     }
 
@@ -638,19 +638,19 @@
 
     @Override
     @ForceInline
-    public Byte256Vector and(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector and(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(and(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte256Vector or(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector or(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(or(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte256Vector xor(Vector<Byte> v, Mask<Byte> m) {
+    public Byte256Vector xor(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(xor(v), m);
     }
 
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector shiftL(int s, Mask<Byte> m) {
+    public Byte256Vector shiftL(int s, VectorMask<Byte> m) {
         return blend(shiftL(s), m);
     }
 
@@ -680,7 +680,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector shiftR(int s, Mask<Byte> m) {
+    public Byte256Vector shiftR(int s, VectorMask<Byte> m) {
         return blend(shiftR(s), m);
     }
 
@@ -695,7 +695,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector aShiftR(int s, Mask<Byte> m) {
+    public Byte256Vector aShiftR(int s, VectorMask<Byte> m) {
         return blend(aShiftR(s), m);
     }
     // Ternary operations
@@ -723,7 +723,7 @@
 
     @Override
     @ForceInline
-    public byte andAll(Mask<Byte> m) {
+    public byte andAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, (byte) -1), m).andAll();
     }
 
@@ -765,7 +765,7 @@
 
     @Override
     @ForceInline
-    public byte orAll(Mask<Byte> m) {
+    public byte orAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).orAll();
     }
 
@@ -780,45 +780,45 @@
 
     @Override
     @ForceInline
-    public byte xorAll(Mask<Byte> m) {
+    public byte xorAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).xorAll();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(Mask<Byte> m) {
+    public byte addAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(Mask<Byte> m) {
+    public byte mulAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, (byte) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public byte minAll(Mask<Byte> m) {
+    public byte minAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(Mask<Byte> m) {
+    public byte maxAll(VectorMask<Byte> m) {
         return blend((Byte256Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Byte> toShuffle() {
+    public VectorShuffle<Byte> toShuffle() {
         byte[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return ByteVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -840,7 +840,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(byte[] a, int ax, Mask<Byte> m) {
+    public final void intoArray(byte[] a, int ax, VectorMask<Byte> m) {
         ByteVector oldVal = ByteVector.fromArray(SPECIES, a, ax);
         ByteVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -864,7 +864,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Byte> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Byte> m) {
         Byte256Vector oldVal = (Byte256Vector) ByteVector.fromByteArray(SPECIES, a, ix);
         Byte256Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -893,7 +893,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Byte> m) {
         Byte256Vector oldVal = (Byte256Vector) ByteVector.fromByteBuffer(SPECIES, bb, ix);
         Byte256Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1018,7 +1018,7 @@
     }
 
     @Override
-    void forEach(Mask<Byte> o, FUnCon f) {
+    void forEach(VectorMask<Byte> o, FUnCon f) {
         boolean[] mbits = ((Byte256Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1075,13 +1075,13 @@
     @Override
     @ForceInline
     public Byte256Vector rearrange(Vector<Byte> v,
-                                  Shuffle<Byte> s, Mask<Byte> m) {
+                                  VectorShuffle<Byte> s, VectorMask<Byte> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte256Vector rearrange(Shuffle<Byte> o1) {
+    public Byte256Vector rearrange(VectorShuffle<Byte> o1) {
         Objects.requireNonNull(o1);
         Byte256Shuffle s =  (Byte256Shuffle)o1;
 
@@ -1096,7 +1096,7 @@
 
     @Override
     @ForceInline
-    public Byte256Vector blend(Vector<Byte> o1, Mask<Byte> o2) {
+    public Byte256Vector blend(Vector<Byte> o1, VectorMask<Byte> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Byte256Vector v = (Byte256Vector)o1;
@@ -1180,7 +1180,7 @@
         }
 
         @Override
-        Byte256Mask bOp(Mask<Byte> o, MBinOp f) {
+        Byte256Mask bOp(VectorMask<Byte> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Byte256Mask)o).getBits();
@@ -1191,7 +1191,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1210,23 +1210,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte256Vector.Byte256Mask(maskArray);
+                return (VectorMask <E>) new Byte256Vector.Byte256Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short256Vector.Short256Mask(maskArray);
+                return (VectorMask <E>) new Short256Vector.Short256Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int256Vector.Int256Mask(maskArray);
+                return (VectorMask <E>) new Int256Vector.Int256Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long256Vector.Long256Mask(maskArray);
+                return (VectorMask <E>) new Long256Vector.Long256Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float256Vector.Float256Mask(maskArray);
+                return (VectorMask <E>) new Float256Vector.Float256Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double256Vector.Double256Mask(maskArray);
+                return (VectorMask <E>) new Double256Vector.Double256Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1247,7 +1247,7 @@
 
         @Override
         @ForceInline
-        public Byte256Mask and(Mask<Byte> o) {
+        public Byte256Mask and(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte256Mask m = (Byte256Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Byte256Mask.class, byte.class, LENGTH,
@@ -1257,7 +1257,7 @@
 
         @Override
         @ForceInline
-        public Byte256Mask or(Mask<Byte> o) {
+        public Byte256Mask or(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte256Mask m = (Byte256Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte256Mask.class, byte.class, LENGTH,
@@ -1279,7 +1279,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Byte256Mask.class, byte.class, LENGTH,
-                                         this, ByteVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Byte256Mask)m).getBits()));
         }
     }
@@ -1304,7 +1304,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1320,30 +1320,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Byte256Shuffle rearrange(Vector.Shuffle<Byte> o) {
+        public Byte256Shuffle rearrange(VectorShuffle<Byte> o) {
             Byte256Shuffle s = (Byte256Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1353,10 +1353,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Byte> species() {
+    public VectorSpecies<Byte> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte512Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("cast")
 final class Byte512Vector extends ByteVector {
-    private static final Species<Byte> SPECIES = ByteVector.SPECIES_512;
+    private static final VectorSpecies<Byte> SPECIES = ByteVector.SPECIES_512;
 
     static final Byte512Vector ZERO = new Byte512Vector();
 
@@ -73,7 +73,7 @@
     }
 
     @Override
-    Byte512Vector uOp(Mask<Byte> o, FUnOp f) {
+    Byte512Vector uOp(VectorMask<Byte> o, FUnOp f) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         boolean[] mbits = ((Byte512Mask)o).getBits();
@@ -97,7 +97,7 @@
     }
 
     @Override
-    Byte512Vector bOp(Vector<Byte> o1, Mask<Byte> o2, FBinOp f) {
+    Byte512Vector bOp(Vector<Byte> o1, VectorMask<Byte> o2, FBinOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = this.getElements();
         byte[] vec2 = ((Byte512Vector)o1).getElements();
@@ -123,7 +123,7 @@
     }
 
     @Override
-    Byte512Vector tOp(Vector<Byte> o1, Vector<Byte> o2, Mask<Byte> o3, FTriOp f) {
+    Byte512Vector tOp(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> o3, FTriOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = getElements();
         byte[] vec2 = ((Byte512Vector)o1).getElements();
@@ -146,7 +146,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -163,7 +163,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -172,37 +172,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -211,11 +211,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(byte.class)) {
-            return (Vector<F>) reshape((Species<Byte>)s);
+            return (Vector<F>) reshape((VectorSpecies<Byte>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -225,7 +225,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -290,7 +290,7 @@
 
     @Override
     @ForceInline
-    public ByteVector reshape(Species<Byte> s) {
+    public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -353,7 +353,7 @@
 
     @Override
     @ForceInline
-    public ByteVector add(byte o, Mask<Byte> m) {
+    public ByteVector add(byte o, VectorMask<Byte> m) {
         return add((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -365,7 +365,7 @@
 
     @Override
     @ForceInline
-    public ByteVector sub(byte o, Mask<Byte> m) {
+    public ByteVector sub(byte o, VectorMask<Byte> m) {
         return sub((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -377,7 +377,7 @@
 
     @Override
     @ForceInline
-    public ByteVector mul(byte o, Mask<Byte> m) {
+    public ByteVector mul(byte o, VectorMask<Byte> m) {
         return mul((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -395,43 +395,43 @@
 
     @Override
     @ForceInline
-    public Mask<Byte> equal(byte o) {
+    public VectorMask<Byte> equal(byte o) {
         return equal((Byte512Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> notEqual(byte o) {
+    public VectorMask<Byte> notEqual(byte o) {
         return notEqual((Byte512Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThan(byte o) {
+    public VectorMask<Byte> lessThan(byte o) {
         return lessThan((Byte512Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThanEq(byte o) {
+    public VectorMask<Byte> lessThanEq(byte o) {
         return lessThanEq((Byte512Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThan(byte o) {
+    public VectorMask<Byte> greaterThan(byte o) {
         return greaterThan((Byte512Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThanEq(byte o) {
+    public VectorMask<Byte> greaterThanEq(byte o) {
         return greaterThanEq((Byte512Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public ByteVector blend(byte o, Mask<Byte> m) {
+    public ByteVector blend(byte o, VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -444,7 +444,7 @@
 
     @Override
     @ForceInline
-    public ByteVector and(byte o, Mask<Byte> m) {
+    public ByteVector and(byte o, VectorMask<Byte> m) {
         return and((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -456,7 +456,7 @@
 
     @Override
     @ForceInline
-    public ByteVector or(byte o, Mask<Byte> m) {
+    public ByteVector or(byte o, VectorMask<Byte> m) {
         return or((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -468,7 +468,7 @@
 
     @Override
     @ForceInline
-    public ByteVector xor(byte o, Mask<Byte> m) {
+    public ByteVector xor(byte o, VectorMask<Byte> m) {
         return xor((Byte512Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @ForceInline
     @Override
-    public Byte512Vector neg(Mask<Byte> m) {
+    public Byte512Vector neg(VectorMask<Byte> m) {
         return blend(neg(), m);
     }
 
@@ -497,7 +497,7 @@
 
     @ForceInline
     @Override
-    public Byte512Vector abs(Mask<Byte> m) {
+    public Byte512Vector abs(VectorMask<Byte> m) {
         return blend(abs(), m);
     }
 
@@ -513,7 +513,7 @@
 
     @ForceInline
     @Override
-    public Byte512Vector not(Mask<Byte> m) {
+    public Byte512Vector not(VectorMask<Byte> m) {
         return blend(not(), m);
     }
     // Binary operations
@@ -531,7 +531,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector add(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector add(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(add(v), m);
     }
 
@@ -548,7 +548,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector sub(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector sub(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(sub(v), m);
     }
 
@@ -565,7 +565,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector mul(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector mul(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(mul(v), m);
     }
 
@@ -582,7 +582,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector min(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector min(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(min(v), m);
     }
 
@@ -599,7 +599,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector max(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector max(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(max(v), m);
     }
 
@@ -638,19 +638,19 @@
 
     @Override
     @ForceInline
-    public Byte512Vector and(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector and(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(and(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte512Vector or(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector or(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(or(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte512Vector xor(Vector<Byte> v, Mask<Byte> m) {
+    public Byte512Vector xor(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(xor(v), m);
     }
 
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector shiftL(int s, Mask<Byte> m) {
+    public Byte512Vector shiftL(int s, VectorMask<Byte> m) {
         return blend(shiftL(s), m);
     }
 
@@ -680,7 +680,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector shiftR(int s, Mask<Byte> m) {
+    public Byte512Vector shiftR(int s, VectorMask<Byte> m) {
         return blend(shiftR(s), m);
     }
 
@@ -695,7 +695,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector aShiftR(int s, Mask<Byte> m) {
+    public Byte512Vector aShiftR(int s, VectorMask<Byte> m) {
         return blend(aShiftR(s), m);
     }
     // Ternary operations
@@ -723,7 +723,7 @@
 
     @Override
     @ForceInline
-    public byte andAll(Mask<Byte> m) {
+    public byte andAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, (byte) -1), m).andAll();
     }
 
@@ -765,7 +765,7 @@
 
     @Override
     @ForceInline
-    public byte orAll(Mask<Byte> m) {
+    public byte orAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).orAll();
     }
 
@@ -780,45 +780,45 @@
 
     @Override
     @ForceInline
-    public byte xorAll(Mask<Byte> m) {
+    public byte xorAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).xorAll();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(Mask<Byte> m) {
+    public byte addAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(Mask<Byte> m) {
+    public byte mulAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, (byte) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public byte minAll(Mask<Byte> m) {
+    public byte minAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(Mask<Byte> m) {
+    public byte maxAll(VectorMask<Byte> m) {
         return blend((Byte512Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Byte> toShuffle() {
+    public VectorShuffle<Byte> toShuffle() {
         byte[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return ByteVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -840,7 +840,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(byte[] a, int ax, Mask<Byte> m) {
+    public final void intoArray(byte[] a, int ax, VectorMask<Byte> m) {
         ByteVector oldVal = ByteVector.fromArray(SPECIES, a, ax);
         ByteVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -864,7 +864,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Byte> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Byte> m) {
         Byte512Vector oldVal = (Byte512Vector) ByteVector.fromByteArray(SPECIES, a, ix);
         Byte512Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -893,7 +893,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Byte> m) {
         Byte512Vector oldVal = (Byte512Vector) ByteVector.fromByteBuffer(SPECIES, bb, ix);
         Byte512Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1018,7 +1018,7 @@
     }
 
     @Override
-    void forEach(Mask<Byte> o, FUnCon f) {
+    void forEach(VectorMask<Byte> o, FUnCon f) {
         boolean[] mbits = ((Byte512Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1075,13 +1075,13 @@
     @Override
     @ForceInline
     public Byte512Vector rearrange(Vector<Byte> v,
-                                  Shuffle<Byte> s, Mask<Byte> m) {
+                                  VectorShuffle<Byte> s, VectorMask<Byte> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte512Vector rearrange(Shuffle<Byte> o1) {
+    public Byte512Vector rearrange(VectorShuffle<Byte> o1) {
         Objects.requireNonNull(o1);
         Byte512Shuffle s =  (Byte512Shuffle)o1;
 
@@ -1096,7 +1096,7 @@
 
     @Override
     @ForceInline
-    public Byte512Vector blend(Vector<Byte> o1, Mask<Byte> o2) {
+    public Byte512Vector blend(Vector<Byte> o1, VectorMask<Byte> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Byte512Vector v = (Byte512Vector)o1;
@@ -1180,7 +1180,7 @@
         }
 
         @Override
-        Byte512Mask bOp(Mask<Byte> o, MBinOp f) {
+        Byte512Mask bOp(VectorMask<Byte> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Byte512Mask)o).getBits();
@@ -1191,7 +1191,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1210,23 +1210,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte512Vector.Byte512Mask(maskArray);
+                return (VectorMask <E>) new Byte512Vector.Byte512Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short512Vector.Short512Mask(maskArray);
+                return (VectorMask <E>) new Short512Vector.Short512Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int512Vector.Int512Mask(maskArray);
+                return (VectorMask <E>) new Int512Vector.Int512Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long512Vector.Long512Mask(maskArray);
+                return (VectorMask <E>) new Long512Vector.Long512Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float512Vector.Float512Mask(maskArray);
+                return (VectorMask <E>) new Float512Vector.Float512Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double512Vector.Double512Mask(maskArray);
+                return (VectorMask <E>) new Double512Vector.Double512Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1247,7 +1247,7 @@
 
         @Override
         @ForceInline
-        public Byte512Mask and(Mask<Byte> o) {
+        public Byte512Mask and(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte512Mask m = (Byte512Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Byte512Mask.class, byte.class, LENGTH,
@@ -1257,7 +1257,7 @@
 
         @Override
         @ForceInline
-        public Byte512Mask or(Mask<Byte> o) {
+        public Byte512Mask or(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte512Mask m = (Byte512Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte512Mask.class, byte.class, LENGTH,
@@ -1279,7 +1279,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Byte512Mask.class, byte.class, LENGTH,
-                                         this, ByteVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Byte512Mask)m).getBits()));
         }
     }
@@ -1304,7 +1304,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1320,30 +1320,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte512Vector.Byte512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte512Vector.Byte512Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short512Vector.Short512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short512Vector.Short512Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int512Vector.Int512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int512Vector.Int512Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long512Vector.Long512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long512Vector.Long512Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float512Vector.Float512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float512Vector.Float512Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double512Vector.Double512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double512Vector.Double512Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Byte512Shuffle rearrange(Vector.Shuffle<Byte> o) {
+        public Byte512Shuffle rearrange(VectorShuffle<Byte> o) {
             Byte512Shuffle s = (Byte512Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1353,10 +1353,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Byte> species() {
+    public VectorSpecies<Byte> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte64Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("cast")
 final class Byte64Vector extends ByteVector {
-    private static final Species<Byte> SPECIES = ByteVector.SPECIES_64;
+    private static final VectorSpecies<Byte> SPECIES = ByteVector.SPECIES_64;
 
     static final Byte64Vector ZERO = new Byte64Vector();
 
@@ -73,7 +73,7 @@
     }
 
     @Override
-    Byte64Vector uOp(Mask<Byte> o, FUnOp f) {
+    Byte64Vector uOp(VectorMask<Byte> o, FUnOp f) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         boolean[] mbits = ((Byte64Mask)o).getBits();
@@ -97,7 +97,7 @@
     }
 
     @Override
-    Byte64Vector bOp(Vector<Byte> o1, Mask<Byte> o2, FBinOp f) {
+    Byte64Vector bOp(Vector<Byte> o1, VectorMask<Byte> o2, FBinOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = this.getElements();
         byte[] vec2 = ((Byte64Vector)o1).getElements();
@@ -123,7 +123,7 @@
     }
 
     @Override
-    Byte64Vector tOp(Vector<Byte> o1, Vector<Byte> o2, Mask<Byte> o3, FTriOp f) {
+    Byte64Vector tOp(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> o3, FTriOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = getElements();
         byte[] vec2 = ((Byte64Vector)o1).getElements();
@@ -146,7 +146,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -163,7 +163,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -172,37 +172,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -211,11 +211,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(byte.class)) {
-            return (Vector<F>) reshape((Species<Byte>)s);
+            return (Vector<F>) reshape((VectorSpecies<Byte>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -225,7 +225,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -290,7 +290,7 @@
 
     @Override
     @ForceInline
-    public ByteVector reshape(Species<Byte> s) {
+    public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -353,7 +353,7 @@
 
     @Override
     @ForceInline
-    public ByteVector add(byte o, Mask<Byte> m) {
+    public ByteVector add(byte o, VectorMask<Byte> m) {
         return add((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -365,7 +365,7 @@
 
     @Override
     @ForceInline
-    public ByteVector sub(byte o, Mask<Byte> m) {
+    public ByteVector sub(byte o, VectorMask<Byte> m) {
         return sub((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -377,7 +377,7 @@
 
     @Override
     @ForceInline
-    public ByteVector mul(byte o, Mask<Byte> m) {
+    public ByteVector mul(byte o, VectorMask<Byte> m) {
         return mul((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -395,43 +395,43 @@
 
     @Override
     @ForceInline
-    public Mask<Byte> equal(byte o) {
+    public VectorMask<Byte> equal(byte o) {
         return equal((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> notEqual(byte o) {
+    public VectorMask<Byte> notEqual(byte o) {
         return notEqual((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThan(byte o) {
+    public VectorMask<Byte> lessThan(byte o) {
         return lessThan((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThanEq(byte o) {
+    public VectorMask<Byte> lessThanEq(byte o) {
         return lessThanEq((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThan(byte o) {
+    public VectorMask<Byte> greaterThan(byte o) {
         return greaterThan((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThanEq(byte o) {
+    public VectorMask<Byte> greaterThanEq(byte o) {
         return greaterThanEq((Byte64Vector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public ByteVector blend(byte o, Mask<Byte> m) {
+    public ByteVector blend(byte o, VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -444,7 +444,7 @@
 
     @Override
     @ForceInline
-    public ByteVector and(byte o, Mask<Byte> m) {
+    public ByteVector and(byte o, VectorMask<Byte> m) {
         return and((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -456,7 +456,7 @@
 
     @Override
     @ForceInline
-    public ByteVector or(byte o, Mask<Byte> m) {
+    public ByteVector or(byte o, VectorMask<Byte> m) {
         return or((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -468,7 +468,7 @@
 
     @Override
     @ForceInline
-    public ByteVector xor(byte o, Mask<Byte> m) {
+    public ByteVector xor(byte o, VectorMask<Byte> m) {
         return xor((Byte64Vector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @ForceInline
     @Override
-    public Byte64Vector neg(Mask<Byte> m) {
+    public Byte64Vector neg(VectorMask<Byte> m) {
         return blend(neg(), m);
     }
 
@@ -497,7 +497,7 @@
 
     @ForceInline
     @Override
-    public Byte64Vector abs(Mask<Byte> m) {
+    public Byte64Vector abs(VectorMask<Byte> m) {
         return blend(abs(), m);
     }
 
@@ -513,7 +513,7 @@
 
     @ForceInline
     @Override
-    public Byte64Vector not(Mask<Byte> m) {
+    public Byte64Vector not(VectorMask<Byte> m) {
         return blend(not(), m);
     }
     // Binary operations
@@ -531,7 +531,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector add(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector add(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(add(v), m);
     }
 
@@ -548,7 +548,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector sub(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector sub(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(sub(v), m);
     }
 
@@ -565,7 +565,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector mul(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector mul(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(mul(v), m);
     }
 
@@ -582,7 +582,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector min(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector min(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(min(v), m);
     }
 
@@ -599,7 +599,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector max(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector max(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(max(v), m);
     }
 
@@ -638,19 +638,19 @@
 
     @Override
     @ForceInline
-    public Byte64Vector and(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector and(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(and(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte64Vector or(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector or(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(or(v), m);
     }
 
     @Override
     @ForceInline
-    public Byte64Vector xor(Vector<Byte> v, Mask<Byte> m) {
+    public Byte64Vector xor(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(xor(v), m);
     }
 
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector shiftL(int s, Mask<Byte> m) {
+    public Byte64Vector shiftL(int s, VectorMask<Byte> m) {
         return blend(shiftL(s), m);
     }
 
@@ -680,7 +680,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector shiftR(int s, Mask<Byte> m) {
+    public Byte64Vector shiftR(int s, VectorMask<Byte> m) {
         return blend(shiftR(s), m);
     }
 
@@ -695,7 +695,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector aShiftR(int s, Mask<Byte> m) {
+    public Byte64Vector aShiftR(int s, VectorMask<Byte> m) {
         return blend(aShiftR(s), m);
     }
     // Ternary operations
@@ -723,7 +723,7 @@
 
     @Override
     @ForceInline
-    public byte andAll(Mask<Byte> m) {
+    public byte andAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) -1), m).andAll();
     }
 
@@ -765,7 +765,7 @@
 
     @Override
     @ForceInline
-    public byte orAll(Mask<Byte> m) {
+    public byte orAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).orAll();
     }
 
@@ -780,45 +780,45 @@
 
     @Override
     @ForceInline
-    public byte xorAll(Mask<Byte> m) {
+    public byte xorAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).xorAll();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(Mask<Byte> m) {
+    public byte addAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(Mask<Byte> m) {
+    public byte mulAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, (byte) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public byte minAll(Mask<Byte> m) {
+    public byte minAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(Mask<Byte> m) {
+    public byte maxAll(VectorMask<Byte> m) {
         return blend((Byte64Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Byte> toShuffle() {
+    public VectorShuffle<Byte> toShuffle() {
         byte[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return ByteVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -840,7 +840,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(byte[] a, int ax, Mask<Byte> m) {
+    public final void intoArray(byte[] a, int ax, VectorMask<Byte> m) {
         ByteVector oldVal = ByteVector.fromArray(SPECIES, a, ax);
         ByteVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -864,7 +864,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Byte> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Byte> m) {
         Byte64Vector oldVal = (Byte64Vector) ByteVector.fromByteArray(SPECIES, a, ix);
         Byte64Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -893,7 +893,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Byte> m) {
         Byte64Vector oldVal = (Byte64Vector) ByteVector.fromByteBuffer(SPECIES, bb, ix);
         Byte64Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1018,7 +1018,7 @@
     }
 
     @Override
-    void forEach(Mask<Byte> o, FUnCon f) {
+    void forEach(VectorMask<Byte> o, FUnCon f) {
         boolean[] mbits = ((Byte64Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1075,13 +1075,13 @@
     @Override
     @ForceInline
     public Byte64Vector rearrange(Vector<Byte> v,
-                                  Shuffle<Byte> s, Mask<Byte> m) {
+                                  VectorShuffle<Byte> s, VectorMask<Byte> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Byte64Vector rearrange(Shuffle<Byte> o1) {
+    public Byte64Vector rearrange(VectorShuffle<Byte> o1) {
         Objects.requireNonNull(o1);
         Byte64Shuffle s =  (Byte64Shuffle)o1;
 
@@ -1096,7 +1096,7 @@
 
     @Override
     @ForceInline
-    public Byte64Vector blend(Vector<Byte> o1, Mask<Byte> o2) {
+    public Byte64Vector blend(Vector<Byte> o1, VectorMask<Byte> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Byte64Vector v = (Byte64Vector)o1;
@@ -1180,7 +1180,7 @@
         }
 
         @Override
-        Byte64Mask bOp(Mask<Byte> o, MBinOp f) {
+        Byte64Mask bOp(VectorMask<Byte> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Byte64Mask)o).getBits();
@@ -1191,7 +1191,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1210,23 +1210,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte64Vector.Byte64Mask(maskArray);
+                return (VectorMask <E>) new Byte64Vector.Byte64Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short64Vector.Short64Mask(maskArray);
+                return (VectorMask <E>) new Short64Vector.Short64Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int64Vector.Int64Mask(maskArray);
+                return (VectorMask <E>) new Int64Vector.Int64Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long64Vector.Long64Mask(maskArray);
+                return (VectorMask <E>) new Long64Vector.Long64Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float64Vector.Float64Mask(maskArray);
+                return (VectorMask <E>) new Float64Vector.Float64Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double64Vector.Double64Mask(maskArray);
+                return (VectorMask <E>) new Double64Vector.Double64Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1247,7 +1247,7 @@
 
         @Override
         @ForceInline
-        public Byte64Mask and(Mask<Byte> o) {
+        public Byte64Mask and(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte64Mask m = (Byte64Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Byte64Mask.class, byte.class, LENGTH,
@@ -1257,7 +1257,7 @@
 
         @Override
         @ForceInline
-        public Byte64Mask or(Mask<Byte> o) {
+        public Byte64Mask or(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             Byte64Mask m = (Byte64Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte64Mask.class, byte.class, LENGTH,
@@ -1279,7 +1279,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Byte64Mask.class, byte.class, LENGTH,
-                                         this, ByteVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Byte64Mask)m).getBits()));
         }
     }
@@ -1304,7 +1304,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1320,30 +1320,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Byte64Shuffle rearrange(Vector.Shuffle<Byte> o) {
+        public Byte64Shuffle rearrange(VectorShuffle<Byte> o) {
             Byte64Shuffle s = (Byte64Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1353,10 +1353,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Byte> species() {
+    public VectorSpecies<Byte> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteMaxVector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("cast")
 final class ByteMaxVector extends ByteVector {
-    private static final Species<Byte> SPECIES = ByteVector.SPECIES_MAX;
+    private static final VectorSpecies<Byte> SPECIES = ByteVector.SPECIES_MAX;
 
     static final ByteMaxVector ZERO = new ByteMaxVector();
 
@@ -73,7 +73,7 @@
     }
 
     @Override
-    ByteMaxVector uOp(Mask<Byte> o, FUnOp f) {
+    ByteMaxVector uOp(VectorMask<Byte> o, FUnOp f) {
         byte[] vec = getElements();
         byte[] res = new byte[length()];
         boolean[] mbits = ((ByteMaxMask)o).getBits();
@@ -97,7 +97,7 @@
     }
 
     @Override
-    ByteMaxVector bOp(Vector<Byte> o1, Mask<Byte> o2, FBinOp f) {
+    ByteMaxVector bOp(Vector<Byte> o1, VectorMask<Byte> o2, FBinOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = this.getElements();
         byte[] vec2 = ((ByteMaxVector)o1).getElements();
@@ -123,7 +123,7 @@
     }
 
     @Override
-    ByteMaxVector tOp(Vector<Byte> o1, Vector<Byte> o2, Mask<Byte> o3, FTriOp f) {
+    ByteMaxVector tOp(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> o3, FTriOp f) {
         byte[] res = new byte[length()];
         byte[] vec1 = getElements();
         byte[] vec2 = ((ByteMaxVector)o1).getElements();
@@ -146,7 +146,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -163,7 +163,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -172,37 +172,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -211,11 +211,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(byte.class)) {
-            return (Vector<F>) reshape((Species<Byte>)s);
+            return (Vector<F>) reshape((VectorSpecies<Byte>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -225,7 +225,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -290,7 +290,7 @@
 
     @Override
     @ForceInline
-    public ByteVector reshape(Species<Byte> s) {
+    public ByteVector reshape(VectorSpecies<Byte> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Byte64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -353,7 +353,7 @@
 
     @Override
     @ForceInline
-    public ByteVector add(byte o, Mask<Byte> m) {
+    public ByteVector add(byte o, VectorMask<Byte> m) {
         return add((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -365,7 +365,7 @@
 
     @Override
     @ForceInline
-    public ByteVector sub(byte o, Mask<Byte> m) {
+    public ByteVector sub(byte o, VectorMask<Byte> m) {
         return sub((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -377,7 +377,7 @@
 
     @Override
     @ForceInline
-    public ByteVector mul(byte o, Mask<Byte> m) {
+    public ByteVector mul(byte o, VectorMask<Byte> m) {
         return mul((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -395,43 +395,43 @@
 
     @Override
     @ForceInline
-    public Mask<Byte> equal(byte o) {
+    public VectorMask<Byte> equal(byte o) {
         return equal((ByteMaxVector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> notEqual(byte o) {
+    public VectorMask<Byte> notEqual(byte o) {
         return notEqual((ByteMaxVector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThan(byte o) {
+    public VectorMask<Byte> lessThan(byte o) {
         return lessThan((ByteMaxVector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> lessThanEq(byte o) {
+    public VectorMask<Byte> lessThanEq(byte o) {
         return lessThanEq((ByteMaxVector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThan(byte o) {
+    public VectorMask<Byte> greaterThan(byte o) {
         return greaterThan((ByteMaxVector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Byte> greaterThanEq(byte o) {
+    public VectorMask<Byte> greaterThanEq(byte o) {
         return greaterThanEq((ByteMaxVector)ByteVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public ByteVector blend(byte o, Mask<Byte> m) {
+    public ByteVector blend(byte o, VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -444,7 +444,7 @@
 
     @Override
     @ForceInline
-    public ByteVector and(byte o, Mask<Byte> m) {
+    public ByteVector and(byte o, VectorMask<Byte> m) {
         return and((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -456,7 +456,7 @@
 
     @Override
     @ForceInline
-    public ByteVector or(byte o, Mask<Byte> m) {
+    public ByteVector or(byte o, VectorMask<Byte> m) {
         return or((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -468,7 +468,7 @@
 
     @Override
     @ForceInline
-    public ByteVector xor(byte o, Mask<Byte> m) {
+    public ByteVector xor(byte o, VectorMask<Byte> m) {
         return xor((ByteMaxVector)ByteVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @ForceInline
     @Override
-    public ByteMaxVector neg(Mask<Byte> m) {
+    public ByteMaxVector neg(VectorMask<Byte> m) {
         return blend(neg(), m);
     }
 
@@ -497,7 +497,7 @@
 
     @ForceInline
     @Override
-    public ByteMaxVector abs(Mask<Byte> m) {
+    public ByteMaxVector abs(VectorMask<Byte> m) {
         return blend(abs(), m);
     }
 
@@ -513,7 +513,7 @@
 
     @ForceInline
     @Override
-    public ByteMaxVector not(Mask<Byte> m) {
+    public ByteMaxVector not(VectorMask<Byte> m) {
         return blend(not(), m);
     }
     // Binary operations
@@ -531,7 +531,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector add(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector add(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(add(v), m);
     }
 
@@ -548,7 +548,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector sub(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector sub(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(sub(v), m);
     }
 
@@ -565,7 +565,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector mul(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector mul(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(mul(v), m);
     }
 
@@ -582,7 +582,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector min(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector min(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(min(v), m);
     }
 
@@ -599,7 +599,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector max(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector max(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(max(v), m);
     }
 
@@ -638,19 +638,19 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector and(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector and(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(and(v), m);
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector or(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector or(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(or(v), m);
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector xor(Vector<Byte> v, Mask<Byte> m) {
+    public ByteMaxVector xor(Vector<Byte> v, VectorMask<Byte> m) {
         return blend(xor(v), m);
     }
 
@@ -665,7 +665,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector shiftL(int s, Mask<Byte> m) {
+    public ByteMaxVector shiftL(int s, VectorMask<Byte> m) {
         return blend(shiftL(s), m);
     }
 
@@ -680,7 +680,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector shiftR(int s, Mask<Byte> m) {
+    public ByteMaxVector shiftR(int s, VectorMask<Byte> m) {
         return blend(shiftR(s), m);
     }
 
@@ -695,7 +695,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector aShiftR(int s, Mask<Byte> m) {
+    public ByteMaxVector aShiftR(int s, VectorMask<Byte> m) {
         return blend(aShiftR(s), m);
     }
     // Ternary operations
@@ -723,7 +723,7 @@
 
     @Override
     @ForceInline
-    public byte andAll(Mask<Byte> m) {
+    public byte andAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, (byte) -1), m).andAll();
     }
 
@@ -765,7 +765,7 @@
 
     @Override
     @ForceInline
-    public byte orAll(Mask<Byte> m) {
+    public byte orAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, (byte) 0), m).orAll();
     }
 
@@ -780,45 +780,45 @@
 
     @Override
     @ForceInline
-    public byte xorAll(Mask<Byte> m) {
+    public byte xorAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, (byte) 0), m).xorAll();
     }
 
 
     @Override
     @ForceInline
-    public byte addAll(Mask<Byte> m) {
+    public byte addAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, (byte) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public byte mulAll(Mask<Byte> m) {
+    public byte mulAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, (byte) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public byte minAll(Mask<Byte> m) {
+    public byte minAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public byte maxAll(Mask<Byte> m) {
+    public byte maxAll(VectorMask<Byte> m) {
         return blend((ByteMaxVector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Byte> toShuffle() {
+    public VectorShuffle<Byte> toShuffle() {
         byte[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return ByteVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -840,7 +840,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(byte[] a, int ax, Mask<Byte> m) {
+    public final void intoArray(byte[] a, int ax, VectorMask<Byte> m) {
         ByteVector oldVal = ByteVector.fromArray(SPECIES, a, ax);
         ByteVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -864,7 +864,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Byte> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Byte> m) {
         ByteMaxVector oldVal = (ByteMaxVector) ByteVector.fromByteArray(SPECIES, a, ix);
         ByteMaxVector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -893,7 +893,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Byte> m) {
         ByteMaxVector oldVal = (ByteMaxVector) ByteVector.fromByteBuffer(SPECIES, bb, ix);
         ByteMaxVector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1018,7 +1018,7 @@
     }
 
     @Override
-    void forEach(Mask<Byte> o, FUnCon f) {
+    void forEach(VectorMask<Byte> o, FUnCon f) {
         boolean[] mbits = ((ByteMaxMask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1075,13 +1075,13 @@
     @Override
     @ForceInline
     public ByteMaxVector rearrange(Vector<Byte> v,
-                                  Shuffle<Byte> s, Mask<Byte> m) {
+                                  VectorShuffle<Byte> s, VectorMask<Byte> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public ByteMaxVector rearrange(Shuffle<Byte> o1) {
+    public ByteMaxVector rearrange(VectorShuffle<Byte> o1) {
         Objects.requireNonNull(o1);
         ByteMaxShuffle s =  (ByteMaxShuffle)o1;
 
@@ -1096,7 +1096,7 @@
 
     @Override
     @ForceInline
-    public ByteMaxVector blend(Vector<Byte> o1, Mask<Byte> o2) {
+    public ByteMaxVector blend(Vector<Byte> o1, VectorMask<Byte> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         ByteMaxVector v = (ByteMaxVector)o1;
@@ -1180,7 +1180,7 @@
         }
 
         @Override
-        ByteMaxMask bOp(Mask<Byte> o, MBinOp f) {
+        ByteMaxMask bOp(VectorMask<Byte> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((ByteMaxMask)o).getBits();
@@ -1191,7 +1191,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1210,23 +1210,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new ByteMaxVector.ByteMaxMask(maskArray);
+                return (VectorMask <E>) new ByteMaxVector.ByteMaxMask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new ShortMaxVector.ShortMaxMask(maskArray);
+                return (VectorMask <E>) new ShortMaxVector.ShortMaxMask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new IntMaxVector.IntMaxMask(maskArray);
+                return (VectorMask <E>) new IntMaxVector.IntMaxMask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new LongMaxVector.LongMaxMask(maskArray);
+                return (VectorMask <E>) new LongMaxVector.LongMaxMask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new FloatMaxVector.FloatMaxMask(maskArray);
+                return (VectorMask <E>) new FloatMaxVector.FloatMaxMask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new DoubleMaxVector.DoubleMaxMask(maskArray);
+                return (VectorMask <E>) new DoubleMaxVector.DoubleMaxMask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1247,7 +1247,7 @@
 
         @Override
         @ForceInline
-        public ByteMaxMask and(Mask<Byte> o) {
+        public ByteMaxMask and(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             ByteMaxMask m = (ByteMaxMask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, ByteMaxMask.class, byte.class, LENGTH,
@@ -1257,7 +1257,7 @@
 
         @Override
         @ForceInline
-        public ByteMaxMask or(Mask<Byte> o) {
+        public ByteMaxMask or(VectorMask<Byte> o) {
             Objects.requireNonNull(o);
             ByteMaxMask m = (ByteMaxMask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, ByteMaxMask.class, byte.class, LENGTH,
@@ -1279,7 +1279,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, ByteMaxMask.class, byte.class, LENGTH,
-                                         this, ByteVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((ByteMaxMask)m).getBits()));
         }
     }
@@ -1304,7 +1304,7 @@
         }
 
         @Override
-        public Species<Byte> species() {
+        public VectorSpecies<Byte> species() {
             return SPECIES;
         }
 
@@ -1320,30 +1320,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new ByteMaxVector.ByteMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new ByteMaxVector.ByteMaxShuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new ShortMaxVector.ShortMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new ShortMaxVector.ShortMaxShuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new IntMaxVector.IntMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new IntMaxVector.IntMaxShuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new LongMaxVector.LongMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new LongMaxVector.LongMaxShuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new FloatMaxVector.FloatMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new FloatMaxVector.FloatMaxShuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new DoubleMaxVector.DoubleMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new DoubleMaxVector.DoubleMaxShuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public ByteMaxShuffle rearrange(Vector.Shuffle<Byte> o) {
+        public ByteMaxShuffle rearrange(VectorShuffle<Byte> o) {
             ByteMaxShuffle s = (ByteMaxShuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1353,10 +1353,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Byte> species() {
+    public VectorSpecies<Byte> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -55,7 +55,7 @@
 
     abstract ByteVector uOp(FUnOp f);
 
-    abstract ByteVector uOp(Mask<Byte> m, FUnOp f);
+    abstract ByteVector uOp(VectorMask<Byte> m, FUnOp f);
 
     // Binary operator
 
@@ -65,7 +65,7 @@
 
     abstract ByteVector bOp(Vector<Byte> v, FBinOp f);
 
-    abstract ByteVector bOp(Vector<Byte> v, Mask<Byte> m, FBinOp f);
+    abstract ByteVector bOp(Vector<Byte> v, VectorMask<Byte> m, FBinOp f);
 
     // Trinary operator
 
@@ -75,7 +75,7 @@
 
     abstract ByteVector tOp(Vector<Byte> v1, Vector<Byte> v2, FTriOp f);
 
-    abstract ByteVector tOp(Vector<Byte> v1, Vector<Byte> v2, Mask<Byte> m, FTriOp f);
+    abstract ByteVector tOp(Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m, FTriOp f);
 
     // Reduction operator
 
@@ -87,7 +87,7 @@
         boolean apply(int i, byte a, byte b);
     }
 
-    abstract Mask<Byte> bTest(Vector<Byte> v, FBinTest f);
+    abstract VectorMask<Byte> bTest(Vector<Byte> v, FBinTest f);
 
     // Foreach
 
@@ -97,7 +97,7 @@
 
     abstract void forEach(FUnCon f);
 
-    abstract void forEach(Mask<Byte> m, FUnCon f);
+    abstract void forEach(VectorMask<Byte> m, FUnCon f);
 
     // Static factories
 
@@ -110,7 +110,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static ByteVector zero(Species<Byte> species) {
+    public static ByteVector zero(VectorSpecies<Byte> species) {
         return VectorIntrinsics.broadcastCoerced((Class<ByteVector>) species.boxType(), byte.class, species.length(),
                                                  0, species,
                                                  ((bits, s) -> ((ByteSpecies)s).op(i -> (byte)bits)));
@@ -124,7 +124,7 @@
      * <p>
      * This method behaves as if it returns the result of calling the
      * byte buffer, offset, and mask accepting
-     * {@link #fromByteBuffer(Species<Byte>, ByteBuffer, int, Mask) method} as follows:
+     * {@link #fromByteBuffer(VectorSpecies<Byte>, ByteBuffer, int, VectorMask) method} as follows:
      * <pre>{@code
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
@@ -138,7 +138,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static ByteVector fromByteArray(Species<Byte> species, byte[] a, int ix) {
+    public static ByteVector fromByteArray(VectorSpecies<Byte> species, byte[] a, int ix) {
         Objects.requireNonNull(a);
         ix = VectorIntrinsics.checkIndex(ix, a.length, species.bitSize() / Byte.SIZE);
         return VectorIntrinsics.load((Class<ByteVector>) species.boxType(), byte.class, species.length(),
@@ -160,7 +160,7 @@
      * <p>
      * This method behaves as if it returns the result of calling the
      * byte buffer, offset, and mask accepting
-     * {@link #fromByteBuffer(Species<Byte>, ByteBuffer, int, Mask) method} as follows:
+     * {@link #fromByteBuffer(VectorSpecies<Byte>, ByteBuffer, int, VectorMask) method} as follows:
      * <pre>{@code
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
@@ -179,7 +179,7 @@
      * {@code i >= a.length - (N * this.elementSize() / Byte.SIZE)}
      */
     @ForceInline
-    public static ByteVector fromByteArray(Species<Byte> species, byte[] a, int ix, Mask<Byte> m) {
+    public static ByteVector fromByteArray(VectorSpecies<Byte> species, byte[] a, int ix, VectorMask<Byte> m) {
         return zero(species).blend(fromByteArray(species, a, ix), m);
     }
 
@@ -199,7 +199,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static ByteVector fromArray(Species<Byte> species, byte[] a, int i){
+    public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int i){
         Objects.requireNonNull(a);
         i = VectorIntrinsics.checkIndex(i, a.length, species.length());
         return VectorIntrinsics.load((Class<ByteVector>) species.boxType(), byte.class, species.length(),
@@ -228,7 +228,7 @@
      * is set {@code i > a.length - N}
      */
     @ForceInline
-    public static ByteVector fromArray(Species<Byte> species, byte[] a, int i, Mask<Byte> m) {
+    public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int i, VectorMask<Byte> m) {
         return zero(species).blend(fromArray(species, a, i), m);
     }
 
@@ -253,7 +253,7 @@
      * or for any vector lane index {@code N} the result of
      * {@code i + indexMap[j + N]} is {@code < 0} or {@code >= a.length}
      */
-    public static ByteVector fromArray(Species<Byte> species, byte[] a, int i, int[] indexMap, int j) {
+    public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int i, int[] indexMap, int j) {
         return ((ByteSpecies)species).op(n -> a[i + indexMap[j + n]]);
     }
     /**
@@ -280,7 +280,7 @@
      * {@code N} is set the result of {@code i + indexMap[j + N]} is
      * {@code < 0} or {@code >= a.length}
      */
-    public static ByteVector fromArray(Species<Byte> species, byte[] a, int i, Mask<Byte> m, int[] indexMap, int j) {
+    public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int i, VectorMask<Byte> m, int[] indexMap, int j) {
         return ((ByteSpecies)species).op(m, n -> a[i + indexMap[j + n]]);
     }
 
@@ -293,7 +293,7 @@
      * <p>
      * This method behaves as if it returns the result of calling the
      * byte buffer, offset, and mask accepting
-     * {@link #fromByteBuffer(Species<Byte>, ByteBuffer, int, Mask)} method} as follows:
+     * {@link #fromByteBuffer(VectorSpecies<Byte>, ByteBuffer, int, VectorMask)} method} as follows:
      * <pre>{@code
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
@@ -310,7 +310,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static ByteVector fromByteBuffer(Species<Byte> species, ByteBuffer bb, int ix) {
+    public static ByteVector fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int ix) {
         if (bb.order() != ByteOrder.nativeOrder()) {
             throw new IllegalArgumentException();
         }
@@ -362,7 +362,7 @@
      * {@code i >= b.limit() - (N * this.elementSize() / Byte.SIZE)}
      */
     @ForceInline
-    public static ByteVector fromByteBuffer(Species<Byte> species, ByteBuffer bb, int ix, Mask<Byte> m) {
+    public static ByteVector fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int ix, VectorMask<Byte> m) {
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
@@ -377,7 +377,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static ByteVector broadcast(Species<Byte> s, byte e) {
+    public static ByteVector broadcast(VectorSpecies<Byte> s, byte e) {
         return VectorIntrinsics.broadcastCoerced(
             (Class<ByteVector>) s.boxType(), byte.class, s.length(),
             e, s,
@@ -400,7 +400,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static ByteVector scalars(Species<Byte> s, byte... es) {
+    public static ByteVector scalars(VectorSpecies<Byte> s, byte... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, s.length());
         return VectorIntrinsics.load((Class<ByteVector>) s.boxType(), byte.class, s.length(),
@@ -420,7 +420,7 @@
      * value {@code e}
      */
     @ForceInline
-    public static final ByteVector single(Species<Byte> s, byte e) {
+    public static final ByteVector single(VectorSpecies<Byte> s, byte e) {
         return zero(s).with(0, e);
     }
 
@@ -435,235 +435,11 @@
      * @return a vector where each lane elements is set to a randomly
      * generated primitive value
      */
-    public static ByteVector random(Species<Byte> s) {
+    public static ByteVector random(VectorSpecies<Byte> s) {
         ThreadLocalRandom r = ThreadLocalRandom.current();
         return ((ByteSpecies)s).op(i -> (byte) r.nextInt());
     }
 
-    /**
-     * Returns a mask where each lane is set or unset according to given
-     * {@code boolean} values
-     * <p>
-     * For each mask lane, where {@code N} is the mask lane index,
-     * if the given {@code boolean} value at index {@code N} is {@code true}
-     * then the mask lane at index {@code N} is set, otherwise it is unset.
-     *
-     * @param species mask species
-     * @param bits the given {@code boolean} values
-     * @return a mask where each lane is set or unset according to the given {@code boolean} value
-     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
-     */
-    @ForceInline
-    public static Mask<Byte> maskFromValues(Species<Byte> species, boolean... bits) {
-        if (species.boxType() == ByteMaxVector.class)
-            return new ByteMaxVector.ByteMaxMask(bits);
-        switch (species.bitSize()) {
-            case 64: return new Byte64Vector.Byte64Mask(bits);
-            case 128: return new Byte128Vector.Byte128Mask(bits);
-            case 256: return new Byte256Vector.Byte256Mask(bits);
-            case 512: return new Byte512Vector.Byte512Mask(bits);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    // @@@ This is a bad implementation -- makes lambdas capturing -- fix this
-    static Mask<Byte> trueMask(Species<Byte> species) {
-        if (species.boxType() == ByteMaxVector.class)
-            return ByteMaxVector.ByteMaxMask.TRUE_MASK;
-        switch (species.bitSize()) {
-            case 64: return Byte64Vector.Byte64Mask.TRUE_MASK;
-            case 128: return Byte128Vector.Byte128Mask.TRUE_MASK;
-            case 256: return Byte256Vector.Byte256Mask.TRUE_MASK;
-            case 512: return Byte512Vector.Byte512Mask.TRUE_MASK;
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    static Mask<Byte> falseMask(Species<Byte> species) {
-        if (species.boxType() == ByteMaxVector.class)
-            return ByteMaxVector.ByteMaxMask.FALSE_MASK;
-        switch (species.bitSize()) {
-            case 64: return Byte64Vector.Byte64Mask.FALSE_MASK;
-            case 128: return Byte128Vector.Byte128Mask.FALSE_MASK;
-            case 256: return Byte256Vector.Byte256Mask.FALSE_MASK;
-            case 512: return Byte512Vector.Byte512Mask.FALSE_MASK;
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Loads a mask from a {@code boolean} array starting at an offset.
-     * <p>
-     * For each mask lane, where {@code N} is the mask lane index,
-     * if the array element at index {@code ix + N} is {@code true} then the
-     * mask lane at index {@code N} is set, otherwise it is unset.
-     *
-     * @param species mask species
-     * @param bits the {@code boolean} array
-     * @param ix the offset into the array
-     * @return the mask loaded from a {@code boolean} array
-     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
-     * {@code ix > bits.length - species.length()}
-     */
-    @ForceInline
-    @SuppressWarnings("unchecked")
-    public static Mask<Byte> maskFromArray(Species<Byte> species, boolean[] bits, int ix) {
-        Objects.requireNonNull(bits);
-        ix = VectorIntrinsics.checkIndex(ix, bits.length, species.length());
-        return VectorIntrinsics.load((Class<Mask<Byte>>) species.maskType(), byte.class, species.length(),
-                                     bits, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
-                                     bits, ix, species,
-                                     (c, idx, s) -> (Mask<Byte>) ((ByteSpecies)s).opm(n -> c[idx + n]));
-    }
-
-    /**
-     * Returns a mask where all lanes are set.
-     *
-     * @param species mask species
-     * @return a mask where all lanes are set
-     */
-    @ForceInline
-    @SuppressWarnings("unchecked")
-    public static Mask<Byte> maskAllTrue(Species<Byte> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<Mask<Byte>>) species.maskType(), byte.class, species.length(),
-                                                 (byte)-1,  species,
-                                                 ((z, s) -> trueMask(s)));
-    }
-
-    /**
-     * Returns a mask where all lanes are unset.
-     *
-     * @param species mask species
-     * @return a mask where all lanes are unset
-     */
-    @ForceInline
-    @SuppressWarnings("unchecked")
-    public static Mask<Byte> maskAllFalse(Species<Byte> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<Mask<Byte>>) species.maskType(), byte.class, species.length(),
-                                                 0, species, 
-                                                 ((z, s) -> falseMask(s)));
-    }
-
-    /**
-     * Returns a shuffle of mapped indexes where each lane element is
-     * the result of applying a mapping function to the corresponding lane
-     * index.
-     * <p>
-     * Care should be taken to ensure Shuffle values produced from this
-     * method are consumed as constants to ensure optimal generation of
-     * code.  For example, values held in static final fields or values
-     * held in loop constant local variables.
-     * <p>
-     * This method behaves as if a shuffle is created from an array of
-     * mapped indexes as follows:
-     * <pre>{@code
-     *   int[] a = new int[species.length()];
-     *   for (int i = 0; i < a.length; i++) {
-     *       a[i] = f.applyAsInt(i);
-     *   }
-     *   return this.shuffleFromValues(a);
-     * }</pre>
-     *
-     * @param species shuffle species
-     * @param f the lane index mapping function
-     * @return a shuffle of mapped indexes
-     */
-    @ForceInline
-    public static Shuffle<Byte> shuffle(Species<Byte> species, IntUnaryOperator f) {
-        if (species.boxType() == ByteMaxVector.class)
-            return new ByteMaxVector.ByteMaxShuffle(f);
-        switch (species.bitSize()) {
-            case 64: return new Byte64Vector.Byte64Shuffle(f);
-            case 128: return new Byte128Vector.Byte128Shuffle(f);
-            case 256: return new Byte256Vector.Byte256Shuffle(f);
-            case 512: return new Byte512Vector.Byte512Shuffle(f);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Returns a shuffle where each lane element is the value of its
-     * corresponding lane index.
-     * <p>
-     * This method behaves as if a shuffle is created from an identity
-     * index mapping function as follows:
-     * <pre>{@code
-     *   return this.shuffle(i -> i);
-     * }</pre>
-     *
-     * @param species shuffle species
-     * @return a shuffle of lane indexes
-     */
-    @ForceInline
-    public static Shuffle<Byte> shuffleIota(Species<Byte> species) {
-        if (species.boxType() == ByteMaxVector.class)
-            return new ByteMaxVector.ByteMaxShuffle(AbstractShuffle.IDENTITY);
-        switch (species.bitSize()) {
-            case 64: return new Byte64Vector.Byte64Shuffle(AbstractShuffle.IDENTITY);
-            case 128: return new Byte128Vector.Byte128Shuffle(AbstractShuffle.IDENTITY);
-            case 256: return new Byte256Vector.Byte256Shuffle(AbstractShuffle.IDENTITY);
-            case 512: return new Byte512Vector.Byte512Shuffle(AbstractShuffle.IDENTITY);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Returns a shuffle where each lane element is set to a given
-     * {@code int} value logically AND'ed by the species length minus one.
-     * <p>
-     * For each shuffle lane, where {@code N} is the shuffle lane index, the
-     * the {@code int} value at index {@code N} logically AND'ed by
-     * {@code species.length() - 1} is placed into the resulting shuffle at
-     * lane index {@code N}.
-     *
-     * @param species shuffle species
-     * @param ixs the given {@code int} values
-     * @return a shuffle where each lane element is set to a given
-     * {@code int} value
-     * @throws IndexOutOfBoundsException if the number of int values is
-     * {@code < species.length()}
-     */
-    @ForceInline
-    public static Shuffle<Byte> shuffleFromValues(Species<Byte> species, int... ixs) {
-        if (species.boxType() == ByteMaxVector.class)
-            return new ByteMaxVector.ByteMaxShuffle(ixs);
-        switch (species.bitSize()) {
-            case 64: return new Byte64Vector.Byte64Shuffle(ixs);
-            case 128: return new Byte128Vector.Byte128Shuffle(ixs);
-            case 256: return new Byte256Vector.Byte256Shuffle(ixs);
-            case 512: return new Byte512Vector.Byte512Shuffle(ixs);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Loads a shuffle from an {@code int} array starting at an offset.
-     * <p>
-     * For each shuffle lane, where {@code N} is the shuffle lane index, the
-     * array element at index {@code i + N} logically AND'ed by
-     * {@code species.length() - 1} is placed into the resulting shuffle at lane
-     * index {@code N}.
-     *
-     * @param species shuffle species
-     * @param ixs the {@code int} array
-     * @param i the offset into the array
-     * @return a shuffle loaded from the {@code int} array
-     * @throws IndexOutOfBoundsException if {@code i < 0}, or
-     * {@code i > a.length - species.length()}
-     */
-    @ForceInline
-    public static Shuffle<Byte> shuffleFromArray(Species<Byte> species, int[] ixs, int i) {
-        if (species.boxType() == ByteMaxVector.class)
-            return new ByteMaxVector.ByteMaxShuffle(ixs, i);
-        switch (species.bitSize()) {
-            case 64: return new Byte64Vector.Byte64Shuffle(ixs, i);
-            case 128: return new Byte128Vector.Byte128Shuffle(ixs, i);
-            case 256: return new Byte256Vector.Byte256Shuffle(ixs, i);
-            case 512: return new Byte512Vector.Byte512Shuffle(ixs, i);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
     // Ops
 
     @Override
@@ -682,7 +458,7 @@
     public abstract ByteVector add(byte s);
 
     @Override
-    public abstract ByteVector add(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector add(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Adds this vector to broadcast of an input scalar,
@@ -696,7 +472,7 @@
      * @return the result of adding this vector to the broadcast of an input
      * scalar
      */
-    public abstract ByteVector add(byte s, Mask<Byte> m);
+    public abstract ByteVector add(byte s, VectorMask<Byte> m);
 
     @Override
     public abstract ByteVector sub(Vector<Byte> v);
@@ -714,7 +490,7 @@
     public abstract ByteVector sub(byte s);
 
     @Override
-    public abstract ByteVector sub(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector sub(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Subtracts the broadcast of an input scalar from this vector, selecting
@@ -728,7 +504,7 @@
      * @return the result of subtracting the broadcast of an input
      * scalar from this vector
      */
-    public abstract ByteVector sub(byte s, Mask<Byte> m);
+    public abstract ByteVector sub(byte s, VectorMask<Byte> m);
 
     @Override
     public abstract ByteVector mul(Vector<Byte> v);
@@ -746,7 +522,7 @@
     public abstract ByteVector mul(byte s);
 
     @Override
-    public abstract ByteVector mul(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector mul(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Multiplies this vector with the broadcast of an input scalar, selecting
@@ -760,25 +536,25 @@
      * @return the result of multiplying this vector with the broadcast of an
      * input scalar
      */
-    public abstract ByteVector mul(byte s, Mask<Byte> m);
+    public abstract ByteVector mul(byte s, VectorMask<Byte> m);
 
     @Override
     public abstract ByteVector neg();
 
     @Override
-    public abstract ByteVector neg(Mask<Byte> m);
+    public abstract ByteVector neg(VectorMask<Byte> m);
 
     @Override
     public abstract ByteVector abs();
 
     @Override
-    public abstract ByteVector abs(Mask<Byte> m);
+    public abstract ByteVector abs(VectorMask<Byte> m);
 
     @Override
     public abstract ByteVector min(Vector<Byte> v);
 
     @Override
-    public abstract ByteVector min(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector min(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Returns the minimum of this vector and the broadcast of an input scalar.
@@ -795,7 +571,7 @@
     public abstract ByteVector max(Vector<Byte> v);
 
     @Override
-    public abstract ByteVector max(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector max(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Returns the maximum of this vector and the broadcast of an input scalar.
@@ -809,7 +585,7 @@
     public abstract ByteVector max(byte s);
 
     @Override
-    public abstract Mask<Byte> equal(Vector<Byte> v);
+    public abstract VectorMask<Byte> equal(Vector<Byte> v);
 
     /**
      * Tests if this vector is equal to the broadcast of an input scalar.
@@ -821,10 +597,10 @@
      * @return the result mask of testing if this vector is equal to the
      * broadcast of an input scalar
      */
-    public abstract Mask<Byte> equal(byte s);
+    public abstract VectorMask<Byte> equal(byte s);
 
     @Override
-    public abstract Mask<Byte> notEqual(Vector<Byte> v);
+    public abstract VectorMask<Byte> notEqual(Vector<Byte> v);
 
     /**
      * Tests if this vector is not equal to the broadcast of an input scalar.
@@ -836,10 +612,10 @@
      * @return the result mask of testing if this vector is not equal to the
      * broadcast of an input scalar
      */
-    public abstract Mask<Byte> notEqual(byte s);
+    public abstract VectorMask<Byte> notEqual(byte s);
 
     @Override
-    public abstract Mask<Byte> lessThan(Vector<Byte> v);
+    public abstract VectorMask<Byte> lessThan(Vector<Byte> v);
 
     /**
      * Tests if this vector is less than the broadcast of an input scalar.
@@ -851,10 +627,10 @@
      * @return the mask result of testing if this vector is less than the
      * broadcast of an input scalar
      */
-    public abstract Mask<Byte> lessThan(byte s);
+    public abstract VectorMask<Byte> lessThan(byte s);
 
     @Override
-    public abstract Mask<Byte> lessThanEq(Vector<Byte> v);
+    public abstract VectorMask<Byte> lessThanEq(Vector<Byte> v);
 
     /**
      * Tests if this vector is less or equal to the broadcast of an input scalar.
@@ -866,10 +642,10 @@
      * @return the mask result of testing if this vector is less than or equal
      * to the broadcast of an input scalar
      */
-    public abstract Mask<Byte> lessThanEq(byte s);
+    public abstract VectorMask<Byte> lessThanEq(byte s);
 
     @Override
-    public abstract Mask<Byte> greaterThan(Vector<Byte> v);
+    public abstract VectorMask<Byte> greaterThan(Vector<Byte> v);
 
     /**
      * Tests if this vector is greater than the broadcast of an input scalar.
@@ -881,10 +657,10 @@
      * @return the mask result of testing if this vector is greater than the
      * broadcast of an input scalar
      */
-    public abstract Mask<Byte> greaterThan(byte s);
+    public abstract VectorMask<Byte> greaterThan(byte s);
 
     @Override
-    public abstract Mask<Byte> greaterThanEq(Vector<Byte> v);
+    public abstract VectorMask<Byte> greaterThanEq(Vector<Byte> v);
 
     /**
      * Tests if this vector is greater than or equal to the broadcast of an
@@ -897,10 +673,10 @@
      * @return the mask result of testing if this vector is greater than or
      * equal to the broadcast of an input scalar
      */
-    public abstract Mask<Byte> greaterThanEq(byte s);
+    public abstract VectorMask<Byte> greaterThanEq(byte s);
 
     @Override
-    public abstract ByteVector blend(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector blend(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Blends the lane elements of this vector with those of the broadcast of an
@@ -917,17 +693,17 @@
      * @return the result of blending the lane elements of this vector with
      * those of the broadcast of an input scalar
      */
-    public abstract ByteVector blend(byte s, Mask<Byte> m);
+    public abstract ByteVector blend(byte s, VectorMask<Byte> m);
 
     @Override
     public abstract ByteVector rearrange(Vector<Byte> v,
-                                                      Shuffle<Byte> s, Mask<Byte> m);
+                                                      VectorShuffle<Byte> s, VectorMask<Byte> m);
 
     @Override
-    public abstract ByteVector rearrange(Shuffle<Byte> m);
+    public abstract ByteVector rearrange(VectorShuffle<Byte> m);
 
     @Override
-    public abstract ByteVector reshape(Species<Byte> s);
+    public abstract ByteVector reshape(VectorSpecies<Byte> s);
 
     @Override
     public abstract ByteVector rotateEL(int i);
@@ -977,7 +753,7 @@
      * @param m the mask controlling lane selection
      * @return the bitwise AND of this vector with the input vector
      */
-    public abstract ByteVector and(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector and(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Bitwise ANDs this vector with the broadcast of an input scalar, selecting
@@ -991,7 +767,7 @@
      * @return the bitwise AND of this vector with the broadcast of an input
      * scalar
      */
-    public abstract ByteVector and(byte s, Mask<Byte> m);
+    public abstract ByteVector and(byte s, VectorMask<Byte> m);
 
     /**
      * Bitwise ORs this vector with an input vector.
@@ -1027,7 +803,7 @@
      * @param m the mask controlling lane selection
      * @return the bitwise OR of this vector with the input vector
      */
-    public abstract ByteVector or(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector or(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Bitwise ORs this vector with the broadcast of an input scalar, selecting
@@ -1041,7 +817,7 @@
      * @return the bitwise OR of this vector with the broadcast of an input
      * scalar
      */
-    public abstract ByteVector or(byte s, Mask<Byte> m);
+    public abstract ByteVector or(byte s, VectorMask<Byte> m);
 
     /**
      * Bitwise XORs this vector with an input vector.
@@ -1077,7 +853,7 @@
      * @param m the mask controlling lane selection
      * @return the bitwise XOR of this vector with the input vector
      */
-    public abstract ByteVector xor(Vector<Byte> v, Mask<Byte> m);
+    public abstract ByteVector xor(Vector<Byte> v, VectorMask<Byte> m);
 
     /**
      * Bitwise XORs this vector with the broadcast of an input scalar, selecting
@@ -1091,7 +867,7 @@
      * @return the bitwise XOR of this vector with the broadcast of an input
      * scalar
      */
-    public abstract ByteVector xor(byte s, Mask<Byte> m);
+    public abstract ByteVector xor(byte s, VectorMask<Byte> m);
 
     /**
      * Bitwise NOTs this vector.
@@ -1112,7 +888,7 @@
      * @param m the mask controlling lane selection
      * @return the bitwise NOT of this vector
      */
-    public abstract ByteVector not(Mask<Byte> m);
+    public abstract ByteVector not(VectorMask<Byte> m);
 
     /**
      * Logically left shifts this vector by the broadcast of an input scalar.
@@ -1146,7 +922,7 @@
      * @return the result of logically left shifting left this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector shiftL(int s, Mask<Byte> m);
+    public abstract ByteVector shiftL(int s, VectorMask<Byte> m);
 
 
     // logical, or unsigned, shift right
@@ -1185,7 +961,7 @@
      * @return the result of logically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector shiftR(int s, Mask<Byte> m);
+    public abstract ByteVector shiftR(int s, VectorMask<Byte> m);
 
 
     /**
@@ -1222,20 +998,20 @@
      * @return the result of arithmetically right shifting this vector by the
      * broadcast of an input scalar
      */
-    public abstract ByteVector aShiftR(int s, Mask<Byte> m);
+    public abstract ByteVector aShiftR(int s, VectorMask<Byte> m);
 
 
     @Override
     public abstract void intoByteArray(byte[] a, int ix);
 
     @Override
-    public abstract void intoByteArray(byte[] a, int ix, Mask<Byte> m);
+    public abstract void intoByteArray(byte[] a, int ix, VectorMask<Byte> m);
 
     @Override
     public abstract void intoByteBuffer(ByteBuffer bb, int ix);
 
     @Override
-    public abstract void intoByteBuffer(ByteBuffer bb, int ix, Mask<Byte> m);
+    public abstract void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Byte> m);
 
 
     // Type specific horizontal reductions
@@ -1261,7 +1037,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract byte addAll(Mask<Byte> m);
+    public abstract byte addAll(VectorMask<Byte> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1285,7 +1061,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract byte mulAll(Mask<Byte> m);
+    public abstract byte mulAll(VectorMask<Byte> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1311,7 +1087,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract byte minAll(Mask<Byte> m);
+    public abstract byte minAll(VectorMask<Byte> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1337,7 +1113,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract byte maxAll(Mask<Byte> m);
+    public abstract byte maxAll(VectorMask<Byte> m);
 
     /**
      * Logically ORs all lane elements of this vector.
@@ -1361,7 +1137,7 @@
      * @param m the mask controlling lane selection
      * @return the logical OR all the lane elements of this vector
      */
-    public abstract byte orAll(Mask<Byte> m);
+    public abstract byte orAll(VectorMask<Byte> m);
 
     /**
      * Logically ANDs all lane elements of this vector.
@@ -1385,7 +1161,7 @@
      * @param m the mask controlling lane selection
      * @return the logical AND all the lane elements of this vector
      */
-    public abstract byte andAll(Mask<Byte> m);
+    public abstract byte andAll(VectorMask<Byte> m);
 
     /**
      * Logically XORs all lane elements of this vector.
@@ -1409,7 +1185,7 @@
      * @param m the mask controlling lane selection
      * @return the logical XOR all the lane elements of this vector
      */
-    public abstract byte xorAll(Mask<Byte> m);
+    public abstract byte xorAll(VectorMask<Byte> m);
 
     // Type specific accessors
 
@@ -1491,7 +1267,7 @@
      * for any vector lane index {@code N} where the mask at lane {@code N}
      * is set {@code i >= a.length - N}
      */
-    public abstract void intoArray(byte[] a, int i, Mask<Byte> m);
+    public abstract void intoArray(byte[] a, int i, VectorMask<Byte> m);
 
     /**
      * Stores this vector into an array using indexes obtained from an index
@@ -1538,39 +1314,36 @@
      * {@code N} is set the result of {@code i + indexMap[j + N]} is
      * {@code < 0} or {@code >= a.length}
      */
-    public void intoArray(byte[] a, int i, Mask<Byte> m, int[] indexMap, int j) {
+    public void intoArray(byte[] a, int i, VectorMask<Byte> m, int[] indexMap, int j) {
         forEach(m, (n, e) -> a[i + indexMap[j + n]] = e);
     }
     // Species
 
     @Override
-    public abstract Species<Byte> species();
+    public abstract VectorSpecies<Byte> species();
 
     /**
-     * Class representing {@link ByteVector}'s of the same {@link Vector.Shape Shape}.
+     * Class representing {@link ByteVector}'s of the same {@link VectorShape VectorShape}.
      */
-    static final class ByteSpecies extends Vector.AbstractSpecies<Byte> {
+    static final class ByteSpecies extends AbstractSpecies<Byte> {
         final Function<byte[], ByteVector> vectorFactory;
-        final Function<boolean[], Vector.Mask<Byte>> maskFactory;
 
-        private ByteSpecies(Vector.Shape shape,
+        private ByteSpecies(VectorShape shape,
                           Class<?> boxType,
                           Class<?> maskType,
                           Function<byte[], ByteVector> vectorFactory,
-                          Function<boolean[], Vector.Mask<Byte>> maskFactory) {
-            super(shape, byte.class, Byte.SIZE, boxType, maskType);
+                          Function<boolean[], VectorMask<Byte>> maskFactory,
+                          Function<IntUnaryOperator, VectorShuffle<Byte>> shuffleFromArrayFactory,
+                          fShuffleFromArray<Byte> shuffleFromOpFactory) {
+            super(shape, byte.class, Byte.SIZE, boxType, maskType, maskFactory,
+                  shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
-            this.maskFactory = maskFactory;
         }
 
         interface FOp {
             byte apply(int i);
         }
 
-        interface FOpm {
-            boolean apply(int i);
-        }
-
         ByteVector op(FOp f) {
             byte[] res = new byte[length()];
             for (int i = 0; i < length(); i++) {
@@ -1579,7 +1352,7 @@
             return vectorFactory.apply(res);
         }
 
-        ByteVector op(Vector.Mask<Byte> o, FOp f) {
+        ByteVector op(VectorMask<Byte> o, FOp f) {
             byte[] res = new byte[length()];
             boolean[] mbits = ((AbstractMask<Byte>)o).getBits();
             for (int i = 0; i < length(); i++) {
@@ -1589,14 +1362,6 @@
             }
             return vectorFactory.apply(res);
         }
-
-        Vector.Mask<Byte> opm(IntVector.IntSpecies.FOpm f) {
-            boolean[] res = new boolean[length()];
-            for (int i = 0; i < length(); i++) {
-                res[i] = (boolean)f.apply(i);
-            }
-            return maskFactory.apply(res);
-        }
     }
 
     /**
@@ -1610,7 +1375,7 @@
      * @return the preferred species for an element type of {@code byte}
      */
     private static ByteSpecies preferredSpecies() {
-        return (ByteSpecies) Species.ofPreferred(byte.class);
+        return (ByteSpecies) VectorSpecies.ofPreferred(byte.class);
     }
 
     /**
@@ -1620,7 +1385,7 @@
      * @return a species for an element type of {@code byte} and shape
      * @throws IllegalArgumentException if no such species exists for the shape
      */
-    static ByteSpecies species(Vector.Shape s) {
+    static ByteSpecies species(VectorShape s) {
         Objects.requireNonNull(s);
         switch (s) {
             case S_64_BIT: return (ByteSpecies) SPECIES_64;
@@ -1632,29 +1397,34 @@
         }
     }
 
-    /** Species representing {@link ByteVector}s of {@link Vector.Shape#S_64_BIT Shape.S_64_BIT}. */
-    public static final Species<Byte> SPECIES_64 = new ByteSpecies(Shape.S_64_BIT, Byte64Vector.class, Byte64Vector.Byte64Mask.class,
-                                                                     Byte64Vector::new, Byte64Vector.Byte64Mask::new);
+    /** Species representing {@link ByteVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */
+    public static final VectorSpecies<Byte> SPECIES_64 = new ByteSpecies(VectorShape.S_64_BIT, Byte64Vector.class, Byte64Vector.Byte64Mask.class,
+                                                                     Byte64Vector::new, Byte64Vector.Byte64Mask::new,
+                                                                     Byte64Vector.Byte64Shuffle::new, Byte64Vector.Byte64Shuffle::new);
 
-    /** Species representing {@link ByteVector}s of {@link Vector.Shape#S_128_BIT Shape.S_128_BIT}. */
-    public static final Species<Byte> SPECIES_128 = new ByteSpecies(Shape.S_128_BIT, Byte128Vector.class, Byte128Vector.Byte128Mask.class,
-                                                                      Byte128Vector::new, Byte128Vector.Byte128Mask::new);
+    /** Species representing {@link ByteVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */
+    public static final VectorSpecies<Byte> SPECIES_128 = new ByteSpecies(VectorShape.S_128_BIT, Byte128Vector.class, Byte128Vector.Byte128Mask.class,
+                                                                      Byte128Vector::new, Byte128Vector.Byte128Mask::new,
+                                                                      Byte128Vector.Byte128Shuffle::new, Byte128Vector.Byte128Shuffle::new);
 
-    /** Species representing {@link ByteVector}s of {@link Vector.Shape#S_256_BIT Shape.S_256_BIT}. */
-    public static final Species<Byte> SPECIES_256 = new ByteSpecies(Shape.S_256_BIT, Byte256Vector.class, Byte256Vector.Byte256Mask.class,
-                                                                      Byte256Vector::new, Byte256Vector.Byte256Mask::new);
+    /** Species representing {@link ByteVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */
+    public static final VectorSpecies<Byte> SPECIES_256 = new ByteSpecies(VectorShape.S_256_BIT, Byte256Vector.class, Byte256Vector.Byte256Mask.class,
+                                                                      Byte256Vector::new, Byte256Vector.Byte256Mask::new,
+                                                                      Byte256Vector.Byte256Shuffle::new, Byte256Vector.Byte256Shuffle::new);
 
-    /** Species representing {@link ByteVector}s of {@link Vector.Shape#S_512_BIT Shape.S_512_BIT}. */
-    public static final Species<Byte> SPECIES_512 = new ByteSpecies(Shape.S_512_BIT, Byte512Vector.class, Byte512Vector.Byte512Mask.class,
-                                                                      Byte512Vector::new, Byte512Vector.Byte512Mask::new);
+    /** Species representing {@link ByteVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */
+    public static final VectorSpecies<Byte> SPECIES_512 = new ByteSpecies(VectorShape.S_512_BIT, Byte512Vector.class, Byte512Vector.Byte512Mask.class,
+                                                                      Byte512Vector::new, Byte512Vector.Byte512Mask::new,
+                                                                      Byte512Vector.Byte512Shuffle::new, Byte512Vector.Byte512Shuffle::new);
 
-    /** Species representing {@link ByteVector}s of {@link Vector.Shape#S_Max_BIT Shape.S_Max_BIT}. */
-    public static final Species<Byte> SPECIES_MAX = new ByteSpecies(Shape.S_Max_BIT, ByteMaxVector.class, ByteMaxVector.ByteMaxMask.class,
-                                                                      ByteMaxVector::new, ByteMaxVector.ByteMaxMask::new);
+    /** Species representing {@link ByteVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */
+    public static final VectorSpecies<Byte> SPECIES_MAX = new ByteSpecies(VectorShape.S_Max_BIT, ByteMaxVector.class, ByteMaxVector.ByteMaxMask.class,
+                                                                      ByteMaxVector::new, ByteMaxVector.ByteMaxMask::new,
+                                                                      ByteMaxVector.ByteMaxShuffle::new, ByteMaxVector.ByteMaxShuffle::new);
 
     /**
      * Preferred species for {@link ByteVector}s.
      * A preferred species is a species of maximal bit size for the platform.
      */
-    public static final Species<Byte> SPECIES_PREFERRED = (Species<Byte>) preferredSpecies();
+    public static final VectorSpecies<Byte> SPECIES_PREFERRED = (VectorSpecies<Byte>) preferredSpecies();
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Double128Vector extends DoubleVector {
-    private static final Species<Double> SPECIES = DoubleVector.SPECIES_128;
+    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_128;
 
     static final Double128Vector ZERO = new Double128Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final double[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Double128Vector uOp(Mask<Double> o, FUnOp f) {
+    Double128Vector uOp(VectorMask<Double> o, FUnOp f) {
         double[] vec = getElements();
         double[] res = new double[length()];
         boolean[] mbits = ((Double128Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Double128Vector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
+    Double128Vector bOp(Vector<Double> o1, VectorMask<Double> o2, FBinOp f) {
         double[] res = new double[length()];
         double[] vec1 = this.getElements();
         double[] vec2 = ((Double128Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Double128Vector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
+    Double128Vector tOp(Vector<Double> o1, Vector<Double> o2, VectorMask<Double> o3, FTriOp f) {
         double[] res = new double[length()];
         double[] vec1 = getElements();
         double[] vec2 = ((Double128Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(double.class)) {
-            return (Vector<F>) reshape((Species<Double>)s);
+            return (Vector<F>) reshape((VectorSpecies<Double>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector reshape(Species<Double> s) {
+    public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector add(double o, Mask<Double> m) {
+    public DoubleVector add(double o, VectorMask<Double> m) {
         return add((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector sub(double o, Mask<Double> m) {
+    public DoubleVector sub(double o, VectorMask<Double> m) {
         return sub((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector mul(double o, Mask<Double> m) {
+    public DoubleVector mul(double o, VectorMask<Double> m) {
         return mul((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Double> equal(double o) {
+    public VectorMask<Double> equal(double o) {
         return equal((Double128Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> notEqual(double o) {
+    public VectorMask<Double> notEqual(double o) {
         return notEqual((Double128Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThan(double o) {
+    public VectorMask<Double> lessThan(double o) {
         return lessThan((Double128Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThanEq(double o) {
+    public VectorMask<Double> lessThanEq(double o) {
         return lessThanEq((Double128Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThan(double o) {
+    public VectorMask<Double> greaterThan(double o) {
         return greaterThan((Double128Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThanEq(double o) {
+    public VectorMask<Double> greaterThanEq(double o) {
         return greaterThanEq((Double128Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public DoubleVector blend(double o, Mask<Double> m) {
+    public DoubleVector blend(double o, VectorMask<Double> m) {
         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public DoubleVector div(double o, Mask<Double> m) {
+    public DoubleVector div(double o, VectorMask<Double> m) {
         return div((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Double128Vector div(Vector<Double> v, Mask<Double> m) {
+    public Double128Vector div(Vector<Double> v, VectorMask<Double> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector atan2(double o, Mask<Double> m) {
+    public DoubleVector atan2(double o, VectorMask<Double> m) {
         return atan2((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector pow(double o, Mask<Double> m) {
+    public DoubleVector pow(double o, VectorMask<Double> m) {
         return pow((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector fma(double o1, double o2, Mask<Double> m) {
+    public DoubleVector fma(double o1, double o2, VectorMask<Double> m) {
         return fma((Double128Vector)DoubleVector.broadcast(SPECIES, o1), (Double128Vector)DoubleVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector hypot(double o, Mask<Double> m) {
+    public DoubleVector hypot(double o, VectorMask<Double> m) {
         return hypot((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public Double128Vector neg(Mask<Double> m) {
+    public Double128Vector neg(VectorMask<Double> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public Double128Vector abs(Mask<Double> m) {
+    public Double128Vector abs(VectorMask<Double> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public Double128Vector add(Vector<Double> v, Mask<Double> m) {
+    public Double128Vector add(Vector<Double> v, VectorMask<Double> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public Double128Vector sub(Vector<Double> v, Mask<Double> m) {
+    public Double128Vector sub(Vector<Double> v, VectorMask<Double> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public Double128Vector mul(Vector<Double> v, Mask<Double> m) {
+    public Double128Vector mul(Vector<Double> v, VectorMask<Double> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public Double128Vector min(Vector<Double> v, Mask<Double> m) {
+    public Double128Vector min(Vector<Double> v, VectorMask<Double> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public Double128Vector max(Vector<Double> v, Mask<Double> m) {
+    public Double128Vector max(Vector<Double> v, VectorMask<Double> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public double addAll(Mask<Double> m) {
+    public double addAll(VectorMask<Double> m) {
         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(Mask<Double> m) {
+    public double mulAll(VectorMask<Double> m) {
         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public double minAll(Mask<Double> m) {
+    public double minAll(VectorMask<Double> m) {
         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public double maxAll(Mask<Double> m) {
+    public double maxAll(VectorMask<Double> m) {
         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Double> toShuffle() {
+    public VectorShuffle<Double> toShuffle() {
         double[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(double[] a, int ax, Mask<Double> m) {
+    public final void intoArray(double[] a, int ax, VectorMask<Double> m) {
         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
         DoubleVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
+     public final void intoArray(double[] a, int ax, VectorMask<Double> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
          DoubleVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Double> m) {
         Double128Vector oldVal = (Double128Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
         Double128Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m) {
         Double128Vector oldVal = (Double128Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
         Double128Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Double> o, FUnCon f) {
+    void forEach(VectorMask<Double> o, FUnCon f) {
         boolean[] mbits = ((Double128Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public Double128Vector rearrange(Vector<Double> v,
-                                  Shuffle<Double> s, Mask<Double> m) {
+                                  VectorShuffle<Double> s, VectorMask<Double> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Double128Vector rearrange(Shuffle<Double> o1) {
+    public Double128Vector rearrange(VectorShuffle<Double> o1) {
         Objects.requireNonNull(o1);
         Double128Shuffle s =  (Double128Shuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public Double128Vector blend(Vector<Double> o1, Mask<Double> o2) {
+    public Double128Vector blend(Vector<Double> o1, VectorMask<Double> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Double128Vector v = (Double128Vector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        Double128Mask bOp(Mask<Double> o, MBinOp f) {
+        Double128Mask bOp(VectorMask<Double> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Double128Mask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte128Vector.Byte128Mask(maskArray);
+                return (VectorMask <E>) new Byte128Vector.Byte128Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short128Vector.Short128Mask(maskArray);
+                return (VectorMask <E>) new Short128Vector.Short128Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int128Vector.Int128Mask(maskArray);
+                return (VectorMask <E>) new Int128Vector.Int128Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long128Vector.Long128Mask(maskArray);
+                return (VectorMask <E>) new Long128Vector.Long128Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float128Vector.Float128Mask(maskArray);
+                return (VectorMask <E>) new Float128Vector.Float128Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double128Vector.Double128Mask(maskArray);
+                return (VectorMask <E>) new Double128Vector.Double128Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public Double128Mask and(Mask<Double> o) {
+        public Double128Mask and(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double128Mask m = (Double128Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double128Mask.class, long.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public Double128Mask or(Mask<Double> o) {
+        public Double128Mask or(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double128Mask m = (Double128Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double128Mask.class, long.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Double128Mask.class, long.class, LENGTH,
-                                         this, DoubleVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Double128Mask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Double128Shuffle rearrange(Vector.Shuffle<Double> o) {
+        public Double128Shuffle rearrange(VectorShuffle<Double> o) {
             Double128Shuffle s = (Double128Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Double> species() {
+    public VectorSpecies<Double> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double256Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Double256Vector extends DoubleVector {
-    private static final Species<Double> SPECIES = DoubleVector.SPECIES_256;
+    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_256;
 
     static final Double256Vector ZERO = new Double256Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final double[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Double256Vector uOp(Mask<Double> o, FUnOp f) {
+    Double256Vector uOp(VectorMask<Double> o, FUnOp f) {
         double[] vec = getElements();
         double[] res = new double[length()];
         boolean[] mbits = ((Double256Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Double256Vector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
+    Double256Vector bOp(Vector<Double> o1, VectorMask<Double> o2, FBinOp f) {
         double[] res = new double[length()];
         double[] vec1 = this.getElements();
         double[] vec2 = ((Double256Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Double256Vector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
+    Double256Vector tOp(Vector<Double> o1, Vector<Double> o2, VectorMask<Double> o3, FTriOp f) {
         double[] res = new double[length()];
         double[] vec1 = getElements();
         double[] vec2 = ((Double256Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(double.class)) {
-            return (Vector<F>) reshape((Species<Double>)s);
+            return (Vector<F>) reshape((VectorSpecies<Double>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector reshape(Species<Double> s) {
+    public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector add(double o, Mask<Double> m) {
+    public DoubleVector add(double o, VectorMask<Double> m) {
         return add((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector sub(double o, Mask<Double> m) {
+    public DoubleVector sub(double o, VectorMask<Double> m) {
         return sub((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector mul(double o, Mask<Double> m) {
+    public DoubleVector mul(double o, VectorMask<Double> m) {
         return mul((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Double> equal(double o) {
+    public VectorMask<Double> equal(double o) {
         return equal((Double256Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> notEqual(double o) {
+    public VectorMask<Double> notEqual(double o) {
         return notEqual((Double256Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThan(double o) {
+    public VectorMask<Double> lessThan(double o) {
         return lessThan((Double256Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThanEq(double o) {
+    public VectorMask<Double> lessThanEq(double o) {
         return lessThanEq((Double256Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThan(double o) {
+    public VectorMask<Double> greaterThan(double o) {
         return greaterThan((Double256Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThanEq(double o) {
+    public VectorMask<Double> greaterThanEq(double o) {
         return greaterThanEq((Double256Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public DoubleVector blend(double o, Mask<Double> m) {
+    public DoubleVector blend(double o, VectorMask<Double> m) {
         return blend((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public DoubleVector div(double o, Mask<Double> m) {
+    public DoubleVector div(double o, VectorMask<Double> m) {
         return div((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Double256Vector div(Vector<Double> v, Mask<Double> m) {
+    public Double256Vector div(Vector<Double> v, VectorMask<Double> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector atan2(double o, Mask<Double> m) {
+    public DoubleVector atan2(double o, VectorMask<Double> m) {
         return atan2((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector pow(double o, Mask<Double> m) {
+    public DoubleVector pow(double o, VectorMask<Double> m) {
         return pow((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector fma(double o1, double o2, Mask<Double> m) {
+    public DoubleVector fma(double o1, double o2, VectorMask<Double> m) {
         return fma((Double256Vector)DoubleVector.broadcast(SPECIES, o1), (Double256Vector)DoubleVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector hypot(double o, Mask<Double> m) {
+    public DoubleVector hypot(double o, VectorMask<Double> m) {
         return hypot((Double256Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public Double256Vector neg(Mask<Double> m) {
+    public Double256Vector neg(VectorMask<Double> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public Double256Vector abs(Mask<Double> m) {
+    public Double256Vector abs(VectorMask<Double> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public Double256Vector add(Vector<Double> v, Mask<Double> m) {
+    public Double256Vector add(Vector<Double> v, VectorMask<Double> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public Double256Vector sub(Vector<Double> v, Mask<Double> m) {
+    public Double256Vector sub(Vector<Double> v, VectorMask<Double> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public Double256Vector mul(Vector<Double> v, Mask<Double> m) {
+    public Double256Vector mul(Vector<Double> v, VectorMask<Double> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public Double256Vector min(Vector<Double> v, Mask<Double> m) {
+    public Double256Vector min(Vector<Double> v, VectorMask<Double> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public Double256Vector max(Vector<Double> v, Mask<Double> m) {
+    public Double256Vector max(Vector<Double> v, VectorMask<Double> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public double addAll(Mask<Double> m) {
+    public double addAll(VectorMask<Double> m) {
         return blend((Double256Vector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(Mask<Double> m) {
+    public double mulAll(VectorMask<Double> m) {
         return blend((Double256Vector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public double minAll(Mask<Double> m) {
+    public double minAll(VectorMask<Double> m) {
         return blend((Double256Vector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public double maxAll(Mask<Double> m) {
+    public double maxAll(VectorMask<Double> m) {
         return blend((Double256Vector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Double> toShuffle() {
+    public VectorShuffle<Double> toShuffle() {
         double[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(double[] a, int ax, Mask<Double> m) {
+    public final void intoArray(double[] a, int ax, VectorMask<Double> m) {
         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
         DoubleVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
+     public final void intoArray(double[] a, int ax, VectorMask<Double> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
          DoubleVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Double> m) {
         Double256Vector oldVal = (Double256Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
         Double256Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m) {
         Double256Vector oldVal = (Double256Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
         Double256Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Double> o, FUnCon f) {
+    void forEach(VectorMask<Double> o, FUnCon f) {
         boolean[] mbits = ((Double256Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public Double256Vector rearrange(Vector<Double> v,
-                                  Shuffle<Double> s, Mask<Double> m) {
+                                  VectorShuffle<Double> s, VectorMask<Double> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Double256Vector rearrange(Shuffle<Double> o1) {
+    public Double256Vector rearrange(VectorShuffle<Double> o1) {
         Objects.requireNonNull(o1);
         Double256Shuffle s =  (Double256Shuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public Double256Vector blend(Vector<Double> o1, Mask<Double> o2) {
+    public Double256Vector blend(Vector<Double> o1, VectorMask<Double> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Double256Vector v = (Double256Vector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        Double256Mask bOp(Mask<Double> o, MBinOp f) {
+        Double256Mask bOp(VectorMask<Double> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Double256Mask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte256Vector.Byte256Mask(maskArray);
+                return (VectorMask <E>) new Byte256Vector.Byte256Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short256Vector.Short256Mask(maskArray);
+                return (VectorMask <E>) new Short256Vector.Short256Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int256Vector.Int256Mask(maskArray);
+                return (VectorMask <E>) new Int256Vector.Int256Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long256Vector.Long256Mask(maskArray);
+                return (VectorMask <E>) new Long256Vector.Long256Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float256Vector.Float256Mask(maskArray);
+                return (VectorMask <E>) new Float256Vector.Float256Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double256Vector.Double256Mask(maskArray);
+                return (VectorMask <E>) new Double256Vector.Double256Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public Double256Mask and(Mask<Double> o) {
+        public Double256Mask and(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double256Mask m = (Double256Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double256Mask.class, long.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public Double256Mask or(Mask<Double> o) {
+        public Double256Mask or(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double256Mask m = (Double256Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double256Mask.class, long.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Double256Mask.class, long.class, LENGTH,
-                                         this, DoubleVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Double256Mask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Double256Shuffle rearrange(Vector.Shuffle<Double> o) {
+        public Double256Shuffle rearrange(VectorShuffle<Double> o) {
             Double256Shuffle s = (Double256Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Double> species() {
+    public VectorSpecies<Double> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double512Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Double512Vector extends DoubleVector {
-    private static final Species<Double> SPECIES = DoubleVector.SPECIES_512;
+    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_512;
 
     static final Double512Vector ZERO = new Double512Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final double[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Double512Vector uOp(Mask<Double> o, FUnOp f) {
+    Double512Vector uOp(VectorMask<Double> o, FUnOp f) {
         double[] vec = getElements();
         double[] res = new double[length()];
         boolean[] mbits = ((Double512Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Double512Vector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
+    Double512Vector bOp(Vector<Double> o1, VectorMask<Double> o2, FBinOp f) {
         double[] res = new double[length()];
         double[] vec1 = this.getElements();
         double[] vec2 = ((Double512Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Double512Vector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
+    Double512Vector tOp(Vector<Double> o1, Vector<Double> o2, VectorMask<Double> o3, FTriOp f) {
         double[] res = new double[length()];
         double[] vec1 = getElements();
         double[] vec2 = ((Double512Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(double.class)) {
-            return (Vector<F>) reshape((Species<Double>)s);
+            return (Vector<F>) reshape((VectorSpecies<Double>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector reshape(Species<Double> s) {
+    public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector add(double o, Mask<Double> m) {
+    public DoubleVector add(double o, VectorMask<Double> m) {
         return add((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector sub(double o, Mask<Double> m) {
+    public DoubleVector sub(double o, VectorMask<Double> m) {
         return sub((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector mul(double o, Mask<Double> m) {
+    public DoubleVector mul(double o, VectorMask<Double> m) {
         return mul((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Double> equal(double o) {
+    public VectorMask<Double> equal(double o) {
         return equal((Double512Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> notEqual(double o) {
+    public VectorMask<Double> notEqual(double o) {
         return notEqual((Double512Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThan(double o) {
+    public VectorMask<Double> lessThan(double o) {
         return lessThan((Double512Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThanEq(double o) {
+    public VectorMask<Double> lessThanEq(double o) {
         return lessThanEq((Double512Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThan(double o) {
+    public VectorMask<Double> greaterThan(double o) {
         return greaterThan((Double512Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThanEq(double o) {
+    public VectorMask<Double> greaterThanEq(double o) {
         return greaterThanEq((Double512Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public DoubleVector blend(double o, Mask<Double> m) {
+    public DoubleVector blend(double o, VectorMask<Double> m) {
         return blend((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public DoubleVector div(double o, Mask<Double> m) {
+    public DoubleVector div(double o, VectorMask<Double> m) {
         return div((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Double512Vector div(Vector<Double> v, Mask<Double> m) {
+    public Double512Vector div(Vector<Double> v, VectorMask<Double> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector atan2(double o, Mask<Double> m) {
+    public DoubleVector atan2(double o, VectorMask<Double> m) {
         return atan2((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector pow(double o, Mask<Double> m) {
+    public DoubleVector pow(double o, VectorMask<Double> m) {
         return pow((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector fma(double o1, double o2, Mask<Double> m) {
+    public DoubleVector fma(double o1, double o2, VectorMask<Double> m) {
         return fma((Double512Vector)DoubleVector.broadcast(SPECIES, o1), (Double512Vector)DoubleVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector hypot(double o, Mask<Double> m) {
+    public DoubleVector hypot(double o, VectorMask<Double> m) {
         return hypot((Double512Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public Double512Vector neg(Mask<Double> m) {
+    public Double512Vector neg(VectorMask<Double> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public Double512Vector abs(Mask<Double> m) {
+    public Double512Vector abs(VectorMask<Double> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public Double512Vector add(Vector<Double> v, Mask<Double> m) {
+    public Double512Vector add(Vector<Double> v, VectorMask<Double> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public Double512Vector sub(Vector<Double> v, Mask<Double> m) {
+    public Double512Vector sub(Vector<Double> v, VectorMask<Double> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public Double512Vector mul(Vector<Double> v, Mask<Double> m) {
+    public Double512Vector mul(Vector<Double> v, VectorMask<Double> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public Double512Vector min(Vector<Double> v, Mask<Double> m) {
+    public Double512Vector min(Vector<Double> v, VectorMask<Double> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public Double512Vector max(Vector<Double> v, Mask<Double> m) {
+    public Double512Vector max(Vector<Double> v, VectorMask<Double> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public double addAll(Mask<Double> m) {
+    public double addAll(VectorMask<Double> m) {
         return blend((Double512Vector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(Mask<Double> m) {
+    public double mulAll(VectorMask<Double> m) {
         return blend((Double512Vector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public double minAll(Mask<Double> m) {
+    public double minAll(VectorMask<Double> m) {
         return blend((Double512Vector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public double maxAll(Mask<Double> m) {
+    public double maxAll(VectorMask<Double> m) {
         return blend((Double512Vector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Double> toShuffle() {
+    public VectorShuffle<Double> toShuffle() {
         double[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(double[] a, int ax, Mask<Double> m) {
+    public final void intoArray(double[] a, int ax, VectorMask<Double> m) {
         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
         DoubleVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
+     public final void intoArray(double[] a, int ax, VectorMask<Double> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
          DoubleVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Double> m) {
         Double512Vector oldVal = (Double512Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
         Double512Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m) {
         Double512Vector oldVal = (Double512Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
         Double512Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Double> o, FUnCon f) {
+    void forEach(VectorMask<Double> o, FUnCon f) {
         boolean[] mbits = ((Double512Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public Double512Vector rearrange(Vector<Double> v,
-                                  Shuffle<Double> s, Mask<Double> m) {
+                                  VectorShuffle<Double> s, VectorMask<Double> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Double512Vector rearrange(Shuffle<Double> o1) {
+    public Double512Vector rearrange(VectorShuffle<Double> o1) {
         Objects.requireNonNull(o1);
         Double512Shuffle s =  (Double512Shuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public Double512Vector blend(Vector<Double> o1, Mask<Double> o2) {
+    public Double512Vector blend(Vector<Double> o1, VectorMask<Double> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Double512Vector v = (Double512Vector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        Double512Mask bOp(Mask<Double> o, MBinOp f) {
+        Double512Mask bOp(VectorMask<Double> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Double512Mask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte512Vector.Byte512Mask(maskArray);
+                return (VectorMask <E>) new Byte512Vector.Byte512Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short512Vector.Short512Mask(maskArray);
+                return (VectorMask <E>) new Short512Vector.Short512Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int512Vector.Int512Mask(maskArray);
+                return (VectorMask <E>) new Int512Vector.Int512Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long512Vector.Long512Mask(maskArray);
+                return (VectorMask <E>) new Long512Vector.Long512Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float512Vector.Float512Mask(maskArray);
+                return (VectorMask <E>) new Float512Vector.Float512Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double512Vector.Double512Mask(maskArray);
+                return (VectorMask <E>) new Double512Vector.Double512Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public Double512Mask and(Mask<Double> o) {
+        public Double512Mask and(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double512Mask m = (Double512Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double512Mask.class, long.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public Double512Mask or(Mask<Double> o) {
+        public Double512Mask or(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double512Mask m = (Double512Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double512Mask.class, long.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Double512Mask.class, long.class, LENGTH,
-                                         this, DoubleVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Double512Mask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte512Vector.Byte512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte512Vector.Byte512Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short512Vector.Short512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short512Vector.Short512Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int512Vector.Int512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int512Vector.Int512Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long512Vector.Long512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long512Vector.Long512Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float512Vector.Float512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float512Vector.Float512Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double512Vector.Double512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double512Vector.Double512Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Double512Shuffle rearrange(Vector.Shuffle<Double> o) {
+        public Double512Shuffle rearrange(VectorShuffle<Double> o) {
             Double512Shuffle s = (Double512Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Double> species() {
+    public VectorSpecies<Double> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double64Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Double64Vector extends DoubleVector {
-    private static final Species<Double> SPECIES = DoubleVector.SPECIES_64;
+    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_64;
 
     static final Double64Vector ZERO = new Double64Vector();
 
@@ -48,7 +48,7 @@
     private static final IntVector.IntSpecies INDEX_SPECIES;
 
     static {
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.S_64_BIT);
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.S_64_BIT);
     }
 
     private final double[] vec; // Don't access directly, use getElements() instead.
@@ -81,7 +81,7 @@
     }
 
     @Override
-    Double64Vector uOp(Mask<Double> o, FUnOp f) {
+    Double64Vector uOp(VectorMask<Double> o, FUnOp f) {
         double[] vec = getElements();
         double[] res = new double[length()];
         boolean[] mbits = ((Double64Mask)o).getBits();
@@ -105,7 +105,7 @@
     }
 
     @Override
-    Double64Vector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
+    Double64Vector bOp(Vector<Double> o1, VectorMask<Double> o2, FBinOp f) {
         double[] res = new double[length()];
         double[] vec1 = this.getElements();
         double[] vec2 = ((Double64Vector)o1).getElements();
@@ -131,7 +131,7 @@
     }
 
     @Override
-    Double64Vector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
+    Double64Vector tOp(Vector<Double> o1, Vector<Double> o2, VectorMask<Double> o3, FTriOp f) {
         double[] res = new double[length()];
         double[] vec1 = getElements();
         double[] vec2 = ((Double64Vector)o1).getElements();
@@ -154,7 +154,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -171,7 +171,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -180,37 +180,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -219,11 +219,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(double.class)) {
-            return (Vector<F>) reshape((Species<Double>)s);
+            return (Vector<F>) reshape((VectorSpecies<Double>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -233,7 +233,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -298,7 +298,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector reshape(Species<Double> s) {
+    public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -361,7 +361,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector add(double o, Mask<Double> m) {
+    public DoubleVector add(double o, VectorMask<Double> m) {
         return add((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -373,7 +373,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector sub(double o, Mask<Double> m) {
+    public DoubleVector sub(double o, VectorMask<Double> m) {
         return sub((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -385,7 +385,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector mul(double o, Mask<Double> m) {
+    public DoubleVector mul(double o, VectorMask<Double> m) {
         return mul((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -403,43 +403,43 @@
 
     @Override
     @ForceInline
-    public Mask<Double> equal(double o) {
+    public VectorMask<Double> equal(double o) {
         return equal((Double64Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> notEqual(double o) {
+    public VectorMask<Double> notEqual(double o) {
         return notEqual((Double64Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThan(double o) {
+    public VectorMask<Double> lessThan(double o) {
         return lessThan((Double64Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThanEq(double o) {
+    public VectorMask<Double> lessThanEq(double o) {
         return lessThanEq((Double64Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThan(double o) {
+    public VectorMask<Double> greaterThan(double o) {
         return greaterThan((Double64Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThanEq(double o) {
+    public VectorMask<Double> greaterThanEq(double o) {
         return greaterThanEq((Double64Vector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public DoubleVector blend(double o, Mask<Double> m) {
+    public DoubleVector blend(double o, VectorMask<Double> m) {
         return blend((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -451,13 +451,13 @@
 
     @Override
     @ForceInline
-    public DoubleVector div(double o, Mask<Double> m) {
+    public DoubleVector div(double o, VectorMask<Double> m) {
         return div((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Double64Vector div(Vector<Double> v, Mask<Double> m) {
+    public Double64Vector div(Vector<Double> v, VectorMask<Double> m) {
         return blend(div(v), m);
     }
 
@@ -469,7 +469,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector atan2(double o, Mask<Double> m) {
+    public DoubleVector atan2(double o, VectorMask<Double> m) {
         return atan2((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -481,7 +481,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector pow(double o, Mask<Double> m) {
+    public DoubleVector pow(double o, VectorMask<Double> m) {
         return pow((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -493,7 +493,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector fma(double o1, double o2, Mask<Double> m) {
+    public DoubleVector fma(double o1, double o2, VectorMask<Double> m) {
         return fma((Double64Vector)DoubleVector.broadcast(SPECIES, o1), (Double64Vector)DoubleVector.broadcast(SPECIES, o2), m);
     }
 
@@ -505,7 +505,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector hypot(double o, Mask<Double> m) {
+    public DoubleVector hypot(double o, VectorMask<Double> m) {
         return hypot((Double64Vector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -514,7 +514,7 @@
 
     @ForceInline
     @Override
-    public Double64Vector neg(Mask<Double> m) {
+    public Double64Vector neg(VectorMask<Double> m) {
         return blend(neg(), m);
     }
 
@@ -529,7 +529,7 @@
 
     @ForceInline
     @Override
-    public Double64Vector abs(Mask<Double> m) {
+    public Double64Vector abs(VectorMask<Double> m) {
         return blend(abs(), m);
     }
 
@@ -746,7 +746,7 @@
 
     @Override
     @ForceInline
-    public Double64Vector add(Vector<Double> v, Mask<Double> m) {
+    public Double64Vector add(Vector<Double> v, VectorMask<Double> m) {
         return blend(add(v), m);
     }
 
@@ -763,7 +763,7 @@
 
     @Override
     @ForceInline
-    public Double64Vector sub(Vector<Double> v, Mask<Double> m) {
+    public Double64Vector sub(Vector<Double> v, VectorMask<Double> m) {
         return blend(sub(v), m);
     }
 
@@ -780,7 +780,7 @@
 
     @Override
     @ForceInline
-    public Double64Vector mul(Vector<Double> v, Mask<Double> m) {
+    public Double64Vector mul(Vector<Double> v, VectorMask<Double> m) {
         return blend(mul(v), m);
     }
 
@@ -797,7 +797,7 @@
 
     @Override
     @ForceInline
-    public Double64Vector min(Vector<Double> v, Mask<Double> m) {
+    public Double64Vector min(Vector<Double> v, VectorMask<Double> m) {
         return blend(min(v), m);
     }
 
@@ -814,7 +814,7 @@
 
     @Override
     @ForceInline
-    public Double64Vector max(Vector<Double> v, Mask<Double> m) {
+    public Double64Vector max(Vector<Double> v, VectorMask<Double> m) {
         return blend(max(v), m);
     }
 
@@ -891,38 +891,38 @@
 
     @Override
     @ForceInline
-    public double addAll(Mask<Double> m) {
+    public double addAll(VectorMask<Double> m) {
         return blend((Double64Vector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(Mask<Double> m) {
+    public double mulAll(VectorMask<Double> m) {
         return blend((Double64Vector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public double minAll(Mask<Double> m) {
+    public double minAll(VectorMask<Double> m) {
         return blend((Double64Vector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public double maxAll(Mask<Double> m) {
+    public double maxAll(VectorMask<Double> m) {
         return blend((Double64Vector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Double> toShuffle() {
+    public VectorShuffle<Double> toShuffle() {
         double[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -944,7 +944,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(double[] a, int ax, Mask<Double> m) {
+    public final void intoArray(double[] a, int ax, VectorMask<Double> m) {
         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
         DoubleVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -957,7 +957,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
+     public final void intoArray(double[] a, int ax, VectorMask<Double> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
          DoubleVector newVal = oldVal.blend(this, m);
@@ -982,7 +982,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Double> m) {
         Double64Vector oldVal = (Double64Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
         Double64Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1011,7 +1011,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m) {
         Double64Vector oldVal = (Double64Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
         Double64Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1136,7 +1136,7 @@
     }
 
     @Override
-    void forEach(Mask<Double> o, FUnCon f) {
+    void forEach(VectorMask<Double> o, FUnCon f) {
         boolean[] mbits = ((Double64Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1201,13 +1201,13 @@
     @Override
     @ForceInline
     public Double64Vector rearrange(Vector<Double> v,
-                                  Shuffle<Double> s, Mask<Double> m) {
+                                  VectorShuffle<Double> s, VectorMask<Double> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Double64Vector rearrange(Shuffle<Double> o1) {
+    public Double64Vector rearrange(VectorShuffle<Double> o1) {
         Objects.requireNonNull(o1);
         Double64Shuffle s =  (Double64Shuffle)o1;
 
@@ -1222,7 +1222,7 @@
 
     @Override
     @ForceInline
-    public Double64Vector blend(Vector<Double> o1, Mask<Double> o2) {
+    public Double64Vector blend(Vector<Double> o1, VectorMask<Double> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Double64Vector v = (Double64Vector)o1;
@@ -1307,7 +1307,7 @@
         }
 
         @Override
-        Double64Mask bOp(Mask<Double> o, MBinOp f) {
+        Double64Mask bOp(VectorMask<Double> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Double64Mask)o).getBits();
@@ -1318,7 +1318,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1337,23 +1337,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte64Vector.Byte64Mask(maskArray);
+                return (VectorMask <E>) new Byte64Vector.Byte64Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short64Vector.Short64Mask(maskArray);
+                return (VectorMask <E>) new Short64Vector.Short64Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int64Vector.Int64Mask(maskArray);
+                return (VectorMask <E>) new Int64Vector.Int64Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long64Vector.Long64Mask(maskArray);
+                return (VectorMask <E>) new Long64Vector.Long64Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float64Vector.Float64Mask(maskArray);
+                return (VectorMask <E>) new Float64Vector.Float64Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double64Vector.Double64Mask(maskArray);
+                return (VectorMask <E>) new Double64Vector.Double64Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1374,7 +1374,7 @@
 
         @Override
         @ForceInline
-        public Double64Mask and(Mask<Double> o) {
+        public Double64Mask and(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double64Mask m = (Double64Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double64Mask.class, long.class, LENGTH,
@@ -1384,7 +1384,7 @@
 
         @Override
         @ForceInline
-        public Double64Mask or(Mask<Double> o) {
+        public Double64Mask or(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             Double64Mask m = (Double64Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double64Mask.class, long.class, LENGTH,
@@ -1406,7 +1406,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Double64Mask.class, long.class, LENGTH,
-                                         this, DoubleVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Double64Mask)m).getBits()));
         }
     }
@@ -1431,7 +1431,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1447,30 +1447,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Double64Shuffle rearrange(Vector.Shuffle<Double> o) {
+        public Double64Shuffle rearrange(VectorShuffle<Double> o) {
             Double64Shuffle s = (Double64Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1480,10 +1480,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Double> species() {
+    public VectorSpecies<Double> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleMaxVector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class DoubleMaxVector extends DoubleVector {
-    private static final Species<Double> SPECIES = DoubleVector.SPECIES_MAX;
+    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_MAX;
 
     static final DoubleMaxVector ZERO = new DoubleMaxVector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final double[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    DoubleMaxVector uOp(Mask<Double> o, FUnOp f) {
+    DoubleMaxVector uOp(VectorMask<Double> o, FUnOp f) {
         double[] vec = getElements();
         double[] res = new double[length()];
         boolean[] mbits = ((DoubleMaxMask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    DoubleMaxVector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
+    DoubleMaxVector bOp(Vector<Double> o1, VectorMask<Double> o2, FBinOp f) {
         double[] res = new double[length()];
         double[] vec1 = this.getElements();
         double[] vec2 = ((DoubleMaxVector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    DoubleMaxVector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
+    DoubleMaxVector tOp(Vector<Double> o1, Vector<Double> o2, VectorMask<Double> o3, FTriOp f) {
         double[] res = new double[length()];
         double[] vec1 = getElements();
         double[] vec2 = ((DoubleMaxVector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(double.class)) {
-            return (Vector<F>) reshape((Species<Double>)s);
+            return (Vector<F>) reshape((VectorSpecies<Double>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector reshape(Species<Double> s) {
+    public DoubleVector reshape(VectorSpecies<Double> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector add(double o, Mask<Double> m) {
+    public DoubleVector add(double o, VectorMask<Double> m) {
         return add((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector sub(double o, Mask<Double> m) {
+    public DoubleVector sub(double o, VectorMask<Double> m) {
         return sub((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector mul(double o, Mask<Double> m) {
+    public DoubleVector mul(double o, VectorMask<Double> m) {
         return mul((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Double> equal(double o) {
+    public VectorMask<Double> equal(double o) {
         return equal((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> notEqual(double o) {
+    public VectorMask<Double> notEqual(double o) {
         return notEqual((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThan(double o) {
+    public VectorMask<Double> lessThan(double o) {
         return lessThan((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> lessThanEq(double o) {
+    public VectorMask<Double> lessThanEq(double o) {
         return lessThanEq((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThan(double o) {
+    public VectorMask<Double> greaterThan(double o) {
         return greaterThan((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Double> greaterThanEq(double o) {
+    public VectorMask<Double> greaterThanEq(double o) {
         return greaterThanEq((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public DoubleVector blend(double o, Mask<Double> m) {
+    public DoubleVector blend(double o, VectorMask<Double> m) {
         return blend((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public DoubleVector div(double o, Mask<Double> m) {
+    public DoubleVector div(double o, VectorMask<Double> m) {
         return div((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public DoubleMaxVector div(Vector<Double> v, Mask<Double> m) {
+    public DoubleMaxVector div(Vector<Double> v, VectorMask<Double> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector atan2(double o, Mask<Double> m) {
+    public DoubleVector atan2(double o, VectorMask<Double> m) {
         return atan2((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector pow(double o, Mask<Double> m) {
+    public DoubleVector pow(double o, VectorMask<Double> m) {
         return pow((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector fma(double o1, double o2, Mask<Double> m) {
+    public DoubleVector fma(double o1, double o2, VectorMask<Double> m) {
         return fma((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o1), (DoubleMaxVector)DoubleVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public DoubleVector hypot(double o, Mask<Double> m) {
+    public DoubleVector hypot(double o, VectorMask<Double> m) {
         return hypot((DoubleMaxVector)DoubleVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public DoubleMaxVector neg(Mask<Double> m) {
+    public DoubleMaxVector neg(VectorMask<Double> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public DoubleMaxVector abs(Mask<Double> m) {
+    public DoubleMaxVector abs(VectorMask<Double> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public DoubleMaxVector add(Vector<Double> v, Mask<Double> m) {
+    public DoubleMaxVector add(Vector<Double> v, VectorMask<Double> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public DoubleMaxVector sub(Vector<Double> v, Mask<Double> m) {
+    public DoubleMaxVector sub(Vector<Double> v, VectorMask<Double> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public DoubleMaxVector mul(Vector<Double> v, Mask<Double> m) {
+    public DoubleMaxVector mul(Vector<Double> v, VectorMask<Double> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public DoubleMaxVector min(Vector<Double> v, Mask<Double> m) {
+    public DoubleMaxVector min(Vector<Double> v, VectorMask<Double> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public DoubleMaxVector max(Vector<Double> v, Mask<Double> m) {
+    public DoubleMaxVector max(Vector<Double> v, VectorMask<Double> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public double addAll(Mask<Double> m) {
+    public double addAll(VectorMask<Double> m) {
         return blend((DoubleMaxVector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public double mulAll(Mask<Double> m) {
+    public double mulAll(VectorMask<Double> m) {
         return blend((DoubleMaxVector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public double minAll(Mask<Double> m) {
+    public double minAll(VectorMask<Double> m) {
         return blend((DoubleMaxVector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public double maxAll(Mask<Double> m) {
+    public double maxAll(VectorMask<Double> m) {
         return blend((DoubleMaxVector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Double> toShuffle() {
+    public VectorShuffle<Double> toShuffle() {
         double[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(double[] a, int ax, Mask<Double> m) {
+    public final void intoArray(double[] a, int ax, VectorMask<Double> m) {
         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
         DoubleVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
+     public final void intoArray(double[] a, int ax, VectorMask<Double> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
          DoubleVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Double> m) {
         DoubleMaxVector oldVal = (DoubleMaxVector) DoubleVector.fromByteArray(SPECIES, a, ix);
         DoubleMaxVector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m) {
         DoubleMaxVector oldVal = (DoubleMaxVector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
         DoubleMaxVector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Double> o, FUnCon f) {
+    void forEach(VectorMask<Double> o, FUnCon f) {
         boolean[] mbits = ((DoubleMaxMask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public DoubleMaxVector rearrange(Vector<Double> v,
-                                  Shuffle<Double> s, Mask<Double> m) {
+                                  VectorShuffle<Double> s, VectorMask<Double> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public DoubleMaxVector rearrange(Shuffle<Double> o1) {
+    public DoubleMaxVector rearrange(VectorShuffle<Double> o1) {
         Objects.requireNonNull(o1);
         DoubleMaxShuffle s =  (DoubleMaxShuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public DoubleMaxVector blend(Vector<Double> o1, Mask<Double> o2) {
+    public DoubleMaxVector blend(Vector<Double> o1, VectorMask<Double> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         DoubleMaxVector v = (DoubleMaxVector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        DoubleMaxMask bOp(Mask<Double> o, MBinOp f) {
+        DoubleMaxMask bOp(VectorMask<Double> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((DoubleMaxMask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new ByteMaxVector.ByteMaxMask(maskArray);
+                return (VectorMask <E>) new ByteMaxVector.ByteMaxMask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new ShortMaxVector.ShortMaxMask(maskArray);
+                return (VectorMask <E>) new ShortMaxVector.ShortMaxMask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new IntMaxVector.IntMaxMask(maskArray);
+                return (VectorMask <E>) new IntMaxVector.IntMaxMask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new LongMaxVector.LongMaxMask(maskArray);
+                return (VectorMask <E>) new LongMaxVector.LongMaxMask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new FloatMaxVector.FloatMaxMask(maskArray);
+                return (VectorMask <E>) new FloatMaxVector.FloatMaxMask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new DoubleMaxVector.DoubleMaxMask(maskArray);
+                return (VectorMask <E>) new DoubleMaxVector.DoubleMaxMask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public DoubleMaxMask and(Mask<Double> o) {
+        public DoubleMaxMask and(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             DoubleMaxMask m = (DoubleMaxMask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, DoubleMaxMask.class, long.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public DoubleMaxMask or(Mask<Double> o) {
+        public DoubleMaxMask or(VectorMask<Double> o) {
             Objects.requireNonNull(o);
             DoubleMaxMask m = (DoubleMaxMask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, DoubleMaxMask.class, long.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, DoubleMaxMask.class, long.class, LENGTH,
-                                         this, DoubleVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((DoubleMaxMask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Double> species() {
+        public VectorSpecies<Double> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new ByteMaxVector.ByteMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new ByteMaxVector.ByteMaxShuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new ShortMaxVector.ShortMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new ShortMaxVector.ShortMaxShuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new IntMaxVector.IntMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new IntMaxVector.IntMaxShuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new LongMaxVector.LongMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new LongMaxVector.LongMaxShuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new FloatMaxVector.FloatMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new FloatMaxVector.FloatMaxShuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new DoubleMaxVector.DoubleMaxShuffle(shuffleArray);
+                return (VectorShuffle<F>) new DoubleMaxVector.DoubleMaxShuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public DoubleMaxShuffle rearrange(Vector.Shuffle<Double> o) {
+        public DoubleMaxShuffle rearrange(VectorShuffle<Double> o) {
             DoubleMaxShuffle s = (DoubleMaxShuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Double> species() {
+    public VectorSpecies<Double> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -56,7 +56,7 @@
 
     abstract DoubleVector uOp(FUnOp f);
 
-    abstract DoubleVector uOp(Mask<Double> m, FUnOp f);
+    abstract DoubleVector uOp(VectorMask<Double> m, FUnOp f);
 
     // Binary operator
 
@@ -66,7 +66,7 @@
 
     abstract DoubleVector bOp(Vector<Double> v, FBinOp f);
 
-    abstract DoubleVector bOp(Vector<Double> v, Mask<Double> m, FBinOp f);
+    abstract DoubleVector bOp(Vector<Double> v, VectorMask<Double> m, FBinOp f);
 
     // Trinary operator
 
@@ -76,7 +76,7 @@
 
     abstract DoubleVector tOp(Vector<Double> v1, Vector<Double> v2, FTriOp f);
 
-    abstract DoubleVector tOp(Vector<Double> v1, Vector<Double> v2, Mask<Double> m, FTriOp f);
+    abstract DoubleVector tOp(Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m, FTriOp f);
 
     // Reduction operator
 
@@ -88,7 +88,7 @@
         boolean apply(int i, double a, double b);
     }
 
-    abstract Mask<Double> bTest(Vector<Double> v, FBinTest f);
+    abstract VectorMask<Double> bTest(Vector<Double> v, FBinTest f);
 
     // Foreach
 
@@ -98,7 +98,7 @@
 
     abstract void forEach(FUnCon f);
 
-    abstract void forEach(Mask<Double> m, FUnCon f);
+    abstract void forEach(VectorMask<Double> m, FUnCon f);
 
     // Static factories
 
@@ -111,7 +111,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector zero(Species<Double> species) {
+    public static DoubleVector zero(VectorSpecies<Double> species) {
         return VectorIntrinsics.broadcastCoerced((Class<DoubleVector>) species.boxType(), double.class, species.length(),
                                                  Double.doubleToLongBits(0.0f), species,
                                                  ((bits, s) -> ((DoubleSpecies)s).op(i -> Double.longBitsToDouble((long)bits))));
@@ -125,7 +125,7 @@
      * <p>
      * This method behaves as if it returns the result of calling the
      * byte buffer, offset, and mask accepting
-     * {@link #fromByteBuffer(Species<Double>, ByteBuffer, int, Mask) method} as follows:
+     * {@link #fromByteBuffer(VectorSpecies<Double>, ByteBuffer, int, VectorMask) method} as follows:
      * <pre>{@code
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
      * }</pre>
@@ -139,7 +139,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector fromByteArray(Species<Double> species, byte[] a, int ix) {
+    public static DoubleVector fromByteArray(VectorSpecies<Double> species, byte[] a, int ix) {
         Objects.requireNonNull(a);
         ix = VectorIntrinsics.checkIndex(ix, a.length, species.bitSize() / Byte.SIZE);
         return VectorIntrinsics.load((Class<DoubleVector>) species.boxType(), double.class, species.length(),
@@ -161,7 +161,7 @@
      * <p>
      * This method behaves as if it returns the result of calling the
      * byte buffer, offset, and mask accepting
-     * {@link #fromByteBuffer(Species<Double>, ByteBuffer, int, Mask) method} as follows:
+     * {@link #fromByteBuffer(VectorSpecies<Double>, ByteBuffer, int, VectorMask) method} as follows:
      * <pre>{@code
      * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
@@ -180,7 +180,7 @@
      * {@code i >= a.length - (N * this.elementSize() / Byte.SIZE)}
      */
     @ForceInline
-    public static DoubleVector fromByteArray(Species<Double> species, byte[] a, int ix, Mask<Double> m) {
+    public static DoubleVector fromByteArray(VectorSpecies<Double> species, byte[] a, int ix, VectorMask<Double> m) {
         return zero(species).blend(fromByteArray(species, a, ix), m);
     }
 
@@ -200,7 +200,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector fromArray(Species<Double> species, double[] a, int i){
+    public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int i){
         Objects.requireNonNull(a);
         i = VectorIntrinsics.checkIndex(i, a.length, species.length());
         return VectorIntrinsics.load((Class<DoubleVector>) species.boxType(), double.class, species.length(),
@@ -229,7 +229,7 @@
      * is set {@code i > a.length - N}
      */
     @ForceInline
-    public static DoubleVector fromArray(Species<Double> species, double[] a, int i, Mask<Double> m) {
+    public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int i, VectorMask<Double> m) {
         return zero(species).blend(fromArray(species, a, i), m);
     }
 
@@ -256,7 +256,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector fromArray(Species<Double> species, double[] a, int i, int[] indexMap, int j) {
+    public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int i, int[] indexMap, int j) {
         Objects.requireNonNull(a);
         Objects.requireNonNull(indexMap);
 
@@ -272,7 +272,7 @@
         return VectorIntrinsics.loadWithMap((Class<DoubleVector>) species.boxType(), double.class, species.length(),
                                             IntVector.species(species.indexShape()).boxType(), a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
                                             a, i, indexMap, j, species,
-                                            (double[] c, int idx, int[] iMap, int idy, Species<Double> s) ->
+                                            (double[] c, int idx, int[] iMap, int idy, VectorSpecies<Double> s) ->
                                                 ((DoubleSpecies)s).op(n -> c[idx + iMap[idy+n]]));
         }
 
@@ -302,7 +302,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector fromArray(Species<Double> species, double[] a, int i, Mask<Double> m, int[] indexMap, int j) {
+    public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int i, VectorMask<Double> m, int[] indexMap, int j) {
         // @@@ This can result in out of bounds errors for unset mask lanes
         return zero(species).blend(fromArray(species, a, i, indexMap, j), m);
     }
@@ -317,7 +317,7 @@
      * <p>
      * This method behaves as if it returns the result of calling the
      * byte buffer, offset, and mask accepting
-     * {@link #fromByteBuffer(Species<Double>, ByteBuffer, int, Mask)} method} as follows:
+     * {@link #fromByteBuffer(VectorSpecies<Double>, ByteBuffer, int, VectorMask)} method} as follows:
      * <pre>{@code
      *   return this.fromByteBuffer(b, i, this.maskAllTrue())
      * }</pre>
@@ -334,7 +334,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector fromByteBuffer(Species<Double> species, ByteBuffer bb, int ix) {
+    public static DoubleVector fromByteBuffer(VectorSpecies<Double> species, ByteBuffer bb, int ix) {
         if (bb.order() != ByteOrder.nativeOrder()) {
             throw new IllegalArgumentException();
         }
@@ -386,7 +386,7 @@
      * {@code i >= b.limit() - (N * this.elementSize() / Byte.SIZE)}
      */
     @ForceInline
-    public static DoubleVector fromByteBuffer(Species<Double> species, ByteBuffer bb, int ix, Mask<Double> m) {
+    public static DoubleVector fromByteBuffer(VectorSpecies<Double> species, ByteBuffer bb, int ix, VectorMask<Double> m) {
         return zero(species).blend(fromByteBuffer(species, bb, ix), m);
     }
 
@@ -401,7 +401,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector broadcast(Species<Double> s, double e) {
+    public static DoubleVector broadcast(VectorSpecies<Double> s, double e) {
         return VectorIntrinsics.broadcastCoerced(
             (Class<DoubleVector>) s.boxType(), double.class, s.length(),
             Double.doubleToLongBits(e), s,
@@ -424,7 +424,7 @@
      */
     @ForceInline
     @SuppressWarnings("unchecked")
-    public static DoubleVector scalars(Species<Double> s, double... es) {
+    public static DoubleVector scalars(VectorSpecies<Double> s, double... es) {
         Objects.requireNonNull(es);
         int ix = VectorIntrinsics.checkIndex(0, es.length, s.length());
         return VectorIntrinsics.load((Class<DoubleVector>) s.boxType(), double.class, s.length(),
@@ -444,7 +444,7 @@
      * value {@code e}
      */
     @ForceInline
-    public static final DoubleVector single(Species<Double> s, double e) {
+    public static final DoubleVector single(VectorSpecies<Double> s, double e) {
         return zero(s).with(0, e);
     }
 
@@ -459,235 +459,11 @@
      * @return a vector where each lane elements is set to a randomly
      * generated primitive value
      */
-    public static DoubleVector random(Species<Double> s) {
+    public static DoubleVector random(VectorSpecies<Double> s) {
         ThreadLocalRandom r = ThreadLocalRandom.current();
         return ((DoubleSpecies)s).op(i -> r.nextDouble());
     }
 
-    /**
-     * Returns a mask where each lane is set or unset according to given
-     * {@code boolean} values
-     * <p>
-     * For each mask lane, where {@code N} is the mask lane index,
-     * if the given {@code boolean} value at index {@code N} is {@code true}
-     * then the mask lane at index {@code N} is set, otherwise it is unset.
-     *
-     * @param species mask species
-     * @param bits the given {@code boolean} values
-     * @return a mask where each lane is set or unset according to the given {@code boolean} value
-     * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
-     */
-    @ForceInline
-    public static Mask<Double> maskFromValues(Species<Double> species, boolean... bits) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return new DoubleMaxVector.DoubleMaxMask(bits);
-        switch (species.bitSize()) {
-            case 64: return new Double64Vector.Double64Mask(bits);
-            case 128: return new Double128Vector.Double128Mask(bits);
-            case 256: return new Double256Vector.Double256Mask(bits);
-            case 512: return new Double512Vector.Double512Mask(bits);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    // @@@ This is a bad implementation -- makes lambdas capturing -- fix this
-    static Mask<Double> trueMask(Species<Double> species) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return DoubleMaxVector.DoubleMaxMask.TRUE_MASK;
-        switch (species.bitSize()) {
-            case 64: return Double64Vector.Double64Mask.TRUE_MASK;
-            case 128: return Double128Vector.Double128Mask.TRUE_MASK;
-            case 256: return Double256Vector.Double256Mask.TRUE_MASK;
-            case 512: return Double512Vector.Double512Mask.TRUE_MASK;
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    static Mask<Double> falseMask(Species<Double> species) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return DoubleMaxVector.DoubleMaxMask.FALSE_MASK;
-        switch (species.bitSize()) {
-            case 64: return Double64Vector.Double64Mask.FALSE_MASK;
-            case 128: return Double128Vector.Double128Mask.FALSE_MASK;
-            case 256: return Double256Vector.Double256Mask.FALSE_MASK;
-            case 512: return Double512Vector.Double512Mask.FALSE_MASK;
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Loads a mask from a {@code boolean} array starting at an offset.
-     * <p>
-     * For each mask lane, where {@code N} is the mask lane index,
-     * if the array element at index {@code ix + N} is {@code true} then the
-     * mask lane at index {@code N} is set, otherwise it is unset.
-     *
-     * @param species mask species
-     * @param bits the {@code boolean} array
-     * @param ix the offset into the array
-     * @return the mask loaded from a {@code boolean} array
-     * @throws IndexOutOfBoundsException if {@code ix < 0}, or
-     * {@code ix > bits.length - species.length()}
-     */
-    @ForceInline
-    @SuppressWarnings("unchecked")
-    public static Mask<Double> maskFromArray(Species<Double> species, boolean[] bits, int ix) {
-        Objects.requireNonNull(bits);
-        ix = VectorIntrinsics.checkIndex(ix, bits.length, species.length());
-        return VectorIntrinsics.load((Class<Mask<Double>>) species.maskType(), long.class, species.length(),
-                                     bits, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
-                                     bits, ix, species,
-                                     (c, idx, s) -> (Mask<Double>) ((DoubleSpecies)s).opm(n -> c[idx + n]));
-    }
-
-    /**
-     * Returns a mask where all lanes are set.
-     *
-     * @param species mask species
-     * @return a mask where all lanes are set
-     */
-    @ForceInline
-    @SuppressWarnings("unchecked")
-    public static Mask<Double> maskAllTrue(Species<Double> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<Mask<Double>>) species.maskType(), long.class, species.length(),
-                                                 (long)-1,  species,
-                                                 ((z, s) -> trueMask(s)));
-    }
-
-    /**
-     * Returns a mask where all lanes are unset.
-     *
-     * @param species mask species
-     * @return a mask where all lanes are unset
-     */
-    @ForceInline
-    @SuppressWarnings("unchecked")
-    public static Mask<Double> maskAllFalse(Species<Double> species) {
-        return VectorIntrinsics.broadcastCoerced((Class<Mask<Double>>) species.maskType(), long.class, species.length(),
-                                                 0, species, 
-                                                 ((z, s) -> falseMask(s)));
-    }
-
-    /**
-     * Returns a shuffle of mapped indexes where each lane element is
-     * the result of applying a mapping function to the corresponding lane
-     * index.
-     * <p>
-     * Care should be taken to ensure Shuffle values produced from this
-     * method are consumed as constants to ensure optimal generation of
-     * code.  For example, values held in static final fields or values
-     * held in loop constant local variables.
-     * <p>
-     * This method behaves as if a shuffle is created from an array of
-     * mapped indexes as follows:
-     * <pre>{@code
-     *   int[] a = new int[species.length()];
-     *   for (int i = 0; i < a.length; i++) {
-     *       a[i] = f.applyAsInt(i);
-     *   }
-     *   return this.shuffleFromValues(a);
-     * }</pre>
-     *
-     * @param species shuffle species
-     * @param f the lane index mapping function
-     * @return a shuffle of mapped indexes
-     */
-    @ForceInline
-    public static Shuffle<Double> shuffle(Species<Double> species, IntUnaryOperator f) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return new DoubleMaxVector.DoubleMaxShuffle(f);
-        switch (species.bitSize()) {
-            case 64: return new Double64Vector.Double64Shuffle(f);
-            case 128: return new Double128Vector.Double128Shuffle(f);
-            case 256: return new Double256Vector.Double256Shuffle(f);
-            case 512: return new Double512Vector.Double512Shuffle(f);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Returns a shuffle where each lane element is the value of its
-     * corresponding lane index.
-     * <p>
-     * This method behaves as if a shuffle is created from an identity
-     * index mapping function as follows:
-     * <pre>{@code
-     *   return this.shuffle(i -> i);
-     * }</pre>
-     *
-     * @param species shuffle species
-     * @return a shuffle of lane indexes
-     */
-    @ForceInline
-    public static Shuffle<Double> shuffleIota(Species<Double> species) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return new DoubleMaxVector.DoubleMaxShuffle(AbstractShuffle.IDENTITY);
-        switch (species.bitSize()) {
-            case 64: return new Double64Vector.Double64Shuffle(AbstractShuffle.IDENTITY);
-            case 128: return new Double128Vector.Double128Shuffle(AbstractShuffle.IDENTITY);
-            case 256: return new Double256Vector.Double256Shuffle(AbstractShuffle.IDENTITY);
-            case 512: return new Double512Vector.Double512Shuffle(AbstractShuffle.IDENTITY);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Returns a shuffle where each lane element is set to a given
-     * {@code int} value logically AND'ed by the species length minus one.
-     * <p>
-     * For each shuffle lane, where {@code N} is the shuffle lane index, the
-     * the {@code int} value at index {@code N} logically AND'ed by
-     * {@code species.length() - 1} is placed into the resulting shuffle at
-     * lane index {@code N}.
-     *
-     * @param species shuffle species
-     * @param ixs the given {@code int} values
-     * @return a shuffle where each lane element is set to a given
-     * {@code int} value
-     * @throws IndexOutOfBoundsException if the number of int values is
-     * {@code < species.length()}
-     */
-    @ForceInline
-    public static Shuffle<Double> shuffleFromValues(Species<Double> species, int... ixs) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return new DoubleMaxVector.DoubleMaxShuffle(ixs);
-        switch (species.bitSize()) {
-            case 64: return new Double64Vector.Double64Shuffle(ixs);
-            case 128: return new Double128Vector.Double128Shuffle(ixs);
-            case 256: return new Double256Vector.Double256Shuffle(ixs);
-            case 512: return new Double512Vector.Double512Shuffle(ixs);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
-    /**
-     * Loads a shuffle from an {@code int} array starting at an offset.
-     * <p>
-     * For each shuffle lane, where {@code N} is the shuffle lane index, the
-     * array element at index {@code i + N} logically AND'ed by
-     * {@code species.length() - 1} is placed into the resulting shuffle at lane
-     * index {@code N}.
-     *
-     * @param species shuffle species
-     * @param ixs the {@code int} array
-     * @param i the offset into the array
-     * @return a shuffle loaded from the {@code int} array
-     * @throws IndexOutOfBoundsException if {@code i < 0}, or
-     * {@code i > a.length - species.length()}
-     */
-    @ForceInline
-    public static Shuffle<Double> shuffleFromArray(Species<Double> species, int[] ixs, int i) {
-        if (species.boxType() == DoubleMaxVector.class)
-            return new DoubleMaxVector.DoubleMaxShuffle(ixs, i);
-        switch (species.bitSize()) {
-            case 64: return new Double64Vector.Double64Shuffle(ixs, i);
-            case 128: return new Double128Vector.Double128Shuffle(ixs, i);
-            case 256: return new Double256Vector.Double256Shuffle(ixs, i);
-            case 512: return new Double512Vector.Double512Shuffle(ixs, i);
-            default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
-        }
-    }
-
     // Ops
 
     @Override
@@ -706,7 +482,7 @@
     public abstract DoubleVector add(double s);
 
     @Override
-    public abstract DoubleVector add(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector add(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Adds this vector to broadcast of an input scalar,
@@ -720,7 +496,7 @@
      * @return the result of adding this vector to the broadcast of an input
      * scalar
      */
-    public abstract DoubleVector add(double s, Mask<Double> m);
+    public abstract DoubleVector add(double s, VectorMask<Double> m);
 
     @Override
     public abstract DoubleVector sub(Vector<Double> v);
@@ -738,7 +514,7 @@
     public abstract DoubleVector sub(double s);
 
     @Override
-    public abstract DoubleVector sub(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector sub(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Subtracts the broadcast of an input scalar from this vector, selecting
@@ -752,7 +528,7 @@
      * @return the result of subtracting the broadcast of an input
      * scalar from this vector
      */
-    public abstract DoubleVector sub(double s, Mask<Double> m);
+    public abstract DoubleVector sub(double s, VectorMask<Double> m);
 
     @Override
     public abstract DoubleVector mul(Vector<Double> v);
@@ -770,7 +546,7 @@
     public abstract DoubleVector mul(double s);
 
     @Override
-    public abstract DoubleVector mul(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector mul(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Multiplies this vector with the broadcast of an input scalar, selecting
@@ -784,25 +560,25 @@
      * @return the result of multiplying this vector with the broadcast of an
      * input scalar
      */
-    public abstract DoubleVector mul(double s, Mask<Double> m);
+    public abstract DoubleVector mul(double s, VectorMask<Double> m);
 
     @Override
     public abstract DoubleVector neg();
 
     @Override
-    public abstract DoubleVector neg(Mask<Double> m);
+    public abstract DoubleVector neg(VectorMask<Double> m);
 
     @Override
     public abstract DoubleVector abs();
 
     @Override
-    public abstract DoubleVector abs(Mask<Double> m);
+    public abstract DoubleVector abs(VectorMask<Double> m);
 
     @Override
     public abstract DoubleVector min(Vector<Double> v);
 
     @Override
-    public abstract DoubleVector min(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector min(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Returns the minimum of this vector and the broadcast of an input scalar.
@@ -819,7 +595,7 @@
     public abstract DoubleVector max(Vector<Double> v);
 
     @Override
-    public abstract DoubleVector max(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector max(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Returns the maximum of this vector and the broadcast of an input scalar.
@@ -833,7 +609,7 @@
     public abstract DoubleVector max(double s);
 
     @Override
-    public abstract Mask<Double> equal(Vector<Double> v);
+    public abstract VectorMask<Double> equal(Vector<Double> v);
 
     /**
      * Tests if this vector is equal to the broadcast of an input scalar.
@@ -845,10 +621,10 @@
      * @return the result mask of testing if this vector is equal to the
      * broadcast of an input scalar
      */
-    public abstract Mask<Double> equal(double s);
+    public abstract VectorMask<Double> equal(double s);
 
     @Override
-    public abstract Mask<Double> notEqual(Vector<Double> v);
+    public abstract VectorMask<Double> notEqual(Vector<Double> v);
 
     /**
      * Tests if this vector is not equal to the broadcast of an input scalar.
@@ -860,10 +636,10 @@
      * @return the result mask of testing if this vector is not equal to the
      * broadcast of an input scalar
      */
-    public abstract Mask<Double> notEqual(double s);
+    public abstract VectorMask<Double> notEqual(double s);
 
     @Override
-    public abstract Mask<Double> lessThan(Vector<Double> v);
+    public abstract VectorMask<Double> lessThan(Vector<Double> v);
 
     /**
      * Tests if this vector is less than the broadcast of an input scalar.
@@ -875,10 +651,10 @@
      * @return the mask result of testing if this vector is less than the
      * broadcast of an input scalar
      */
-    public abstract Mask<Double> lessThan(double s);
+    public abstract VectorMask<Double> lessThan(double s);
 
     @Override
-    public abstract Mask<Double> lessThanEq(Vector<Double> v);
+    public abstract VectorMask<Double> lessThanEq(Vector<Double> v);
 
     /**
      * Tests if this vector is less or equal to the broadcast of an input scalar.
@@ -890,10 +666,10 @@
      * @return the mask result of testing if this vector is less than or equal
      * to the broadcast of an input scalar
      */
-    public abstract Mask<Double> lessThanEq(double s);
+    public abstract VectorMask<Double> lessThanEq(double s);
 
     @Override
-    public abstract Mask<Double> greaterThan(Vector<Double> v);
+    public abstract VectorMask<Double> greaterThan(Vector<Double> v);
 
     /**
      * Tests if this vector is greater than the broadcast of an input scalar.
@@ -905,10 +681,10 @@
      * @return the mask result of testing if this vector is greater than the
      * broadcast of an input scalar
      */
-    public abstract Mask<Double> greaterThan(double s);
+    public abstract VectorMask<Double> greaterThan(double s);
 
     @Override
-    public abstract Mask<Double> greaterThanEq(Vector<Double> v);
+    public abstract VectorMask<Double> greaterThanEq(Vector<Double> v);
 
     /**
      * Tests if this vector is greater than or equal to the broadcast of an
@@ -921,10 +697,10 @@
      * @return the mask result of testing if this vector is greater than or
      * equal to the broadcast of an input scalar
      */
-    public abstract Mask<Double> greaterThanEq(double s);
+    public abstract VectorMask<Double> greaterThanEq(double s);
 
     @Override
-    public abstract DoubleVector blend(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector blend(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Blends the lane elements of this vector with those of the broadcast of an
@@ -941,17 +717,17 @@
      * @return the result of blending the lane elements of this vector with
      * those of the broadcast of an input scalar
      */
-    public abstract DoubleVector blend(double s, Mask<Double> m);
+    public abstract DoubleVector blend(double s, VectorMask<Double> m);
 
     @Override
     public abstract DoubleVector rearrange(Vector<Double> v,
-                                                      Shuffle<Double> s, Mask<Double> m);
+                                                      VectorShuffle<Double> s, VectorMask<Double> m);
 
     @Override
-    public abstract DoubleVector rearrange(Shuffle<Double> m);
+    public abstract DoubleVector rearrange(VectorShuffle<Double> m);
 
     @Override
-    public abstract DoubleVector reshape(Species<Double> s);
+    public abstract DoubleVector reshape(VectorSpecies<Double> s);
 
     @Override
     public abstract DoubleVector rotateEL(int i);
@@ -999,7 +775,7 @@
      * @param m the mask controlling lane selection
      * @return the result of dividing this vector by the input vector
      */
-    public abstract DoubleVector div(Vector<Double> v, Mask<Double> m);
+    public abstract DoubleVector div(Vector<Double> v, VectorMask<Double> m);
 
     /**
      * Divides this vector by the broadcast of an input scalar, selecting lane
@@ -1013,7 +789,7 @@
      * @return the result of dividing this vector by the broadcast of an input
      * scalar
      */
-    public abstract DoubleVector div(double s, Mask<Double> m);
+    public abstract DoubleVector div(double s, VectorMask<Double> m);
 
     /**
      * Calculates the square root of this vector.
@@ -1035,7 +811,7 @@
      * @param m the mask controlling lane selection
      * @return the square root of this vector
      */
-    public DoubleVector sqrt(Mask<Double> m) {
+    public DoubleVector sqrt(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.sqrt((double) a));
     }
 
@@ -1066,7 +842,7 @@
      * @param m the mask controlling lane selection
      * @return the tangent of this vector
      */
-    public DoubleVector tan(Mask<Double> m) {
+    public DoubleVector tan(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.tan((double) a));
     }
 
@@ -1097,7 +873,7 @@
      * @param m the mask controlling lane selection
      * @return the hyperbolic tangent of this vector
      */
-    public DoubleVector tanh(Mask<Double> m) {
+    public DoubleVector tanh(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.tanh((double) a));
     }
 
@@ -1128,7 +904,7 @@
      * @param m the mask controlling lane selection
      * @return the sine of this vector
      */
-    public DoubleVector sin(Mask<Double> m) {
+    public DoubleVector sin(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.sin((double) a));
     }
 
@@ -1159,7 +935,7 @@
      * @param m the mask controlling lane selection
      * @return the hyperbolic sine of this vector
      */
-    public DoubleVector sinh(Mask<Double> m) {
+    public DoubleVector sinh(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.sinh((double) a));
     }
 
@@ -1190,7 +966,7 @@
      * @param m the mask controlling lane selection
      * @return the cosine of this vector
      */
-    public DoubleVector cos(Mask<Double> m) {
+    public DoubleVector cos(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.cos((double) a));
     }
 
@@ -1221,7 +997,7 @@
      * @param m the mask controlling lane selection
      * @return the hyperbolic cosine of this vector
      */
-    public DoubleVector cosh(Mask<Double> m) {
+    public DoubleVector cosh(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.cosh((double) a));
     }
 
@@ -1252,7 +1028,7 @@
      * @param m the mask controlling lane selection
      * @return the arc sine of this vector
      */
-    public DoubleVector asin(Mask<Double> m) {
+    public DoubleVector asin(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.asin((double) a));
     }
 
@@ -1283,7 +1059,7 @@
      * @param m the mask controlling lane selection
      * @return the arc cosine of this vector
      */
-    public DoubleVector acos(Mask<Double> m) {
+    public DoubleVector acos(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.acos((double) a));
     }
 
@@ -1314,7 +1090,7 @@
      * @param m the mask controlling lane selection
      * @return the arc tangent of this vector
      */
-    public DoubleVector atan(Mask<Double> m) {
+    public DoubleVector atan(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.atan((double) a));
     }
 
@@ -1364,7 +1140,7 @@
      * @param m the mask controlling lane selection
      * @return the arc tangent of this vector divided by the input vector
      */
-    public DoubleVector atan2(Vector<Double> v, Mask<Double> m) {
+    public DoubleVector atan2(Vector<Double> v, VectorMask<Double> m) {
         return bOp(v, m, (i, a, b) -> (double) Math.atan2((double) a, (double) b));
     }
 
@@ -1379,7 +1155,7 @@
      * @param m the mask controlling lane selection
      * @return the arc tangent of this vector over the input vector
      */
-    public abstract DoubleVector atan2(double s, Mask<Double> m);
+    public abstract DoubleVector atan2(double s, VectorMask<Double> m);
 
     /**
      * Calculates the cube root of this vector.
@@ -1408,7 +1184,7 @@
      * @param m the mask controlling lane selection
      * @return the cube root of this vector
      */
-    public DoubleVector cbrt(Mask<Double> m) {
+    public DoubleVector cbrt(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.cbrt((double) a));
     }
 
@@ -1439,7 +1215,7 @@
      * @param m the mask controlling lane selection
      * @return the natural logarithm of this vector
      */
-    public DoubleVector log(Mask<Double> m) {
+    public DoubleVector log(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.log((double) a));
     }
 
@@ -1470,7 +1246,7 @@
      * @param m the mask controlling lane selection
      * @return the base 10 logarithm of this vector
      */
-    public DoubleVector log10(Mask<Double> m) {
+    public DoubleVector log10(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.log10((double) a));
     }
 
@@ -1504,7 +1280,7 @@
      * @return the natural logarithm of the sum of this vector and the broadcast
      * of {@code 1}
      */
-    public DoubleVector log1p(Mask<Double> m) {
+    public DoubleVector log1p(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.log1p((double) a));
     }
 
@@ -1555,7 +1331,7 @@
      * @param m the mask controlling lane selection
      * @return this vector raised to the power of an input vector
      */
-    public DoubleVector pow(Vector<Double> v, Mask<Double> m) {
+    public DoubleVector pow(Vector<Double> v, VectorMask<Double> m) {
         return bOp(v, m, (i, a, b) -> (double) Math.pow((double) a, (double) b));
     }
 
@@ -1571,7 +1347,7 @@
      * @return this vector raised to the power of the broadcast of an input
      * scalar.
      */
-    public abstract DoubleVector pow(double s, Mask<Double> m);
+    public abstract DoubleVector pow(double s, VectorMask<Double> m);
 
     /**
      * Calculates the broadcast of Euler's number {@code e} raised to the power
@@ -1603,7 +1379,7 @@
      * @return the broadcast of Euler's number {@code e} raised to the power of
      * this vector
      */
-    public DoubleVector exp(Mask<Double> m) {
+    public DoubleVector exp(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.exp((double) a));
     }
 
@@ -1648,7 +1424,7 @@
      * @return the broadcast of Euler's number {@code e} raised to the power of
      * this vector minus the broadcast of {@code -1}
      */
-    public DoubleVector expm1(Mask<Double> m) {
+    public DoubleVector expm1(VectorMask<Double> m) {
         return uOp(m, (i, a) -> (double) Math.expm1((double) a));
     }
 
@@ -1707,7 +1483,7 @@
      * @return the product of this vector and the first input vector summed with
      * the second input vector
      */
-    public DoubleVector fma(Vector<Double> v1, Vector<Double> v2, Mask<Double> m) {
+    public DoubleVector fma(Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m) {
         return tOp(v1, v2, m, (i, a, b, c) -> Math.fma(a, b, c));
     }
 
@@ -1729,7 +1505,7 @@
      * @return the product of this vector and the broadcast of a first input
      * scalar summed with the broadcast of a second input scalar
      */
-    public abstract DoubleVector fma(double s1, double s2, Mask<Double> m);
+    public abstract DoubleVector fma(double s1, double s2, VectorMask<Double> m);
 
     /**
      * Calculates square root of the sum of the squares of this vector and an
@@ -1796,7 +1572,7 @@
      * @return square root of the sum of the squares of this vector and an input
      * vector
      */
-    public DoubleVector hypot(Vector<Double> v, Mask<Double> m) {
+    public DoubleVector hypot(Vector<Double> v, VectorMask<Double> m) {
         return bOp(v, m, (i, a, b) -> (double) Math.hypot((double) a, (double) b));
     }
 
@@ -1818,20 +1594,20 @@
      * @return square root of the sum of the squares of this vector and the
      * broadcast of an input scalar
      */
-    public abstract DoubleVector hypot(double s, Mask<Double> m);
+    public abstract DoubleVector hypot(double s, VectorMask<Double> m);
 
 
     @Override
     public abstract void intoByteArray(byte[] a, int ix);
 
     @Override
-    public abstract void intoByteArray(byte[] a, int ix, Mask<Double> m);
+    public abstract void intoByteArray(byte[] a, int ix, VectorMask<Double> m);
 
     @Override
     public abstract void intoByteBuffer(ByteBuffer bb, int ix);
 
     @Override
-    public abstract void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m);
+    public abstract void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m);
 
 
     // Type specific horizontal reductions
@@ -1875,7 +1651,7 @@
      * @param m the mask controlling lane selection
      * @return the addition of the selected lane elements of this vector
      */
-    public abstract double addAll(Mask<Double> m);
+    public abstract double addAll(VectorMask<Double> m);
 
     /**
      * Multiplies all lane elements of this vector.
@@ -1915,7 +1691,7 @@
      * @param m the mask controlling lane selection
      * @return the multiplication of all the lane elements of this vector
      */
-    public abstract double mulAll(Mask<Double> m);
+    public abstract double mulAll(VectorMask<Double> m);
 
     /**
      * Returns the minimum lane element of this vector.
@@ -1941,7 +1717,7 @@
      * @param m the mask controlling lane selection
      * @return the minimum lane element of this vector
      */
-    public abstract double minAll(Mask<Double> m);
+    public abstract double minAll(VectorMask<Double> m);
 
     /**
      * Returns the maximum lane element of this vector.
@@ -1967,7 +1743,7 @@
      * @param m the mask controlling lane selection
      * @return the maximum lane element of this vector
      */
-    public abstract double maxAll(Mask<Double> m);
+    public abstract double maxAll(VectorMask<Double> m);
 
 
     // Type specific accessors
@@ -2050,7 +1826,7 @@
      * for any vector lane index {@code N} where the mask at lane {@code N}
      * is set {@code i >= a.length - N}
      */
-    public abstract void intoArray(double[] a, int i, Mask<Double> m);
+    public abstract void intoArray(double[] a, int i, VectorMask<Double> m);
 
     /**
      * Stores this vector into an array using indexes obtained from an index
@@ -2095,37 +1871,34 @@
      * {@code N} is set the result of {@code i + indexMap[j + N]} is
      * {@code < 0} or {@code >= a.length}
      */
-    public abstract void intoArray(double[] a, int i, Mask<Double> m, int[] indexMap, int j);
+    public abstract void intoArray(double[] a, int i, VectorMask<Double> m, int[] indexMap, int j);
     // Species
 
     @Override
-    public abstract Species<Double> species();
+    public abstract VectorSpecies<Double> species();
 
     /**
-     * Class representing {@link DoubleVector}'s of the same {@link Vector.Shape Shape}.
+     * Class representing {@link DoubleVector}'s of the same {@link VectorShape VectorShape}.
      */
-    static final class DoubleSpecies extends Vector.AbstractSpecies<Double> {
+    static final class DoubleSpecies extends AbstractSpecies<Double> {
         final Function<double[], DoubleVector> vectorFactory;
-        final Function<boolean[], Vector.Mask<Double>> maskFactory;
 
-        private DoubleSpecies(Vector.Shape shape,
+        private DoubleSpecies(VectorShape shape,
                           Class<?> boxType,
                           Class<?> maskType,
                           Function<double[], DoubleVector> vectorFactory,
-                          Function<boolean[], Vector.Mask<Double>> maskFactory) {
-            super(shape, double.class, Double.SIZE, boxType, maskType);
+                          Function<boolean[], VectorMask<Double>> maskFactory,
+                          Function<IntUnaryOperator, VectorShuffle<Double>> shuffleFromArrayFactory,
+                          fShuffleFromArray<Double> shuffleFromOpFactory) {
+            super(shape, double.class, Double.SIZE, boxType, maskType, maskFactory,
+                  shuffleFromArrayFactory, shuffleFromOpFactory);
             this.vectorFactory = vectorFactory;
-            this.maskFactory = maskFactory;
         }
 
         interface FOp {
             double apply(int i);
         }
 
-        interface FOpm {
-            boolean apply(int i);
-        }
-
         DoubleVector op(FOp f) {
             double[] res = new double[length()];
             for (int i = 0; i < length(); i++) {
@@ -2134,7 +1907,7 @@
             return vectorFactory.apply(res);
         }
 
-        DoubleVector op(Vector.Mask<Double> o, FOp f) {
+        DoubleVector op(VectorMask<Double> o, FOp f) {
             double[] res = new double[length()];
             boolean[] mbits = ((AbstractMask<Double>)o).getBits();
             for (int i = 0; i < length(); i++) {
@@ -2144,14 +1917,6 @@
             }
             return vectorFactory.apply(res);
         }
-
-        Vector.Mask<Double> opm(IntVector.IntSpecies.FOpm f) {
-            boolean[] res = new boolean[length()];
-            for (int i = 0; i < length(); i++) {
-                res[i] = (boolean)f.apply(i);
-            }
-            return maskFactory.apply(res);
-        }
     }
 
     /**
@@ -2165,7 +1930,7 @@
      * @return the preferred species for an element type of {@code double}
      */
     private static DoubleSpecies preferredSpecies() {
-        return (DoubleSpecies) Species.ofPreferred(double.class);
+        return (DoubleSpecies) VectorSpecies.ofPreferred(double.class);
     }
 
     /**
@@ -2175,7 +1940,7 @@
      * @return a species for an element type of {@code double} and shape
      * @throws IllegalArgumentException if no such species exists for the shape
      */
-    static DoubleSpecies species(Vector.Shape s) {
+    static DoubleSpecies species(VectorShape s) {
         Objects.requireNonNull(s);
         switch (s) {
             case S_64_BIT: return (DoubleSpecies) SPECIES_64;
@@ -2187,29 +1952,34 @@
         }
     }
 
-    /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_64_BIT Shape.S_64_BIT}. */
-    public static final Species<Double> SPECIES_64 = new DoubleSpecies(Shape.S_64_BIT, Double64Vector.class, Double64Vector.Double64Mask.class,
-                                                                     Double64Vector::new, Double64Vector.Double64Mask::new);
+    /** Species representing {@link DoubleVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */
+    public static final VectorSpecies<Double> SPECIES_64 = new DoubleSpecies(VectorShape.S_64_BIT, Double64Vector.class, Double64Vector.Double64Mask.class,
+                                                                     Double64Vector::new, Double64Vector.Double64Mask::new,
+                                                                     Double64Vector.Double64Shuffle::new, Double64Vector.Double64Shuffle::new);
 
-    /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_128_BIT Shape.S_128_BIT}. */
-    public static final Species<Double> SPECIES_128 = new DoubleSpecies(Shape.S_128_BIT, Double128Vector.class, Double128Vector.Double128Mask.class,
-                                                                      Double128Vector::new, Double128Vector.Double128Mask::new);
+    /** Species representing {@link DoubleVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */
+    public static final VectorSpecies<Double> SPECIES_128 = new DoubleSpecies(VectorShape.S_128_BIT, Double128Vector.class, Double128Vector.Double128Mask.class,
+                                                                      Double128Vector::new, Double128Vector.Double128Mask::new,
+                                                                      Double128Vector.Double128Shuffle::new, Double128Vector.Double128Shuffle::new);
 
-    /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_256_BIT Shape.S_256_BIT}. */
-    public static final Species<Double> SPECIES_256 = new DoubleSpecies(Shape.S_256_BIT, Double256Vector.class, Double256Vector.Double256Mask.class,
-                                                                      Double256Vector::new, Double256Vector.Double256Mask::new);
+    /** Species representing {@link DoubleVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */
+    public static final VectorSpecies<Double> SPECIES_256 = new DoubleSpecies(VectorShape.S_256_BIT, Double256Vector.class, Double256Vector.Double256Mask.class,
+                                                                      Double256Vector::new, Double256Vector.Double256Mask::new,
+                                                                      Double256Vector.Double256Shuffle::new, Double256Vector.Double256Shuffle::new);
 
-    /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_512_BIT Shape.S_512_BIT}. */
-    public static final Species<Double> SPECIES_512 = new DoubleSpecies(Shape.S_512_BIT, Double512Vector.class, Double512Vector.Double512Mask.class,
-                                                                      Double512Vector::new, Double512Vector.Double512Mask::new);
+    /** Species representing {@link DoubleVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */
+    public static final VectorSpecies<Double> SPECIES_512 = new DoubleSpecies(VectorShape.S_512_BIT, Double512Vector.class, Double512Vector.Double512Mask.class,
+                                                                      Double512Vector::new, Double512Vector.Double512Mask::new,
+                                                                      Double512Vector.Double512Shuffle::new, Double512Vector.Double512Shuffle::new);
 
-    /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_Max_BIT Shape.S_Max_BIT}. */
-    public static final Species<Double> SPECIES_MAX = new DoubleSpecies(Shape.S_Max_BIT, DoubleMaxVector.class, DoubleMaxVector.DoubleMaxMask.class,
-                                                                      DoubleMaxVector::new, DoubleMaxVector.DoubleMaxMask::new);
+    /** Species representing {@link DoubleVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */
+    public static final VectorSpecies<Double> SPECIES_MAX = new DoubleSpecies(VectorShape.S_Max_BIT, DoubleMaxVector.class, DoubleMaxVector.DoubleMaxMask.class,
+                                                                      DoubleMaxVector::new, DoubleMaxVector.DoubleMaxMask::new,
+                                                                      DoubleMaxVector.DoubleMaxShuffle::new, DoubleMaxVector.DoubleMaxShuffle::new);
 
     /**
      * Preferred species for {@link DoubleVector}s.
      * A preferred species is a species of maximal bit size for the platform.
      */
-    public static final Species<Double> SPECIES_PREFERRED = (Species<Double>) preferredSpecies();
+    public static final VectorSpecies<Double> SPECIES_PREFERRED = (VectorSpecies<Double>) preferredSpecies();
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float128Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Float128Vector extends FloatVector {
-    private static final Species<Float> SPECIES = FloatVector.SPECIES_128;
+    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_128;
 
     static final Float128Vector ZERO = new Float128Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final float[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Float128Vector uOp(Mask<Float> o, FUnOp f) {
+    Float128Vector uOp(VectorMask<Float> o, FUnOp f) {
         float[] vec = getElements();
         float[] res = new float[length()];
         boolean[] mbits = ((Float128Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Float128Vector bOp(Vector<Float> o1, Mask<Float> o2, FBinOp f) {
+    Float128Vector bOp(Vector<Float> o1, VectorMask<Float> o2, FBinOp f) {
         float[] res = new float[length()];
         float[] vec1 = this.getElements();
         float[] vec2 = ((Float128Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Float128Vector tOp(Vector<Float> o1, Vector<Float> o2, Mask<Float> o3, FTriOp f) {
+    Float128Vector tOp(Vector<Float> o1, Vector<Float> o2, VectorMask<Float> o3, FTriOp f) {
         float[] res = new float[length()];
         float[] vec1 = getElements();
         float[] vec2 = ((Float128Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(float.class)) {
-            return (Vector<F>) reshape((Species<Float>)s);
+            return (Vector<F>) reshape((VectorSpecies<Float>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public FloatVector reshape(Species<Float> s) {
+    public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public FloatVector add(float o, Mask<Float> m) {
+    public FloatVector add(float o, VectorMask<Float> m) {
         return add((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public FloatVector sub(float o, Mask<Float> m) {
+    public FloatVector sub(float o, VectorMask<Float> m) {
         return sub((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public FloatVector mul(float o, Mask<Float> m) {
+    public FloatVector mul(float o, VectorMask<Float> m) {
         return mul((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Float> equal(float o) {
+    public VectorMask<Float> equal(float o) {
         return equal((Float128Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> notEqual(float o) {
+    public VectorMask<Float> notEqual(float o) {
         return notEqual((Float128Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThan(float o) {
+    public VectorMask<Float> lessThan(float o) {
         return lessThan((Float128Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThanEq(float o) {
+    public VectorMask<Float> lessThanEq(float o) {
         return lessThanEq((Float128Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThan(float o) {
+    public VectorMask<Float> greaterThan(float o) {
         return greaterThan((Float128Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThanEq(float o) {
+    public VectorMask<Float> greaterThanEq(float o) {
         return greaterThanEq((Float128Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public FloatVector blend(float o, Mask<Float> m) {
+    public FloatVector blend(float o, VectorMask<Float> m) {
         return blend((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public FloatVector div(float o, Mask<Float> m) {
+    public FloatVector div(float o, VectorMask<Float> m) {
         return div((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Float128Vector div(Vector<Float> v, Mask<Float> m) {
+    public Float128Vector div(Vector<Float> v, VectorMask<Float> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public FloatVector atan2(float o, Mask<Float> m) {
+    public FloatVector atan2(float o, VectorMask<Float> m) {
         return atan2((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public FloatVector pow(float o, Mask<Float> m) {
+    public FloatVector pow(float o, VectorMask<Float> m) {
         return pow((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public FloatVector fma(float o1, float o2, Mask<Float> m) {
+    public FloatVector fma(float o1, float o2, VectorMask<Float> m) {
         return fma((Float128Vector)FloatVector.broadcast(SPECIES, o1), (Float128Vector)FloatVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public FloatVector hypot(float o, Mask<Float> m) {
+    public FloatVector hypot(float o, VectorMask<Float> m) {
         return hypot((Float128Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public Float128Vector neg(Mask<Float> m) {
+    public Float128Vector neg(VectorMask<Float> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public Float128Vector abs(Mask<Float> m) {
+    public Float128Vector abs(VectorMask<Float> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public Float128Vector add(Vector<Float> v, Mask<Float> m) {
+    public Float128Vector add(Vector<Float> v, VectorMask<Float> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public Float128Vector sub(Vector<Float> v, Mask<Float> m) {
+    public Float128Vector sub(Vector<Float> v, VectorMask<Float> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public Float128Vector mul(Vector<Float> v, Mask<Float> m) {
+    public Float128Vector mul(Vector<Float> v, VectorMask<Float> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public Float128Vector min(Vector<Float> v, Mask<Float> m) {
+    public Float128Vector min(Vector<Float> v, VectorMask<Float> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public Float128Vector max(Vector<Float> v, Mask<Float> m) {
+    public Float128Vector max(Vector<Float> v, VectorMask<Float> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public float addAll(Mask<Float> m) {
+    public float addAll(VectorMask<Float> m) {
         return blend((Float128Vector)FloatVector.broadcast(SPECIES, (float) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(Mask<Float> m) {
+    public float mulAll(VectorMask<Float> m) {
         return blend((Float128Vector)FloatVector.broadcast(SPECIES, (float) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public float minAll(Mask<Float> m) {
+    public float minAll(VectorMask<Float> m) {
         return blend((Float128Vector)FloatVector.broadcast(SPECIES, Float.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public float maxAll(Mask<Float> m) {
+    public float maxAll(VectorMask<Float> m) {
         return blend((Float128Vector)FloatVector.broadcast(SPECIES, Float.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Float> toShuffle() {
+    public VectorShuffle<Float> toShuffle() {
         float[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return FloatVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(float[] a, int ax, Mask<Float> m) {
+    public final void intoArray(float[] a, int ax, VectorMask<Float> m) {
         FloatVector oldVal = FloatVector.fromArray(SPECIES, a, ax);
         FloatVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(float[] a, int ax, Mask<Float> m, int[] b, int iy) {
+     public final void intoArray(float[] a, int ax, VectorMask<Float> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          FloatVector oldVal = FloatVector.fromArray(SPECIES, a, ax, b, iy);
          FloatVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Float> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Float> m) {
         Float128Vector oldVal = (Float128Vector) FloatVector.fromByteArray(SPECIES, a, ix);
         Float128Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Float> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Float> m) {
         Float128Vector oldVal = (Float128Vector) FloatVector.fromByteBuffer(SPECIES, bb, ix);
         Float128Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Float> o, FUnCon f) {
+    void forEach(VectorMask<Float> o, FUnCon f) {
         boolean[] mbits = ((Float128Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public Float128Vector rearrange(Vector<Float> v,
-                                  Shuffle<Float> s, Mask<Float> m) {
+                                  VectorShuffle<Float> s, VectorMask<Float> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Float128Vector rearrange(Shuffle<Float> o1) {
+    public Float128Vector rearrange(VectorShuffle<Float> o1) {
         Objects.requireNonNull(o1);
         Float128Shuffle s =  (Float128Shuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public Float128Vector blend(Vector<Float> o1, Mask<Float> o2) {
+    public Float128Vector blend(Vector<Float> o1, VectorMask<Float> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Float128Vector v = (Float128Vector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        Float128Mask bOp(Mask<Float> o, MBinOp f) {
+        Float128Mask bOp(VectorMask<Float> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Float128Mask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Float> species() {
+        public VectorSpecies<Float> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte128Vector.Byte128Mask(maskArray);
+                return (VectorMask <E>) new Byte128Vector.Byte128Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short128Vector.Short128Mask(maskArray);
+                return (VectorMask <E>) new Short128Vector.Short128Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int128Vector.Int128Mask(maskArray);
+                return (VectorMask <E>) new Int128Vector.Int128Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long128Vector.Long128Mask(maskArray);
+                return (VectorMask <E>) new Long128Vector.Long128Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float128Vector.Float128Mask(maskArray);
+                return (VectorMask <E>) new Float128Vector.Float128Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double128Vector.Double128Mask(maskArray);
+                return (VectorMask <E>) new Double128Vector.Double128Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public Float128Mask and(Mask<Float> o) {
+        public Float128Mask and(VectorMask<Float> o) {
             Objects.requireNonNull(o);
             Float128Mask m = (Float128Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Float128Mask.class, int.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public Float128Mask or(Mask<Float> o) {
+        public Float128Mask or(VectorMask<Float> o) {
             Objects.requireNonNull(o);
             Float128Mask m = (Float128Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Float128Mask.class, int.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Float128Mask.class, int.class, LENGTH,
-                                         this, FloatVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Float128Mask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Float> species() {
+        public VectorSpecies<Float> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Float128Shuffle rearrange(Vector.Shuffle<Float> o) {
+        public Float128Shuffle rearrange(VectorShuffle<Float> o) {
             Float128Shuffle s = (Float128Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Float> species() {
+    public VectorSpecies<Float> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float256Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Float256Vector extends FloatVector {
-    private static final Species<Float> SPECIES = FloatVector.SPECIES_256;
+    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_256;
 
     static final Float256Vector ZERO = new Float256Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final float[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Float256Vector uOp(Mask<Float> o, FUnOp f) {
+    Float256Vector uOp(VectorMask<Float> o, FUnOp f) {
         float[] vec = getElements();
         float[] res = new float[length()];
         boolean[] mbits = ((Float256Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Float256Vector bOp(Vector<Float> o1, Mask<Float> o2, FBinOp f) {
+    Float256Vector bOp(Vector<Float> o1, VectorMask<Float> o2, FBinOp f) {
         float[] res = new float[length()];
         float[] vec1 = this.getElements();
         float[] vec2 = ((Float256Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Float256Vector tOp(Vector<Float> o1, Vector<Float> o2, Mask<Float> o3, FTriOp f) {
+    Float256Vector tOp(Vector<Float> o1, Vector<Float> o2, VectorMask<Float> o3, FTriOp f) {
         float[] res = new float[length()];
         float[] vec1 = getElements();
         float[] vec2 = ((Float256Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(float.class)) {
-            return (Vector<F>) reshape((Species<Float>)s);
+            return (Vector<F>) reshape((VectorSpecies<Float>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public FloatVector reshape(Species<Float> s) {
+    public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public FloatVector add(float o, Mask<Float> m) {
+    public FloatVector add(float o, VectorMask<Float> m) {
         return add((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public FloatVector sub(float o, Mask<Float> m) {
+    public FloatVector sub(float o, VectorMask<Float> m) {
         return sub((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public FloatVector mul(float o, Mask<Float> m) {
+    public FloatVector mul(float o, VectorMask<Float> m) {
         return mul((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Float> equal(float o) {
+    public VectorMask<Float> equal(float o) {
         return equal((Float256Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> notEqual(float o) {
+    public VectorMask<Float> notEqual(float o) {
         return notEqual((Float256Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThan(float o) {
+    public VectorMask<Float> lessThan(float o) {
         return lessThan((Float256Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThanEq(float o) {
+    public VectorMask<Float> lessThanEq(float o) {
         return lessThanEq((Float256Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThan(float o) {
+    public VectorMask<Float> greaterThan(float o) {
         return greaterThan((Float256Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThanEq(float o) {
+    public VectorMask<Float> greaterThanEq(float o) {
         return greaterThanEq((Float256Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public FloatVector blend(float o, Mask<Float> m) {
+    public FloatVector blend(float o, VectorMask<Float> m) {
         return blend((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public FloatVector div(float o, Mask<Float> m) {
+    public FloatVector div(float o, VectorMask<Float> m) {
         return div((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Float256Vector div(Vector<Float> v, Mask<Float> m) {
+    public Float256Vector div(Vector<Float> v, VectorMask<Float> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public FloatVector atan2(float o, Mask<Float> m) {
+    public FloatVector atan2(float o, VectorMask<Float> m) {
         return atan2((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public FloatVector pow(float o, Mask<Float> m) {
+    public FloatVector pow(float o, VectorMask<Float> m) {
         return pow((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public FloatVector fma(float o1, float o2, Mask<Float> m) {
+    public FloatVector fma(float o1, float o2, VectorMask<Float> m) {
         return fma((Float256Vector)FloatVector.broadcast(SPECIES, o1), (Float256Vector)FloatVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public FloatVector hypot(float o, Mask<Float> m) {
+    public FloatVector hypot(float o, VectorMask<Float> m) {
         return hypot((Float256Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public Float256Vector neg(Mask<Float> m) {
+    public Float256Vector neg(VectorMask<Float> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public Float256Vector abs(Mask<Float> m) {
+    public Float256Vector abs(VectorMask<Float> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public Float256Vector add(Vector<Float> v, Mask<Float> m) {
+    public Float256Vector add(Vector<Float> v, VectorMask<Float> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public Float256Vector sub(Vector<Float> v, Mask<Float> m) {
+    public Float256Vector sub(Vector<Float> v, VectorMask<Float> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public Float256Vector mul(Vector<Float> v, Mask<Float> m) {
+    public Float256Vector mul(Vector<Float> v, VectorMask<Float> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public Float256Vector min(Vector<Float> v, Mask<Float> m) {
+    public Float256Vector min(Vector<Float> v, VectorMask<Float> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public Float256Vector max(Vector<Float> v, Mask<Float> m) {
+    public Float256Vector max(Vector<Float> v, VectorMask<Float> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public float addAll(Mask<Float> m) {
+    public float addAll(VectorMask<Float> m) {
         return blend((Float256Vector)FloatVector.broadcast(SPECIES, (float) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(Mask<Float> m) {
+    public float mulAll(VectorMask<Float> m) {
         return blend((Float256Vector)FloatVector.broadcast(SPECIES, (float) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public float minAll(Mask<Float> m) {
+    public float minAll(VectorMask<Float> m) {
         return blend((Float256Vector)FloatVector.broadcast(SPECIES, Float.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public float maxAll(Mask<Float> m) {
+    public float maxAll(VectorMask<Float> m) {
         return blend((Float256Vector)FloatVector.broadcast(SPECIES, Float.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Float> toShuffle() {
+    public VectorShuffle<Float> toShuffle() {
         float[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return FloatVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(float[] a, int ax, Mask<Float> m) {
+    public final void intoArray(float[] a, int ax, VectorMask<Float> m) {
         FloatVector oldVal = FloatVector.fromArray(SPECIES, a, ax);
         FloatVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(float[] a, int ax, Mask<Float> m, int[] b, int iy) {
+     public final void intoArray(float[] a, int ax, VectorMask<Float> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          FloatVector oldVal = FloatVector.fromArray(SPECIES, a, ax, b, iy);
          FloatVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Float> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Float> m) {
         Float256Vector oldVal = (Float256Vector) FloatVector.fromByteArray(SPECIES, a, ix);
         Float256Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Float> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Float> m) {
         Float256Vector oldVal = (Float256Vector) FloatVector.fromByteBuffer(SPECIES, bb, ix);
         Float256Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Float> o, FUnCon f) {
+    void forEach(VectorMask<Float> o, FUnCon f) {
         boolean[] mbits = ((Float256Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public Float256Vector rearrange(Vector<Float> v,
-                                  Shuffle<Float> s, Mask<Float> m) {
+                                  VectorShuffle<Float> s, VectorMask<Float> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Float256Vector rearrange(Shuffle<Float> o1) {
+    public Float256Vector rearrange(VectorShuffle<Float> o1) {
         Objects.requireNonNull(o1);
         Float256Shuffle s =  (Float256Shuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public Float256Vector blend(Vector<Float> o1, Mask<Float> o2) {
+    public Float256Vector blend(Vector<Float> o1, VectorMask<Float> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Float256Vector v = (Float256Vector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        Float256Mask bOp(Mask<Float> o, MBinOp f) {
+        Float256Mask bOp(VectorMask<Float> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Float256Mask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Float> species() {
+        public VectorSpecies<Float> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte256Vector.Byte256Mask(maskArray);
+                return (VectorMask <E>) new Byte256Vector.Byte256Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short256Vector.Short256Mask(maskArray);
+                return (VectorMask <E>) new Short256Vector.Short256Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int256Vector.Int256Mask(maskArray);
+                return (VectorMask <E>) new Int256Vector.Int256Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long256Vector.Long256Mask(maskArray);
+                return (VectorMask <E>) new Long256Vector.Long256Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float256Vector.Float256Mask(maskArray);
+                return (VectorMask <E>) new Float256Vector.Float256Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double256Vector.Double256Mask(maskArray);
+                return (VectorMask <E>) new Double256Vector.Double256Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public Float256Mask and(Mask<Float> o) {
+        public Float256Mask and(VectorMask<Float> o) {
             Objects.requireNonNull(o);
             Float256Mask m = (Float256Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Float256Mask.class, int.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public Float256Mask or(Mask<Float> o) {
+        public Float256Mask or(VectorMask<Float> o) {
             Objects.requireNonNull(o);
             Float256Mask m = (Float256Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Float256Mask.class, int.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Float256Mask.class, int.class, LENGTH,
-                                         this, FloatVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Float256Mask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Float> species() {
+        public VectorSpecies<Float> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Float256Shuffle rearrange(Vector.Shuffle<Float> o) {
+        public Float256Shuffle rearrange(VectorShuffle<Float> o) {
             Float256Shuffle s = (Float256Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Float> species() {
+    public VectorSpecies<Float> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float512Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Float512Vector extends FloatVector {
-    private static final Species<Float> SPECIES = FloatVector.SPECIES_512;
+    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_512;
 
     static final Float512Vector ZERO = new Float512Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final float[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Float512Vector uOp(Mask<Float> o, FUnOp f) {
+    Float512Vector uOp(VectorMask<Float> o, FUnOp f) {
         float[] vec = getElements();
         float[] res = new float[length()];
         boolean[] mbits = ((Float512Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Float512Vector bOp(Vector<Float> o1, Mask<Float> o2, FBinOp f) {
+    Float512Vector bOp(Vector<Float> o1, VectorMask<Float> o2, FBinOp f) {
         float[] res = new float[length()];
         float[] vec1 = this.getElements();
         float[] vec2 = ((Float512Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Float512Vector tOp(Vector<Float> o1, Vector<Float> o2, Mask<Float> o3, FTriOp f) {
+    Float512Vector tOp(Vector<Float> o1, Vector<Float> o2, VectorMask<Float> o3, FTriOp f) {
         float[] res = new float[length()];
         float[] vec1 = getElements();
         float[] vec2 = ((Float512Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(float.class)) {
-            return (Vector<F>) reshape((Species<Float>)s);
+            return (Vector<F>) reshape((VectorSpecies<Float>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public FloatVector reshape(Species<Float> s) {
+    public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public FloatVector add(float o, Mask<Float> m) {
+    public FloatVector add(float o, VectorMask<Float> m) {
         return add((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public FloatVector sub(float o, Mask<Float> m) {
+    public FloatVector sub(float o, VectorMask<Float> m) {
         return sub((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public FloatVector mul(float o, Mask<Float> m) {
+    public FloatVector mul(float o, VectorMask<Float> m) {
         return mul((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Float> equal(float o) {
+    public VectorMask<Float> equal(float o) {
         return equal((Float512Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> notEqual(float o) {
+    public VectorMask<Float> notEqual(float o) {
         return notEqual((Float512Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThan(float o) {
+    public VectorMask<Float> lessThan(float o) {
         return lessThan((Float512Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThanEq(float o) {
+    public VectorMask<Float> lessThanEq(float o) {
         return lessThanEq((Float512Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThan(float o) {
+    public VectorMask<Float> greaterThan(float o) {
         return greaterThan((Float512Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThanEq(float o) {
+    public VectorMask<Float> greaterThanEq(float o) {
         return greaterThanEq((Float512Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public FloatVector blend(float o, Mask<Float> m) {
+    public FloatVector blend(float o, VectorMask<Float> m) {
         return blend((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline
-    public FloatVector div(float o, Mask<Float> m) {
+    public FloatVector div(float o, VectorMask<Float> m) {
         return div((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
     @Override
     @ForceInline
-    public Float512Vector div(Vector<Float> v, Mask<Float> m) {
+    public Float512Vector div(Vector<Float> v, VectorMask<Float> m) {
         return blend(div(v), m);
     }
 
@@ -470,7 +470,7 @@
 
     @Override
     @ForceInline
-    public FloatVector atan2(float o, Mask<Float> m) {
+    public FloatVector atan2(float o, VectorMask<Float> m) {
         return atan2((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -482,7 +482,7 @@
 
     @Override
     @ForceInline
-    public FloatVector pow(float o, Mask<Float> m) {
+    public FloatVector pow(float o, VectorMask<Float> m) {
         return pow((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -494,7 +494,7 @@
 
     @Override
     @ForceInline
-    public FloatVector fma(float o1, float o2, Mask<Float> m) {
+    public FloatVector fma(float o1, float o2, VectorMask<Float> m) {
         return fma((Float512Vector)FloatVector.broadcast(SPECIES, o1), (Float512Vector)FloatVector.broadcast(SPECIES, o2), m);
     }
 
@@ -506,7 +506,7 @@
 
     @Override
     @ForceInline
-    public FloatVector hypot(float o, Mask<Float> m) {
+    public FloatVector hypot(float o, VectorMask<Float> m) {
         return hypot((Float512Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -515,7 +515,7 @@
 
     @ForceInline
     @Override
-    public Float512Vector neg(Mask<Float> m) {
+    public Float512Vector neg(VectorMask<Float> m) {
         return blend(neg(), m);
     }
 
@@ -530,7 +530,7 @@
 
     @ForceInline
     @Override
-    public Float512Vector abs(Mask<Float> m) {
+    public Float512Vector abs(VectorMask<Float> m) {
         return blend(abs(), m);
     }
 
@@ -747,7 +747,7 @@
 
     @Override
     @ForceInline
-    public Float512Vector add(Vector<Float> v, Mask<Float> m) {
+    public Float512Vector add(Vector<Float> v, VectorMask<Float> m) {
         return blend(add(v), m);
     }
 
@@ -764,7 +764,7 @@
 
     @Override
     @ForceInline
-    public Float512Vector sub(Vector<Float> v, Mask<Float> m) {
+    public Float512Vector sub(Vector<Float> v, VectorMask<Float> m) {
         return blend(sub(v), m);
     }
 
@@ -781,7 +781,7 @@
 
     @Override
     @ForceInline
-    public Float512Vector mul(Vector<Float> v, Mask<Float> m) {
+    public Float512Vector mul(Vector<Float> v, VectorMask<Float> m) {
         return blend(mul(v), m);
     }
 
@@ -798,7 +798,7 @@
 
     @Override
     @ForceInline
-    public Float512Vector min(Vector<Float> v, Mask<Float> m) {
+    public Float512Vector min(Vector<Float> v, VectorMask<Float> m) {
         return blend(min(v), m);
     }
 
@@ -815,7 +815,7 @@
 
     @Override
     @ForceInline
-    public Float512Vector max(Vector<Float> v, Mask<Float> m) {
+    public Float512Vector max(Vector<Float> v, VectorMask<Float> m) {
         return blend(max(v), m);
     }
 
@@ -892,38 +892,38 @@
 
     @Override
     @ForceInline
-    public float addAll(Mask<Float> m) {
+    public float addAll(VectorMask<Float> m) {
         return blend((Float512Vector)FloatVector.broadcast(SPECIES, (float) 0), m).addAll();
     }
 
 
     @Override
     @ForceInline
-    public float mulAll(Mask<Float> m) {
+    public float mulAll(VectorMask<Float> m) {
         return blend((Float512Vector)FloatVector.broadcast(SPECIES, (float) 1), m).mulAll();
     }
 
     @Override
     @ForceInline
-    public float minAll(Mask<Float> m) {
+    public float minAll(VectorMask<Float> m) {
         return blend((Float512Vector)FloatVector.broadcast(SPECIES, Float.MAX_VALUE), m).minAll();
     }
 
     @Override
     @ForceInline
-    public float maxAll(Mask<Float> m) {
+    public float maxAll(VectorMask<Float> m) {
         return blend((Float512Vector)FloatVector.broadcast(SPECIES, Float.MIN_VALUE), m).maxAll();
     }
 
     @Override
     @ForceInline
-    public Shuffle<Float> toShuffle() {
+    public VectorShuffle<Float> toShuffle() {
         float[] a = toArray();
         int[] sa = new int[a.length];
         for (int i = 0; i < a.length; i++) {
             sa[i] = (int) a[i];
         }
-        return FloatVector.shuffleFromArray(SPECIES, sa, 0);
+        return VectorShuffle.fromArray(SPECIES, sa, 0);
     }
 
     // Memory operations
@@ -945,7 +945,7 @@
 
     @Override
     @ForceInline
-    public final void intoArray(float[] a, int ax, Mask<Float> m) {
+    public final void intoArray(float[] a, int ax, VectorMask<Float> m) {
         FloatVector oldVal = FloatVector.fromArray(SPECIES, a, ax);
         FloatVector newVal = oldVal.blend(this, m);
         newVal.intoArray(a, ax);
@@ -970,7 +970,7 @@
 
      @Override
      @ForceInline
-     public final void intoArray(float[] a, int ax, Mask<Float> m, int[] b, int iy) {
+     public final void intoArray(float[] a, int ax, VectorMask<Float> m, int[] b, int iy) {
          // @@@ This can result in out of bounds errors for unset mask lanes
          FloatVector oldVal = FloatVector.fromArray(SPECIES, a, ax, b, iy);
          FloatVector newVal = oldVal.blend(this, m);
@@ -995,7 +995,7 @@
 
     @Override
     @ForceInline
-    public final void intoByteArray(byte[] a, int ix, Mask<Float> m) {
+    public final void intoByteArray(byte[] a, int ix, VectorMask<Float> m) {
         Float512Vector oldVal = (Float512Vector) FloatVector.fromByteArray(SPECIES, a, ix);
         Float512Vector newVal = oldVal.blend(this, m);
         newVal.intoByteArray(a, ix);
@@ -1024,7 +1024,7 @@
 
     @Override
     @ForceInline
-    public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Float> m) {
+    public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Float> m) {
         Float512Vector oldVal = (Float512Vector) FloatVector.fromByteBuffer(SPECIES, bb, ix);
         Float512Vector newVal = oldVal.blend(this, m);
         newVal.intoByteBuffer(bb, ix);
@@ -1149,7 +1149,7 @@
     }
 
     @Override
-    void forEach(Mask<Float> o, FUnCon f) {
+    void forEach(VectorMask<Float> o, FUnCon f) {
         boolean[] mbits = ((Float512Mask)o).getBits();
         forEach((i, a) -> {
             if (mbits[i]) { f.apply(i, a); }
@@ -1214,13 +1214,13 @@
     @Override
     @ForceInline
     public Float512Vector rearrange(Vector<Float> v,
-                                  Shuffle<Float> s, Mask<Float> m) {
+                                  VectorShuffle<Float> s, VectorMask<Float> m) {
         return this.rearrange(s).blend(v.rearrange(s), m);
     }
 
     @Override
     @ForceInline
-    public Float512Vector rearrange(Shuffle<Float> o1) {
+    public Float512Vector rearrange(VectorShuffle<Float> o1) {
         Objects.requireNonNull(o1);
         Float512Shuffle s =  (Float512Shuffle)o1;
 
@@ -1235,7 +1235,7 @@
 
     @Override
     @ForceInline
-    public Float512Vector blend(Vector<Float> o1, Mask<Float> o2) {
+    public Float512Vector blend(Vector<Float> o1, VectorMask<Float> o2) {
         Objects.requireNonNull(o1);
         Objects.requireNonNull(o2);
         Float512Vector v = (Float512Vector)o1;
@@ -1320,7 +1320,7 @@
         }
 
         @Override
-        Float512Mask bOp(Mask<Float> o, MBinOp f) {
+        Float512Mask bOp(VectorMask<Float> o, MBinOp f) {
             boolean[] res = new boolean[species().length()];
             boolean[] bits = getBits();
             boolean[] mbits = ((Float512Mask)o).getBits();
@@ -1331,7 +1331,7 @@
         }
 
         @Override
-        public Species<Float> species() {
+        public VectorSpecies<Float> species() {
             return SPECIES;
         }
 
@@ -1350,23 +1350,23 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <E> Mask<E> cast(Species<E> species) {
+        public <E> VectorMask<E> cast(VectorSpecies<E> species) {
             if (length() != species.length())
-                throw new IllegalArgumentException("Mask length and species length differ");
+                throw new IllegalArgumentException("VectorMask length and species length differ");
             Class<?> stype = species.elementType();
             boolean [] maskArray = toArray();
             if (stype == byte.class) {
-                return (Mask <E>) new Byte512Vector.Byte512Mask(maskArray);
+                return (VectorMask <E>) new Byte512Vector.Byte512Mask(maskArray);
             } else if (stype == short.class) {
-                return (Mask <E>) new Short512Vector.Short512Mask(maskArray);
+                return (VectorMask <E>) new Short512Vector.Short512Mask(maskArray);
             } else if (stype == int.class) {
-                return (Mask <E>) new Int512Vector.Int512Mask(maskArray);
+                return (VectorMask <E>) new Int512Vector.Int512Mask(maskArray);
             } else if (stype == long.class) {
-                return (Mask <E>) new Long512Vector.Long512Mask(maskArray);
+                return (VectorMask <E>) new Long512Vector.Long512Mask(maskArray);
             } else if (stype == float.class) {
-                return (Mask <E>) new Float512Vector.Float512Mask(maskArray);
+                return (VectorMask <E>) new Float512Vector.Float512Mask(maskArray);
             } else if (stype == double.class) {
-                return (Mask <E>) new Double512Vector.Double512Mask(maskArray);
+                return (VectorMask <E>) new Double512Vector.Double512Mask(maskArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
@@ -1387,7 +1387,7 @@
 
         @Override
         @ForceInline
-        public Float512Mask and(Mask<Float> o) {
+        public Float512Mask and(VectorMask<Float> o) {
             Objects.requireNonNull(o);
             Float512Mask m = (Float512Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Float512Mask.class, int.class, LENGTH,
@@ -1397,7 +1397,7 @@
 
         @Override
         @ForceInline
-        public Float512Mask or(Mask<Float> o) {
+        public Float512Mask or(VectorMask<Float> o) {
             Objects.requireNonNull(o);
             Float512Mask m = (Float512Mask)o;
             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Float512Mask.class, int.class, LENGTH,
@@ -1419,7 +1419,7 @@
         @ForceInline
         public boolean allTrue() {
             return VectorIntrinsics.test(BT_overflow, Float512Mask.class, int.class, LENGTH,
-                                         this, FloatVector.maskAllTrue(species()),
+                                         this, VectorMask.maskAllTrue(species()),
                                          (m, __) -> allTrueHelper(((Float512Mask)m).getBits()));
         }
     }
@@ -1444,7 +1444,7 @@
         }
 
         @Override
-        public Species<Float> species() {
+        public VectorSpecies<Float> species() {
             return SPECIES;
         }
 
@@ -1460,30 +1460,30 @@
         @Override
         @ForceInline
         @SuppressWarnings("unchecked")
-        public <F> Shuffle<F> cast(Species<F> species) {
+        public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
             if (length() != species.length())
                 throw new IllegalArgumentException("Shuffle length and species length differ");
             Class<?> stype = species.elementType();
             int [] shuffleArray = toArray();
             if (stype == byte.class) {
-                return (Shuffle<F>) new Byte512Vector.Byte512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Byte512Vector.Byte512Shuffle(shuffleArray);
             } else if (stype == short.class) {
-                return (Shuffle<F>) new Short512Vector.Short512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Short512Vector.Short512Shuffle(shuffleArray);
             } else if (stype == int.class) {
-                return (Shuffle<F>) new Int512Vector.Int512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Int512Vector.Int512Shuffle(shuffleArray);
             } else if (stype == long.class) {
-                return (Shuffle<F>) new Long512Vector.Long512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Long512Vector.Long512Shuffle(shuffleArray);
             } else if (stype == float.class) {
-                return (Shuffle<F>) new Float512Vector.Float512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Float512Vector.Float512Shuffle(shuffleArray);
             } else if (stype == double.class) {
-                return (Shuffle<F>) new Double512Vector.Double512Shuffle(shuffleArray);
+                return (VectorShuffle<F>) new Double512Vector.Double512Shuffle(shuffleArray);
             } else {
                 throw new UnsupportedOperationException("Bad lane type for casting.");
             }
         }
 
         @Override
-        public Float512Shuffle rearrange(Vector.Shuffle<Float> o) {
+        public Float512Shuffle rearrange(VectorShuffle<Float> o) {
             Float512Shuffle s = (Float512Shuffle) o;
             byte[] r = new byte[reorder.length];
             for (int i = 0; i < reorder.length; i++) {
@@ -1493,10 +1493,10 @@
         }
     }
 
-    // Species
+    // VectorSpecies
 
     @Override
-    public Species<Float> species() {
+    public VectorSpecies<Float> species() {
         return SPECIES;
     }
 }
--- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java	Mon Apr 15 03:54:26 2019 +0200
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Float64Vector.java	Fri Apr 19 04:44:47 2019 +0200
@@ -38,7 +38,7 @@
 
 @SuppressWarnings("cast")
 final class Float64Vector extends FloatVector {
-    private static final Species<Float> SPECIES = FloatVector.SPECIES_64;
+    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_64;
 
     static final Float64Vector ZERO = new Float64Vector();
 
@@ -49,7 +49,7 @@
 
     static {
         int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
-        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(Shape.forBitSize(bitSize));
+        INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize));
     }
 
     private final float[] vec; // Don't access directly, use getElements() instead.
@@ -82,7 +82,7 @@
     }
 
     @Override
-    Float64Vector uOp(Mask<Float> o, FUnOp f) {
+    Float64Vector uOp(VectorMask<Float> o, FUnOp f) {
         float[] vec = getElements();
         float[] res = new float[length()];
         boolean[] mbits = ((Float64Mask)o).getBits();
@@ -106,7 +106,7 @@
     }
 
     @Override
-    Float64Vector bOp(Vector<Float> o1, Mask<Float> o2, FBinOp f) {
+    Float64Vector bOp(Vector<Float> o1, VectorMask<Float> o2, FBinOp f) {
         float[] res = new float[length()];
         float[] vec1 = this.getElements();
         float[] vec2 = ((Float64Vector)o1).getElements();
@@ -132,7 +132,7 @@
     }
 
     @Override
-    Float64Vector tOp(Vector<Float> o1, Vector<Float> o2, Mask<Float> o3, FTriOp f) {
+    Float64Vector tOp(Vector<Float> o1, Vector<Float> o2, VectorMask<Float> o3, FTriOp f) {
         float[] res = new float[length()];
         float[] vec1 = getElements();
         float[] vec2 = ((Float64Vector)o1).getElements();
@@ -155,7 +155,7 @@
 
     @Override
     @ForceInline
-    public <F> Vector<F> cast(Species<F> s) {
+    public <F> Vector<F> cast(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
         if (s.length() != LENGTH)
             throw new IllegalArgumentException("Vector length this species length differ");
@@ -172,7 +172,7 @@
 
     @SuppressWarnings("unchecked")
     @ForceInline
-    private <F> Vector<F> castDefault(Species<F> s) {
+    private <F> Vector<F> castDefault(VectorSpecies<F> s) {
         int limit = s.length();
 
         Class<?> stype = s.elementType();
@@ -181,37 +181,37 @@
             for (int i = 0; i < limit; i++) {
                 a[i] = (byte) this.get(i);
             }
-            return (Vector) ByteVector.fromArray((Species<Byte>) s, a, 0);
+            return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
         } else if (stype == short.class) {
             short[] a = new short[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (short) this.get(i);
             }
-            return (Vector) ShortVector.fromArray((Species<Short>) s, a, 0);
+            return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
         } else if (stype == int.class) {
             int[] a = new int[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (int) this.get(i);
             }
-            return (Vector) IntVector.fromArray((Species<Integer>) s, a, 0);
+            return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
         } else if (stype == long.class) {
             long[] a = new long[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (long) this.get(i);
             }
-            return (Vector) LongVector.fromArray((Species<Long>) s, a, 0);
+            return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
         } else if (stype == float.class) {
             float[] a = new float[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (float) this.get(i);
             }
-            return (Vector) FloatVector.fromArray((Species<Float>) s, a, 0);
+            return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
         } else if (stype == double.class) {
             double[] a = new double[limit];
             for (int i = 0; i < limit; i++) {
                 a[i] = (double) this.get(i);
             }
-            return (Vector) DoubleVector.fromArray((Species<Double>) s, a, 0);
+            return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
         } else {
             throw new UnsupportedOperationException("Bad lane type for casting.");
         }
@@ -220,11 +220,11 @@
     @Override
     @ForceInline
     @SuppressWarnings("unchecked")
-    public <F> Vector<F> reinterpret(Species<F> s) {
+    public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         if(s.elementType().equals(float.class)) {
-            return (Vector<F>) reshape((Species<Float>)s);
+            return (Vector<F>) reshape((VectorSpecies<Float>)s);
         }
         if(s.bitSize() == bitSize()) {
             return reinterpretType(s);
@@ -234,7 +234,7 @@
     }
 
     @ForceInline
-    private <F> Vector<F> reinterpretType(Species<F> s) {
+    private <F> Vector<F> reinterpretType(VectorSpecies<F> s) {
         Objects.requireNonNull(s);
 
         Class<?> stype = s.elementType();
@@ -299,7 +299,7 @@
 
     @Override
     @ForceInline
-    public FloatVector reshape(Species<Float> s) {
+    public FloatVector reshape(VectorSpecies<Float> s) {
         Objects.requireNonNull(s);
         if (s.bitSize() == 64 && (s.boxType() == Float64Vector.class)) {
             return VectorIntrinsics.reinterpret(
@@ -362,7 +362,7 @@
 
     @Override
     @ForceInline
-    public FloatVector add(float o, Mask<Float> m) {
+    public FloatVector add(float o, VectorMask<Float> m) {
         return add((Float64Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -374,7 +374,7 @@
 
     @Override
     @ForceInline
-    public FloatVector sub(float o, Mask<Float> m) {
+    public FloatVector sub(float o, VectorMask<Float> m) {
         return sub((Float64Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -386,7 +386,7 @@
 
     @Override
     @ForceInline
-    public FloatVector mul(float o, Mask<Float> m) {
+    public FloatVector mul(float o, VectorMask<Float> m) {
         return mul((Float64Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -404,43 +404,43 @@
 
     @Override
     @ForceInline
-    public Mask<Float> equal(float o) {
+    public VectorMask<Float> equal(float o) {
         return equal((Float64Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> notEqual(float o) {
+    public VectorMask<Float> notEqual(float o) {
         return notEqual((Float64Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThan(float o) {
+    public VectorMask<Float> lessThan(float o) {
         return lessThan((Float64Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> lessThanEq(float o) {
+    public VectorMask<Float> lessThanEq(float o) {
         return lessThanEq((Float64Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThan(float o) {
+    public VectorMask<Float> greaterThan(float o) {
         return greaterThan((Float64Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public Mask<Float> greaterThanEq(float o) {
+    public VectorMask<Float> greaterThanEq(float o) {
         return greaterThanEq((Float64Vector)FloatVector.broadcast(SPECIES, o));
     }
 
     @Override
     @ForceInline
-    public FloatVector blend(float o, Mask<Float> m) {
+    public FloatVector blend(float o, VectorMask<Float> m) {
         return blend((Float64Vector)FloatVector.broadcast(SPECIES, o), m);
     }
 
@@ -452,13 +452,13 @@
 
     @Override
     @ForceInline