ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/python/ndtypes/pyndtypes.h

@@ -51,13 +51,11 @@ extern "C" {
 
 typedef struct {
     PyObject_HEAD
-    PyObject *rbuf; /* resource buffer */
-    ndt_t *ndt;     /* type */
+    Py_hash_t hash;
+    const ndt_t *ndt;
 } NdtObject;
 
 #define NDT(v) (((NdtObject *)v)->ndt)
-#define RBUF(v) (((NdtObject *)v)->rbuf)
-#define RBUF_NDT_META(v) (((ResourceBufferObject *)(((NdtObject *)v)->rbuf))->m)
 
 
 /****************************************************************************/
@@ -72,42 +70,32 @@ typedef struct {
 #define Ndt_Check_RETURN int
 #define Ndt_Check_ARGS (const PyObject *)
 
-#define CONST_NDT_INDEX 2
-#define CONST_NDT_RETURN const ndt_t *
-#define CONST_NDT_ARGS (const PyObject *)
-
-#define Ndt_SetError_INDEX 3
+#define Ndt_SetError_INDEX 2
 #define Ndt_SetError_RETURN PyObject *
 #define Ndt_SetError_ARGS (ndt_context_t *)
 
-#define Ndt_CopySubtree_INDEX 4
-#define Ndt_CopySubtree_RETURN PyObject *
-#define Ndt_CopySubtree_ARGS (const PyObject *, const ndt_t *)
-
-#define Ndt_MoveSubtree_INDEX 5
-#define Ndt_MoveSubtree_RETURN PyObject *
-#define Ndt_MoveSubtree_ARGS (const PyObject *, ndt_t *)
-
-#define Ndt_FromType_INDEX 6
+#define Ndt_FromType_INDEX 3
 #define Ndt_FromType_RETURN PyObject *
-#define Ndt_FromType_ARGS (ndt_t *)
+#define Ndt_FromType_ARGS (const ndt_t *)
 
-#define Ndt_FromObject_INDEX 7
+#define Ndt_FromObject_INDEX 4
 #define Ndt_FromObject_RETURN PyObject *
 #define Ndt_FromObject_ARGS (PyObject *)
 
-#define NDTYPES_MAX_API 8
+#define Ndt_FromOffsetsAndDtype_INDEX 5
+#define Ndt_FromOffsetsAndDtype_RETURN PyObject *
+#define Ndt_FromOffsetsAndDtype_ARGS (PyObject *offsets, bool *opt, const ndt_t *dtype)
+
+#define NDTYPES_MAX_API 6
 
 
 #ifdef NDTYPES_MODULE
 static Ndt_CheckExact_RETURN Ndt_CheckExact Ndt_CheckExact_ARGS;
 static Ndt_Check_RETURN Ndt_Check Ndt_Check_ARGS;
-static CONST_NDT_RETURN CONST_NDT CONST_NDT_ARGS;
 static Ndt_SetError_RETURN Ndt_SetError Ndt_SetError_ARGS;
-static Ndt_CopySubtree_RETURN Ndt_CopySubtree Ndt_CopySubtree_ARGS;
-static Ndt_MoveSubtree_RETURN Ndt_MoveSubtree Ndt_MoveSubtree_ARGS;
 static Ndt_FromType_RETURN Ndt_FromType Ndt_FromType_ARGS;
 static Ndt_FromObject_RETURN Ndt_FromObject Ndt_FromObject_ARGS;
+static Ndt_FromOffsetsAndDtype_RETURN Ndt_FromOffsetsAndDtype Ndt_FromOffsetsAndDtype_ARGS;
 #else
 static void **_ndtypes_api;
 
@@ -117,24 +105,18 @@ static void **_ndtypes_api;
 #define Ndt_Check \
     (*(Ndt_Check_RETURN (*)Ndt_Check_ARGS) _ndtypes_api[Ndt_Check_INDEX])
 
-#define CONST_NDT \
-    (*(CONST_NDT_RETURN (*)CONST_NDT_ARGS) _ndtypes_api[CONST_NDT_INDEX])
-
 #define Ndt_SetError \
     (*(Ndt_SetError_RETURN (*)Ndt_SetError_ARGS) _ndtypes_api[Ndt_SetError_INDEX])
 
-#define Ndt_CopySubtree \
-    (*(Ndt_CopySubtree_RETURN (*)Ndt_CopySubtree_ARGS) _ndtypes_api[Ndt_CopySubtree_INDEX])
-
-#define Ndt_MoveSubtree \
-    (*(Ndt_MoveSubtree_RETURN (*)Ndt_MoveSubtree_ARGS) _ndtypes_api[Ndt_MoveSubtree_INDEX])
-
 #define Ndt_FromType \
     (*(Ndt_FromType_RETURN (*)Ndt_FromType_ARGS) _ndtypes_api[Ndt_FromType_INDEX])
 
 #define Ndt_FromObject \
     (*(Ndt_FromObject_RETURN (*)Ndt_FromObject_ARGS) _ndtypes_api[Ndt_FromObject_INDEX])
 
+#define Ndt_FromOffsetsAndDtype \
+    (*(Ndt_FromOffsetsAndDtype_RETURN (*)Ndt_FromOffsetsAndDtype_ARGS) _ndtypes_api[Ndt_FromOffsetsAndDtype_INDEX])
+
 static int
 import_ndtypes(void)
 {

data/ext/ruby_ndtypes/ndtypes/python/test_ndtypes.py

@@ -81,6 +81,7 @@ class TestModule(unittest.TestCase):
 
         self.assertFalse(t.is_f_contiguous())
         self.assertFalse(t.is_c_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_module_common_fields(self):
         t = ndt("SomeNamespace:: 2 * 3 * float64")
@@ -113,6 +114,7 @@ class TestFunction(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_function_common_fields(self):
         t = ndt("(10 * float64, string) -> float64")
@@ -145,6 +147,7 @@ class TestVoid(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_void_exceptions(self):
         # Void can only be used as a function return type.
@@ -167,6 +170,7 @@ class TestAny(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_any_common_fields(self):
         t = ndt("Any")
@@ -198,14 +202,17 @@ class TestFixedDim(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
         t = ndt("20 * complex128")
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
         t = ndt("1 * 10 * complex128")
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_fixed_dim_common_fields(self):
         dt = "{a: complex64, b: string}"
@@ -291,6 +298,32 @@ class TestFixedDim(unittest.TestCase):
                         self.assertEqual(t.datasize, c_datasize(t))
                         self.assertTrue(verify_datasize(t))
 
+    def test_fixed_dim_at(self):
+
+        for dims in ("2 * 3 * ", "0 * 1 * "):
+            t = ndt(dims + "int8")
+
+            u = t.at(0)
+            self.assertEqual(u, ndt(dims + "int8"))
+
+            u = t.at(1)
+            self.assertEqual(u, ndt(dims[4:] + "int8"))
+
+            u = t.at(2)
+            self.assertEqual(u, ndt("int8"))
+
+            u = t.at(0, dtype="int64")
+            self.assertEqual(u, ndt(dims + "int64"))
+
+            u = t.at(1, dtype="int64")
+            self.assertEqual(u, ndt(dims[4:] + "int64"))
+
+            u = t.at(2, dtype="int64")
+            self.assertEqual(u, ndt("int64"))
+
+            self.assertRaises(ValueError, t.at, -1)
+            self.assertRaises(ValueError, t.at, -3)
+
 
 class TestFortran(unittest.TestCase):
 
@@ -308,14 +341,17 @@ class TestFortran(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
         t = ndt("!20 * complex128")
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
         t = ndt("!1 * 10 * uint8")
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_fortran_common_fields(self):
         dt = "{a: complex64, b: string}"
@@ -398,6 +434,32 @@ class TestFortran(unittest.TestCase):
         s = "!fixed(shape=2, step=-20) * uint8"
         self.assertRaises(TypeError, ndt, s)
 
+    def test_fortran_at(self):
+
+        for dims in ("2 * 3 * ", "0 * 1 * "):
+            t = ndt("!" + dims + "int8")
+
+            u = t.at(0)
+            self.assertEqual(u, ndt(dims + "int8"))
+
+            u = t.at(1)
+            self.assertEqual(u, ndt(dims[4:] + "int8"))
+
+            u = t.at(2)
+            self.assertEqual(u, ndt("int8"))
+
+            u = t.at(0, dtype="int64")
+            self.assertEqual(u, ndt(dims + "int64"))
+
+            u = t.at(1, dtype="int64")
+            self.assertEqual(u, ndt(dims[4:] + "int64"))
+
+            u = t.at(2, dtype="int64")
+            self.assertEqual(u, ndt("int64"))
+
+            self.assertRaises(ValueError, t.at, -1)
+            self.assertRaises(ValueError, t.at, -3)
+
 
 class TestVarDim(unittest.TestCase):
 
@@ -416,6 +478,7 @@ class TestVarDim(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_var_dim_common_fields(self):
         dt = "{a: complex64, b: string}"
@@ -445,12 +508,6 @@ class TestVarDim(unittest.TestCase):
         # Too many dimensions.
         self.assertRaises(TypeError, ndt, "var * " * (MAX_DIM + 1) + "float64")
 
-        # Nested var is disallowed.
-        self.assertRaises(TypeError, ndt, "2 * {a: var * complex128}")
-        self.assertRaises(TypeError, ndt, "var * {a: var * complex128}")
-        self.assertRaises(TypeError, ndt, "var * ref(var * string)")
-        self.assertRaises(TypeError, ndt, "var * SomeConstr(var * string)")
-
     def test_var_dim_external_offsets(self):
         # Invalid offsets.
         self.assertRaises(TypeError, ndt, "int8", [""])
@@ -478,9 +535,6 @@ class TestVarDim(unittest.TestCase):
         self.assertRaises(ValueError, ndt, "N * int8", [[0, 2], [0, 10, 20]])
         self.assertRaises(ValueError, ndt, "var * int8", [[0, 2], [0, 10, 20]])
 
-        # Mixing external and internal offsets.
-        self.assertRaises(TypeError, ndt, "var(offsets=[0,2,10]) * int8", [[0, 1], [0, 2]])
-
 
 class TestSymbolicDim(unittest.TestCase):
 
@@ -499,6 +553,7 @@ class TestSymbolicDim(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_symbolic_dim_common_fields(self):
         dt = "{a: complex64, b: string}"
@@ -506,12 +561,12 @@ class TestSymbolicDim(unittest.TestCase):
         check_serialize(self, t)
         dtype = ndt(dt)
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestEllipsisDim(unittest.TestCase):
@@ -531,6 +586,7 @@ class TestEllipsisDim(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_ellipsis_dim_common_fields(self):
         dt = "{a: complex64, b: string}"
@@ -538,12 +594,51 @@ class TestEllipsisDim(unittest.TestCase):
         check_serialize(self, t)
         dtype = ndt(dt)
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
+
+class TestArray(unittest.TestCase):
+
+    def test_array_predicates(self):
+        t = ndt("array of complex128")
+        check_serialize(self, t)
+
+        self.assertFalse(t.isabstract())
+        self.assertFalse(t.iscomplex())
+        self.assertTrue(t.isconcrete())
+        self.assertFalse(t.isfloat())
+        self.assertFalse(t.isoptional())
+        self.assertFalse(t.isscalar())
+        self.assertFalse(t.issigned())
+        self.assertFalse(t.isunsigned())
+
+        self.assertFalse(t.is_c_contiguous())
+        self.assertFalse(t.is_f_contiguous())
+
+    def test_array_dim_common_fields(self):
+        dt = "{a: complex64, b: float64}"
+        t = ndt("array of %s" % dt)
+        check_serialize(self, t)
+        dtype = ndt(dt)
+
+        # The flexible array counts as a dtype.
+        self.assertEqual(t.ndim, 1)
+
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
+
+        if not HAVE_32_BIT_LINUX:
+            self.assertEqual(t.itemsize, dtype.itemsize)
+            self.assertEqual(t.align, dtype.align)
+
+    def test_array_invariants(self):
+        # Mixing array with fixed/var dimensions is disallowed.
+        self.assertRaises(TypeError, ndt, "array of 2 * int64")
+        self.assertRaises(TypeError, ndt, "array of var * int64")
 
 
 class TestTuple(unittest.TestCase):
@@ -564,6 +659,7 @@ class TestTuple(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
         for s in ["(Any)", "(int64, N * M * uint8)", "(string, Float)"]:
             t = ndt(s)
@@ -580,6 +676,7 @@ class TestTuple(unittest.TestCase):
 
             self.assertFalse(t.is_c_contiguous())
             self.assertFalse(t.is_f_contiguous())
+            self.assertFalse(t.is_var_contiguous())
 
     def test_tuple_common_fields(self):
         f = "{a: complex64, b: string}"
@@ -592,8 +689,8 @@ class TestTuple(unittest.TestCase):
             self.assertEqual(t.itemsize, 2 * field.itemsize)
             self.assertEqual(t.align, field.align)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestRecord(unittest.TestCase):
@@ -614,6 +711,7 @@ class TestRecord(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
         for s in ["{a: Any, b: Complex}", "{x: N * M * T}"]:
             t = ndt(s)
@@ -630,6 +728,7 @@ class TestRecord(unittest.TestCase):
 
             self.assertFalse(t.is_c_contiguous())
             self.assertFalse(t.is_f_contiguous())
+            self.assertFalse(t.is_var_contiguous())
 
     def test_record_common_fields(self):
         f = "{a: complex64, b: string}"
@@ -642,8 +741,63 @@ class TestRecord(unittest.TestCase):
             self.assertEqual(t.itemsize, 3 * field.itemsize)
             self.assertEqual(t.align, field.align)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
+
+
+class TestUnion(unittest.TestCase):
+
+    def test_union_predicates(self):
+        for s in ["[A of int64 | B of bytes]", "[X of string | Y of uint8]"]:
+            t = ndt(s)
+            check_serialize(self, t)
+
+            self.assertFalse(t.isabstract())
+            self.assertFalse(t.iscomplex())
+            self.assertTrue(t.isconcrete())
+            self.assertFalse(t.isfloat())
+            self.assertFalse(t.isoptional())
+            self.assertFalse(t.isscalar())
+            self.assertFalse(t.issigned())
+            self.assertFalse(t.isunsigned())
+
+            self.assertTrue(t.is_c_contiguous())
+            self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
+
+        for s in ["[A of Any | B of Complex]", "[X of N * M * T]"]:
+            t = ndt(s)
+            check_serialize(self, t)
+
+            self.assertTrue(t.isabstract())
+            self.assertFalse(t.iscomplex())
+            self.assertFalse(t.isconcrete())
+            self.assertFalse(t.isfloat())
+            self.assertFalse(t.isoptional())
+            self.assertFalse(t.isscalar())
+            self.assertFalse(t.issigned())
+            self.assertFalse(t.isunsigned())
+
+            self.assertFalse(t.is_c_contiguous())
+            self.assertFalse(t.is_f_contiguous())
+            self.assertFalse(t.is_var_contiguous())
+
+    def test_union_common_fields(self):
+        f = "[A of uint64 | B of uint8]"
+        g = "[C of (uint64, uint64) | D of string]"
+        t = ndt("[X of %s | Y of %s]" % (f, g))
+        u = ndt("(uint64, uint64)")
+
+        check_serialize(self, t)
+
+        a = ndt(g)
+
+        self.assertEqual(t.ndim, 0)
+        self.assertEqual(t.itemsize, u.itemsize + 2)
+        self.assertEqual(t.align, 1)
+
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestRef(unittest.TestCase):
@@ -664,6 +818,7 @@ class TestRef(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
         for s in ["&Any", "&(int64, N * M * uint8)"]:
             t = ndt(s)
@@ -680,6 +835,7 @@ class TestRef(unittest.TestCase):
 
             self.assertFalse(t.is_c_contiguous())
             self.assertFalse(t.is_f_contiguous())
+            self.assertFalse(t.is_var_contiguous())
 
     def test_ref_common_fields(self):
         a = "{a: complex64, b: string}"
@@ -691,8 +847,8 @@ class TestRef(unittest.TestCase):
         self.assertEqual(t.itemsize, SIZEOF_PTR)
         self.assertEqual(t.align, SIZEOF_PTR)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestConstr(unittest.TestCase):
@@ -713,6 +869,7 @@ class TestConstr(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_constr_common_fields(self):
         a = "{a: complex64, b: string}"
@@ -725,8 +882,8 @@ class TestConstr(unittest.TestCase):
             self.assertEqual(t.itemsize, arg.itemsize)
             self.assertEqual(t.align, arg.align)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestNominal(unittest.TestCase):
@@ -757,6 +914,7 @@ class TestNominal(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_nominal_common_fields(self):
         t = ndt("some_t")
@@ -769,8 +927,8 @@ class TestNominal(unittest.TestCase):
             self.assertEqual(t.itemsize, 2 * 10 * dtype.itemsize)
             self.assertEqual(t.align, dtype.align)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
     def test_nominal_exceptions(self):
         # not in the typedef table
@@ -797,17 +955,18 @@ class TestScalarKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_scalar_kind_common_fields(self):
         t = ndt("Scalar")
         check_serialize(self, t)
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestCategorical(unittest.TestCase):
@@ -832,6 +991,7 @@ class TestCategorical(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_categorical_common_fields(self):
         t = ndt("categorical(NA, 'something', 'must', 'be', 'done')")
@@ -842,8 +1002,8 @@ class TestCategorical(unittest.TestCase):
             self.assertEqual(t.itemsize, 8)
             self.assertEqual(t.align, 8)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestFixedStringKind(unittest.TestCase):
@@ -863,16 +1023,17 @@ class TestFixedStringKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_fixed_string_kind_common_fields(self):
         t = ndt("FixedString")
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestFixedString(unittest.TestCase):
@@ -892,6 +1053,7 @@ class TestFixedString(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_fixed_string_common_fields(self):
         for encoding, codepoint_size in [
@@ -908,8 +1070,8 @@ class TestFixedString(unittest.TestCase):
                 self.assertEqual(t.itemsize, 20 * codepoint_size)
                 self.assertEqual(t.align, codepoint_size)
 
-            self.assertRaises(TypeError, t, 'shape')
-            self.assertRaises(TypeError, t, 'strides')
+            self.assertEqual(t.shape, ())
+            self.assertEqual(t.strides, ())
 
 
 class TestFixedBytesKind(unittest.TestCase):
@@ -929,16 +1091,17 @@ class TestFixedBytesKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_fixed_string_kind_common_fields(self):
         t = ndt("FixedBytes")
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestFixedBytes(unittest.TestCase):
@@ -958,6 +1121,7 @@ class TestFixedBytes(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_fixed_bytes_common_fields(self):
         for align in [1,2,4,8,16,32,64]:
@@ -970,8 +1134,8 @@ class TestFixedBytes(unittest.TestCase):
                 self.assertEqual(t.itemsize, 1024)
                 self.assertEqual(t.align, align)
 
-            self.assertRaises(TypeError, t, 'shape')
-            self.assertRaises(TypeError, t, 'strides')
+            self.assertEqual(t.shape, ())
+            self.assertEqual(t.strides, ())
 
     def test_fixed_bytes_exceptions(self):
         # Data size must be a multiple of align.
@@ -995,6 +1159,7 @@ class TestString(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_string_common_fields(self):
         t = ndt("string")
@@ -1003,8 +1168,8 @@ class TestString(unittest.TestCase):
         self.assertEqual(t.itemsize, SIZEOF_PTR)
         self.assertEqual(t.align, SIZEOF_PTR)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestBytes(unittest.TestCase):
@@ -1024,6 +1189,7 @@ class TestBytes(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_bytes_common_fields(self):
         t = ndt("bytes")
@@ -1033,8 +1199,8 @@ class TestBytes(unittest.TestCase):
             self.assertEqual(t.itemsize, 16)
             self.assertEqual(t.align, 8)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestChar(unittest.TestCase):
@@ -1054,6 +1220,7 @@ class TestChar(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_char_common_fields(self):
         t = ndt("char('utf32')")
@@ -1063,8 +1230,8 @@ class TestChar(unittest.TestCase):
         self.assertEqual(t.itemsize, 4)
         self.assertEqual(t.align, 4)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestBool(unittest.TestCase):
@@ -1084,6 +1251,7 @@ class TestBool(unittest.TestCase):
 
         self.assertTrue(t.is_c_contiguous())
         self.assertTrue(t.is_f_contiguous())
+        self.assertTrue(t.is_var_contiguous())
 
     def test_bool_common_fields(self):
         t = ndt("bool")
@@ -1092,8 +1260,8 @@ class TestBool(unittest.TestCase):
         self.assertEqual(t.itemsize, 1)
         self.assertEqual(t.align, 1)
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertEqual(t.shape, ())
+        self.assertEqual(t.strides, ())
 
 
 class TestSignedKind(unittest.TestCase):
@@ -1113,16 +1281,17 @@ class TestSignedKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_signed_kind_common_fields(self):
         t = ndt("Signed")
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestSigned(unittest.TestCase):
@@ -1145,6 +1314,7 @@ class TestSigned(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_signed_common_fields(self):
         for s, itemsize in [
@@ -1160,8 +1330,8 @@ class TestSigned(unittest.TestCase):
                 self.assertEqual(t.itemsize, itemsize)
                 self.assertEqual(t.align, itemsize)
 
-            self.assertRaises(TypeError, t, 'shape')
-            self.assertRaises(TypeError, t, 'shape')
+            self.assertEqual(t.shape, ())
+            self.assertEqual(t.strides, ())
 
 
 class TestUnsignedKind(unittest.TestCase):
@@ -1181,16 +1351,17 @@ class TestUnsignedKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_unsigned_kind_common_fields(self):
         t = ndt("Unsigned")
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestUnsigned(unittest.TestCase):
@@ -1213,6 +1384,7 @@ class TestUnsigned(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_unsigned_common_fields(self):
         for s, itemsize in [
@@ -1228,8 +1400,8 @@ class TestUnsigned(unittest.TestCase):
                 self.assertEqual(t.itemsize, itemsize)
                 self.assertEqual(t.align, itemsize)
 
-            self.assertRaises(TypeError, t, 'shape')
-            self.assertRaises(TypeError, t, 'shape')
+            self.assertEqual(t.shape, ())
+            self.assertEqual(t.strides, ())
 
 
 class TestFloatKind(unittest.TestCase):
@@ -1249,25 +1421,24 @@ class TestFloatKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_float_kind_common_fields(self):
         t = ndt("Float")
         check_serialize(self, t)
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestFloat(unittest.TestCase):
 
     def test_float_predicates(self):
-        _float = ['float32', 'float64']
-        if HAVE_PYTHON_36:
-            _float.insert(0, 'float16')
+        _float = ['bfloat16', 'float16', 'float32', 'float64']
 
         for s in _float:
             t = ndt(s)
@@ -1284,11 +1455,10 @@ class TestFloat(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_float_common_fields(self):
-        _float = [('float32', 4), ('float64', 8)]
-        if HAVE_PYTHON_36:
-            _float.insert(0, ('float16', 2))
+        _float = [('bfloat16', 2), ('float16', 2), ('float32', 4), ('float64', 8)]
 
         for s, itemsize in _float:
             t = ndt(s)
@@ -1298,8 +1468,8 @@ class TestFloat(unittest.TestCase):
                 self.assertEqual(t.itemsize, itemsize)
                 self.assertEqual(t.align, itemsize)
 
-            self.assertRaises(TypeError, t, 'shape')
-            self.assertRaises(TypeError, t, 'shape')
+            self.assertEqual(t.shape, ())
+            self.assertEqual(t.strides, ())
 
 
 class TestComplexKind(unittest.TestCase):
@@ -1319,24 +1489,23 @@ class TestComplexKind(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_complex_kind_common_fields(self):
         t = ndt("Complex")
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestComplex(unittest.TestCase):
 
     def test_complex_predicates(self):
-        _complex = ['complex64', 'complex128']
-        if HAVE_PYTHON_36:
-            _complex.insert(0, 'complex32')
+        _complex = ['bcomplex32', 'complex32', 'complex64', 'complex128']
 
         for s in _complex:
             t = ndt(s)
@@ -1353,11 +1522,10 @@ class TestComplex(unittest.TestCase):
 
             self.assertTrue(t.is_c_contiguous())
             self.assertTrue(t.is_f_contiguous())
+            self.assertTrue(t.is_var_contiguous())
 
     def test_complex_common_fields(self):
-        _complex = [('complex64', 8), ('complex128', 16)]
-        if HAVE_PYTHON_36:
-            _complex.insert(0, ('complex32', 4))
+        _complex = [('bcomplex32', 4), ('complex32', 4), ('complex64', 8), ('complex128', 16)]
 
         for s, itemsize in _complex:
             t = ndt(s)
@@ -1367,8 +1535,8 @@ class TestComplex(unittest.TestCase):
                 self.assertEqual(t.itemsize, itemsize)
                 self.assertEqual(t.align, itemsize // 2)
 
-            self.assertRaises(TypeError, t, 'shape')
-            self.assertRaises(TypeError, t, 'shape')
+            self.assertEqual(t.shape, ())
+            self.assertEqual(t.strides, ())
 
 
 class TestTypevar(unittest.TestCase):
@@ -1388,16 +1556,17 @@ class TestTypevar(unittest.TestCase):
 
         self.assertFalse(t.is_c_contiguous())
         self.assertFalse(t.is_f_contiguous())
+        self.assertFalse(t.is_var_contiguous())
 
     def test_typevar_common_fields(self):
         t = ndt("T")
 
-        self.assertRaises(TypeError, t, 'ndim')
-        self.assertRaises(TypeError, t, 'itemsize')
-        self.assertRaises(TypeError, t, 'align')
+        self.assertRaises(TypeError, getattr, t, 'ndim')
+        self.assertRaises(TypeError, getattr, t, 'itemsize')
+        self.assertRaises(TypeError, getattr, t, 'align')
 
-        self.assertRaises(TypeError, t, 'shape')
-        self.assertRaises(TypeError, t, 'strides')
+        self.assertRaises(TypeError, getattr, t, 'shape')
+        self.assertRaises(TypeError, getattr, t, 'strides')
 
 
 class TestCopy(unittest.TestCase):
@@ -1450,7 +1619,7 @@ class TestBufferProtocol(unittest.TestCase):
             ("(2,19)T{<b:a:xxxQ:b:}", 12, 4),
             ("(31,221)T{<b:a:xxxxxxxQ:b:}", 16, 8),
             ("(2,3,10)T{<b:a:xxxxxxxxxxxxxxxQ:b:xxxxxxxx}", 32, 16),
-            ("(2,10)T{=L:a:(2,3)D:b:}", 100, 1)]
+            ("(2,10)T{=L:a:(2,3)Zd:b:}", 100, 1)]
 
         test_error_cases = [
             # empty shape (scalars are not arrays in datashape)
@@ -1524,13 +1693,10 @@ class TestBufferProtocol(unittest.TestCase):
           'c', 'b', 'B',
           'h', 'i', 'l', 'q',
           'H', 'I', 'L', 'Q',
-          'f', 'd']
+          'e', 'f', 'd']
 
         native = ['n', 'N']
 
-        if HAVE_PYTHON_36:
-            standard += ['e']
-
         for fmt in standard:
             for modifier in ['', '@', '=', '<', '>', '!']:
                 f = modifier + fmt
@@ -1553,17 +1719,16 @@ class TestBufferProtocol(unittest.TestCase):
                 self.assertRaises(ValueError, ndt.from_format, f)
                 self.assertRaises(struct.error, struct.Struct, f)
 
-        if HAVE_PYTHON_36:
-            # complex32
-            fmt = 'E'
-            for modifier in ['', '@', '=', '<', '>', '!']:
-                f = modifier + fmt
-                t = ndt.from_format(f)
-                if not HAVE_32_BIT_LINUX:
-                    self.assertEqual(t.itemsize, 4)
+        # complex32
+        fmt = 'Ze'
+        for modifier in ['', '@', '=', '<', '>', '!']:
+            f = modifier + fmt
+            t = ndt.from_format(f)
+            if not HAVE_32_BIT_LINUX:
+                self.assertEqual(t.itemsize, 4)
 
         # complex64
-        fmt = 'F'
+        fmt = 'Zf'
         for modifier in ['', '@', '=', '<', '>', '!']:
             f = modifier + fmt
             t = ndt.from_format(f)
@@ -1571,7 +1736,7 @@ class TestBufferProtocol(unittest.TestCase):
                 self.assertEqual(t.itemsize, 8)
 
         # complex128
-        fmt = 'D'
+        fmt = 'Zd'
         for modifier in ['', '@', '=', '<', '>', '!']:
             f = modifier + fmt
             t = ndt.from_format(f)
@@ -1703,6 +1868,38 @@ class TestMatch(unittest.TestCase):
         self.assertFalse(p.match(c))
 
 
+class TestUnify(unittest.TestCase):
+
+    def test_unify(self):
+
+        t = ndt("2 * 3 * float32")
+        u = ndt("2 * 3 * float32")
+        w = t.unify(u)
+        self.assertEqual(w, ndt("2 * 3 * float32"))
+
+        t = ndt("2 * 3 * float32")
+        u = ndt("2 * 3 * ?float64")
+        w = t.unify(u)
+        self.assertEqual(w, ndt("2 * 3 * ?float64"))
+
+        t = ndt("2 * 3 * (?Any, int64)")
+        u = ndt("2 * 3 * (float64, Any)")
+        w = t.unify(u)
+        self.assertEqual(w, ndt("2 * 3 * (?float64, int64)"))
+
+        t = ndt("var(offsets=[0,2]) * var(offsets=[0,3,10]) * (int64, complex128)")
+        u = ndt("var(offsets=[0,2]) * var(offsets=[0,3,10]) * ?(int8, complex64)")
+        w = t.unify(u)
+        del t
+        del u
+        gc.collect()
+        self.assertEqual(w, ndt("var(offsets=[0,2]) * var(offsets=[0,3,10]) * ?(int64, complex128)"))
+
+        x = copy(w)
+        del(w)
+        self.assertEqual(x, ndt("var(offsets=[0,2]) * var(offsets=[0,3,10]) * ?(int64, complex128)"))
+
+
 class TestApply(unittest.TestCase):
 
     def test_apply(self):
@@ -1714,13 +1911,14 @@ class TestApply(unittest.TestCase):
 
 
         # Argument types:
-        in_types = [ndt("20 * 2 * 3 * int64"), ndt("20 * 3 * 4 * int64")]
+        types = [ndt("20 * 2 * 3 * int64"), ndt("20 * 3 * 4 * int64")]
 
-        spec = sig.apply(in_types)
-        self.assertEqual(spec.sig, sig)
-        self.assertEqual(spec.in_types, in_types)
-        self.assertSequenceEqual(spec.out_types, [ndt("20 * 2 * 4 * float64")])
+        spec = sig.apply(*types)
         self.assertEqual(spec.outer_dims, 1)
+        self.assertEqual(spec.nin, 2)
+        self.assertEqual(spec.nout, 1)
+        self.assertEqual(spec.nargs, 3)
+        self.assertEqual(spec.types, types + [ndt("20 * 2 * 4 * float64")])
 
     def test_apply_error(self):
 
@@ -1731,8 +1929,8 @@ class TestApply(unittest.TestCase):
                ["20 * 2 * 100 * int64", "20 * 3 * 4 * int64"]]
 
         for l in lst:
-            in_types = [ndt(x) for x in l]
-            self.assertRaises(TypeError, sig.apply, in_types)
+            types = [ndt(x) for x in l]
+            self.assertRaises(TypeError, sig.apply, types)
 
 
 def from_shape_strides(shape, strides):
@@ -1745,12 +1943,19 @@ class TestBroadcast(unittest.TestCase):
 
     def test_broadcast(self):
 
-        for c in BROADCAST_TEST_CASES:
-            spec = c.sig.apply(c.in_types)
+        for d in BROADCAST_TEST_CASES:
+            sig, args, kwargs, expected = d.values()
+            spec = sig.apply(*args, out=kwargs)
+
+            msg = str(sig)
 
-            self.assertEqual(len(spec), len(c))
-            for v, u in zip(spec, c):
-                self.assertEqual(v, u)
+            self.assertEqual(len(spec), len(expected), msg=msg)
+            self.assertEqual(spec.flags, expected.flags, msg=msg)
+            self.assertEqual(spec.outer_dims, expected.outer_dims, msg=msg)
+            self.assertEqual(spec.nin, expected.nin, msg=msg)
+            self.assertEqual(spec.nout, expected.nout, msg=msg)
+            self.assertEqual(spec.nargs, expected.nargs, msg=msg)
+            self.assertEqual(spec.types, expected.types, msg=msg)
 
     def test_against_numpy(self):
 
@@ -1788,8 +1993,8 @@ class TestBroadcast(unittest.TestCase):
 
                 t = from_shape_strides(xshape, xstrides)
                 u = from_shape_strides(yshape, ystrides)
-                spec = sig.apply([t, u])
-                tt, uu = spec.in_broadcast
+                spec = sig.apply(t, u)
+                tt, uu = spec.types[:2]
 
                 self.assertEqual(tt.shape, xx.shape)
                 self.assertEqual(uu.shape, yy.shape)
@@ -1916,8 +2121,10 @@ ALL_TESTS = [
   TestVarDim,
   TestSymbolicDim,
   TestEllipsisDim,
+  TestArray,
   TestTuple,
   TestRecord,
+  TestUnion,
   TestRef,
   TestConstr,
   TestNominal,
@@ -1945,6 +2152,7 @@ ALL_TESTS = [
   TestConstruction,
   TestError,
   TestMatch,
+  TestUnify,
   TestApply,
   TestBroadcast,
   TestTypedef,