ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/libndtypes/values.c

@@ -56,7 +56,7 @@ ndt_value_del(ndt_value_t *mem)
 }
 
 void
-ndt_value_array_del(ndt_value_t *mem, int64_t ntypes)
+ndt_value_array_del(const ndt_value_t *mem, int64_t ntypes)
 {
     int64_t i;
 
@@ -70,7 +70,7 @@ ndt_value_array_del(ndt_value_t *mem, int64_t ntypes)
         }
     }
 
-    ndt_free(mem);
+    ndt_free((void *)mem);
 }
 
 /* Value sequences */

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

@@ -335,75 +335,92 @@ def genindices(factor):
                 yield (factor * i, factor * j, factor * k)
 
 BROADCAST_TEST_CASES = [
-    ApplySpec(
-        flags = 'C|Fortran|Strided|Xnd',
-        sig = ndt("uint8 -> float64"),
-        in_types = [ndt("uint8")],
-        out_types = [ndt("float64")],
-        in_broadcast = [],
-        outer_dims = 0),
-
-    ApplySpec(
-        flags = 'Elemwise1D|C|Fortran|Strided|Xnd',
-        sig = ndt("... * uint8 -> ... * float64"),
-        in_types = [ndt("2 * uint8")],
-        out_types = [ndt("2 * float64")],
-        in_broadcast = [ndt("2 * uint8")],
-        outer_dims = 1),
-
-    ApplySpec(
-        flags = 'C|Fortran|Strided|Xnd',
-        sig = ndt("F[... * uint8] -> F[... * float64]"),
-        in_types = [ndt("!2 * 3 * uint8")],
-        out_types = [ndt("!2 * 3 * float64")],
-        in_broadcast = [ndt("!2 * 3 * uint8")],
-        outer_dims = 2),
-
-    ApplySpec(
-        flags = 'C|Fortran|Strided|Xnd',
-        sig = ndt("... * uint8 -> ... * float64"),
-        in_types = [ndt("fixed(shape=2, step=10) * uint8")],
-        out_types = [ndt("2 * float64")],
-        in_broadcast = [ndt("fixed(shape=2, step=10) * uint8")],
-        outer_dims = 1),
-
-    ApplySpec(
-        flags = 'Strided|Xnd',
-        sig = ndt("... * N * uint8 -> ... * N * float64"),
-        in_types = [ndt("fixed(shape=2, step=10) * uint8")],
-        out_types = [ndt("2 * float64")],
-        in_broadcast = [ndt("fixed(shape=2, step=10) * uint8")],
-        outer_dims = 0),
-
-    ApplySpec(
-        flags = 'C|Fortran|Strided|Xnd',
-        sig = ndt("... * N * uint8 -> ... * N * float64"),
-        in_types = [ndt("2 * 3 * uint8")],
-        out_types = [ndt("2 * 3 * float64")],
-        in_broadcast = [ndt("2 * 3 * uint8")],
-        outer_dims = 1),
-
-    ApplySpec(
-        flags = 'C|Strided|Xnd',
-        sig = ndt("... * N * M * uint8 -> ... * N * M * float64"),
-        in_types = [ndt("2 * 3 * uint8")],
-        out_types = [ndt("2 * 3 * float64")],
-        in_broadcast = [ndt("2 * 3 * uint8")],
-        outer_dims = 0),
-
-    ApplySpec(
-        flags = 'Xnd',
-        sig = ndt("N * D * float64 -> P * float64"),
-        in_types = [ndt("2 * 10 * float64")],
-        out_types = [ndt("P * float64")],
-        in_broadcast = [],
-        outer_dims = 0),
-
-    ApplySpec(
-        flags = 'C|Fortran|Xnd',
-        sig = ndt("var... * float64 -> var... * float64"),
-        in_types = [ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64")],
-        out_types = [ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64")],
-        in_broadcast = [],
-        outer_dims = 2)
+    dict(sig=ndt("uint8 -> float64"),
+         args=[ndt("uint8")],
+         out=None,
+         spec= ApplySpec(
+                 flags = 'C|Fortran|Strided|Xnd',
+                 outer_dims = 0,
+                 nin = 1,
+                 nout = 1,
+                 nargs = 2,
+                 types = [ndt("uint8"), ndt("float64")])),
+
+    dict(sig=ndt("... * uint8 -> ... * float64"),
+         args=[ndt("2 * uint8")],
+         out=None,
+         spec=ApplySpec(
+            flags = 'OptZ|OptC|OptS|C|Fortran|Strided|Xnd',
+            outer_dims = 1,
+            nin = 1,
+            nout = 1,
+            nargs = 2,
+            types = [ndt("2 * uint8"), ndt("2 * float64")])),
+
+    dict(sig=ndt("F[... * uint8] -> F[... * float64]"),
+         args=[ndt("!2 * 3 * uint8")],
+         out=None,
+         spec=ApplySpec(
+                flags = 'OptS|C|Fortran|Strided|Xnd',
+                outer_dims = 2,
+                nin = 1,
+                nout = 1,
+                nargs = 2,
+                types = [ndt("!2 * 3 * uint8"), ndt("!2 * 3 * float64")])),
+
+    dict(sig=ndt("... * uint8 -> ... * float64"),
+         args=[ndt("fixed(shape=2, step=10) * uint8")],
+         out=None,
+         spec=ApplySpec(
+                flags = 'OptS|C|Fortran|Strided|Xnd',
+                outer_dims = 1,
+                nin = 1,
+                nout = 1,
+                nargs = 2,
+                types = [ndt("fixed(shape=2, step=10) * uint8"), ndt("2 * float64")])),
+
+    dict(sig=ndt("... * N * uint8 -> ... * N * float64"),
+         args=[ndt("fixed(shape=2, step=10) * uint8")],
+         out=None,
+         spec=ApplySpec(
+                flags = 'Strided|Xnd',
+                outer_dims = 0,
+                nin = 1,
+                nout = 1,
+                nargs = 2,
+                types = [ndt("fixed(shape=2, step=10) * uint8"), ndt("2 * float64")])),
+
+    dict(sig=ndt("... * N * uint8 -> ... * N * float64"),
+         args=[ndt("2 * 3 * uint8")],
+         out=None,
+         spec=ApplySpec(
+                flags = 'OptZ|OptC|OptS|C|Fortran|Strided|Xnd' ,
+                outer_dims = 1,
+                nin = 1,
+                nout = 1,
+                nargs = 2,
+                types = [ndt("2 * 3 * uint8"), ndt("2 * 3 * float64")])),
+
+    dict(sig=ndt("... * N * M * uint8 -> ... * N * M * float64"),
+         args=[ndt("2 * 3 * uint8")],
+         out=None,
+         spec=ApplySpec(
+                flags = 'C|Strided|Xnd',
+                outer_dims = 0,
+                nin = 1,
+                nout = 1,
+                nargs = 2,
+                types = [ndt("2 * 3 * uint8"), ndt("2 * 3 * float64")])),
+
+    dict(sig=ndt("var... * float64 -> var... * float64"),
+         args=[ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64")],
+         out=None,
+         spec=ApplySpec(
+                flags = 'Xnd',
+                outer_dims = 2,
+                nin = 1,
+                nout = 1,
+                nargs = 2,
+                types = [ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64"),
+                         ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64")])),
 ]

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

@@ -5,7 +5,6 @@ def skip_if(condition, reason):
     if condition:
         raise unittest.SkipTest(reason)
 
-HAVE_PYTHON_36 = sys.version_info >= (3, 6, 0)
 HAVE_32_BIT_LINUX = sys.maxsize == 2**31-1 and sys.platform == 'linux'
 
 requires_py36 = unittest.skipUnless(

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

@@ -54,17 +54,14 @@ The xnd module uses ndtypes to implement a general container for mapping most
 Python types relevant for scientific computing directly to memory.
 """
 
-def _pretty_repr(self):
-    return """\
-ApplySpec(
-  flags=%r,
-  sig=%r,
-  in_types=%r,
-  in_broadcast=%r,
-  out_types=%r,
-  outer_dims=%r
-)""" % (self.flags, self.sig, self.in_types, self.in_broadcast, self.out_types, self.outer_dims)
-
-from . import _ndtypes
-_ndtypes.ApplySpec.__repr__ = _pretty_repr
 from ._ndtypes import *
+from ._ndtypes import _ApplySpec
+from . import _ndtypes
+
+class ApplySpec(_ApplySpec):
+
+    def __repr__(self):
+        return "\
+ApplySpec(flags=%r,\n  outer_dims=%r\n  nin=%r,\n  nout=%r,\n  nargs=%r,\n  types=%r)\
+" % (self.flags, self.outer_dims, self.nin, self.nout, self.nargs, self.types)
+

data/ext/ruby_ndtypes/ndtypes/python/ndtypes/_ndtypes.c

@@ -54,65 +54,70 @@
 
 
 /****************************************************************************/
-/*                           Resource Buffer Object                         */
+/*                               Cached objects                             */
 /****************************************************************************/
 
-/* This object handles resources like offsets that are shared by several
-   ndt objects. It is never exposed to the Python level.
-
-   At a later stage, the object will need to communicate with Arrow
-   or other formats to store external resources. */
-
-static PyObject *seterr(ndt_context_t *ctx);
+static PyObject *Deserialize = NULL;
+static PyTypeObject *_ApplySpec = NULL;
 
-typedef struct {
-    PyObject_HEAD
-    ndt_meta_t *m;
-} ResourceBufferObject;
 
-static PyTypeObject ResourceBuffer_Type;
+/****************************************************************************/
+/*                               Error handling                             */
+/****************************************************************************/
 
 static PyObject *
-rbuf_alloc(void)
+seterr(ndt_context_t *ctx)
 {
-    NDT_STATIC_CONTEXT(ctx);
-    ResourceBufferObject *self;
+    PyObject *exc = PyExc_RuntimeError;
 
-    self = (ResourceBufferObject *)
-        PyObject_GC_New(ResourceBufferObject, &ResourceBuffer_Type);
-    if (self == NULL) {
-        return NULL;
-    }
- 
-    self->m = ndt_meta_new(&ctx);
-    if (self->m == NULL) {
-        return seterr(&ctx);
+    switch (ctx->err) {
+    case NDT_Success: /* should never be set on error */
+        exc = PyExc_RuntimeError;
+        break;
+    case NDT_ValueError:
+        exc = PyExc_ValueError;
+        break;
+    case NDT_TypeError:
+        exc = PyExc_TypeError;
+        break;
+    case NDT_InvalidArgumentError:
+        exc = PyExc_ValueError;
+        break;
+    case NDT_NotImplementedError:
+        exc = PyExc_NotImplementedError;
+        break;
+    case NDT_IndexError:
+        exc = PyExc_IndexError;
+        break;
+    case NDT_LexError: case NDT_ParseError:
+        exc = PyExc_ValueError;
+        break;
+    case NDT_OSError:
+        exc = PyExc_OSError;
+        break;
+    case NDT_RuntimeError:
+        exc = PyExc_RuntimeError;
+        break;
+    case NDT_MemoryError:
+        exc = PyExc_MemoryError;
+        break;
     }
 
-    PyObject_GC_Track(self);
-    return (PyObject *)self;
-}
+    PyErr_SetString(exc, ndt_context_msg(ctx));
+    ndt_context_del(ctx);
 
-static int
-rbuf_traverse(ResourceBufferObject *self UNUSED, visitproc visit UNUSED,
-              void *arg UNUSED)
-{
-    return 0;
-}
+    return NULL;
+};
 
-static void
-rbuf_dealloc(ResourceBufferObject *self)
-{
-    ndt_meta_del(self->m);
-    self->m = NULL;
-    PyObject_GC_UnTrack(self);
-    PyObject_GC_Del(self);
-}
+
+/****************************************************************************/
+/*                         Get offsets from a list                          */
+/****************************************************************************/
 
 static int
-rbuf_init_from_offset_list(ResourceBufferObject *rbuf, PyObject *list)
+offsets_from_list(ndt_meta_t *m, PyObject *list)
 {
-    ndt_meta_t * const m = rbuf->m;
+    NDT_STATIC_CONTEXT(ctx);
     PyObject *lst;
 
     if (!PyList_Check(list)) {
@@ -166,99 +171,17 @@ rbuf_init_from_offset_list(ResourceBufferObject *rbuf, PyObject *list)
             offsets[k] = (int32_t)x;
         }
 
-        m->noffsets[m->ndims] = (int32_t)noffsets;
-        m->offsets[m->ndims] = offsets;
+        m->offsets[m->ndims] = ndt_offsets_from_ptr(offsets, (int32_t)noffsets, &ctx);
+        if (m->offsets[m->ndims] == NULL) {
+            (void)seterr(&ctx);
+            return -1;
+        }
         m->ndims++;
     }
 
     return 0;
 }
 
-static PyObject *
-rbuf_from_offset_lists(PyObject *list)
-{
-    PyObject *rbuf;
-
-    rbuf = rbuf_alloc();
-    if (rbuf == NULL) {
-        return NULL;
-    }
-
-    if (rbuf_init_from_offset_list((ResourceBufferObject *)rbuf, list) < 0) {
-        Py_DECREF(rbuf);
-        return NULL;
-    }
-
-    return rbuf;
-}
-
-static PyTypeObject ResourceBuffer_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = "_ndtypes.resource",
-    .tp_basicsize = sizeof(ResourceBufferObject),
-    .tp_dealloc = (destructor)rbuf_dealloc,
-    .tp_getattro = PyObject_GenericGetAttr,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
-    .tp_traverse = (traverseproc)rbuf_traverse
-};
-
-
-/****************************************************************************/
-/*                               Cached objects                             */
-/****************************************************************************/
-
-static PyObject *Deserialize = NULL;
-static PyTypeObject *ApplySpec = NULL;
-
-
-/****************************************************************************/
-/*                               Error handling                             */
-/****************************************************************************/
-
-static PyObject *
-seterr(ndt_context_t *ctx)
-{
-    PyObject *exc = PyExc_RuntimeError;
-
-    switch (ctx->err) {
-    case NDT_Success: /* should never be set on error */
-        exc = PyExc_RuntimeError;
-        break;
-    case NDT_ValueError:
-        exc = PyExc_ValueError;
-        break;
-    case NDT_TypeError:
-        exc = PyExc_TypeError;
-        break;
-    case NDT_InvalidArgumentError:
-        exc = PyExc_ValueError;
-        break;
-    case NDT_NotImplementedError:
-        exc = PyExc_NotImplementedError;
-        break;
-    case NDT_IndexError:
-        exc = PyExc_IndexError;
-        break;
-    case NDT_LexError: case NDT_ParseError:
-        exc = PyExc_ValueError;
-        break;
-    case NDT_OSError:
-        exc = PyExc_OSError;
-        break;
-    case NDT_RuntimeError:
-        exc = PyExc_RuntimeError;
-        break;
-    case NDT_MemoryError:
-        exc = PyExc_MemoryError;
-        break;
-    }
-
-    PyErr_SetString(exc, ndt_context_msg(ctx));
-    ndt_context_del(ctx);
-
-    return NULL;
-};
-
 
 /****************************************************************************/
 /*                                 ndt object                               */
@@ -275,29 +198,40 @@ ndtype_alloc(PyTypeObject *type)
     if (self == NULL) {
         return NULL;
     }
- 
-    RBUF(self) = NULL;
+    self->hash = -1;
     NDT(self) = NULL;
 
     return (PyObject *)self;
 }
 
-static int
-ndtype_traverse(NdtObject *self, visitproc visit, void *arg)
-{
-    Py_VISIT(self->rbuf);
-    return 0;
-}
-
 static void
 ndtype_dealloc(NdtObject *self)
 {
-    PyObject_GC_UnTrack(self);
-    ndt_del(NDT(self));
-    Py_CLEAR(self->rbuf);
+    ndt_decref(NDT(self));
     Py_TYPE(self)->tp_free(self);
 }
 
+static const ndt_t *
+from_string(PyObject *v)
+{
+    NDT_STATIC_CONTEXT(ctx);
+    const char *cp;
+    const ndt_t *t;
+
+    cp = PyUnicode_AsUTF8(v);
+    if (cp == NULL) {
+        return NULL;
+    }
+
+    t = ndt_from_string(cp, &ctx);
+    if (t == NULL) {
+        (void)seterr(&ctx);
+        return NULL;
+    }
+
+   return t;
+}
+
 static PyObject *
 ndtype_from_object(PyTypeObject *tp, PyObject *type)
 {
@@ -320,13 +254,7 @@ ndtype_from_object(PyTypeObject *tp, PyObject *type)
         return NULL;
     }
 
-    RBUF(self) = rbuf_alloc();
-    if (RBUF(self) == NULL) {
-        Py_DECREF(self);
-        return NULL;
-    }
-
-    NDT(self) = ndt_from_string_fill_meta(RBUF_NDT_META(self), cp, &ctx);
+    NDT(self) = ndt_from_string(cp, &ctx);
     if (NDT(self) == NULL) {
         Py_DECREF(self);
         return seterr(&ctx);
@@ -383,6 +311,7 @@ static PyObject *
 ndtype_from_offsets_and_dtype(PyTypeObject *tp, PyObject *offsets, PyObject *dtype)
 {
     NDT_STATIC_CONTEXT(ctx);
+    ndt_meta_t m = {.ndims = 0, .offsets = {NULL}};
     PyObject *self;
     const char *cp;
 
@@ -396,14 +325,43 @@ ndtype_from_offsets_and_dtype(PyTypeObject *tp, PyObject *offsets, PyObject *dty
         return NULL;
     }
 
-    RBUF(self) = rbuf_from_offset_lists(offsets);
-    if (RBUF(self) == NULL) {
+    if (offsets_from_list(&m, offsets) < 0) {
+        ndt_meta_clear(&m);
         Py_DECREF(self);
         return NULL;
     }
 
-    NDT(self) = ndt_from_metadata_and_dtype(RBUF_NDT_META(self), cp, &ctx);
+    NDT(self) = ndt_from_metadata_and_dtype(&m, cp, &ctx);
+    ndt_meta_clear(&m);
+    if (NDT(self) == NULL) {
+        Py_DECREF(self);
+        return seterr(&ctx);
+    }
+
+    return self;
+}
+
+static PyObject *
+ndtype_from_offsets_opt_and_dtype(PyTypeObject *tp, PyObject *offsets, bool *opt,
+                                  const ndt_t *dtype)
+{
+    NDT_STATIC_CONTEXT(ctx);
+    ndt_meta_t m = {.ndims = 0, .offsets = {NULL}};
+    PyObject *self;
+
+    self = ndtype_alloc(tp);
+    if (self == NULL) {
+        return NULL;
+    }
 
+    if (offsets_from_list(&m, offsets) < 0) {
+        ndt_meta_clear(&m);
+        Py_DECREF(self);
+        return NULL;
+    }
+
+    NDT(self) = ndt_from_metadata_opt_and_dtype(&m, opt, dtype, &ctx);
+    ndt_meta_clear(&m);
     if (NDT(self) == NULL) {
         Py_DECREF(self);
         return seterr(&ctx);
@@ -428,13 +386,7 @@ ndtype_deserialize(PyTypeObject *tp, PyObject *bytes)
         return NULL;
     }
 
-    RBUF(self) = rbuf_alloc();
-    if (RBUF(self) == NULL) {
-        Py_DECREF(self);
-        return NULL;
-    }
-
-    NDT(self) = ndt_deserialize(RBUF_NDT_META(self), PyBytes_AS_STRING(bytes),
+    NDT(self) = ndt_deserialize(PyBytes_AS_STRING(bytes),
                                 PyBytes_GET_SIZE(bytes), &ctx);
     if (NDT(self) == NULL) {
         Py_DECREF(self);
@@ -601,6 +553,7 @@ Ndtype_BoolFunc(ndt_is_complex)
 
 Ndtype_BoolFunc(ndt_is_c_contiguous)
 Ndtype_BoolFunc(ndt_is_f_contiguous)
+Ndtype_BoolFunc(ndt_is_var_contiguous)
 
 
 static PyObject *
@@ -628,13 +581,62 @@ static Py_hash_t
 ndtype_hash(PyObject *self)
 {
     NDT_STATIC_CONTEXT(ctx);
-    Py_hash_t res;
+    NdtObject *s = (NdtObject *)self;
 
-    res = ndt_hash(NDT(self), &ctx);
-    if (res == -1) {
-        (void)seterr(&ctx);
+    if (s->hash == -1) {
+        s->hash = ndt_hash(NDT(self), &ctx);
+        if (s->hash == -1) {
+            (void)seterr(&ctx);
+        }
+    }
+
+    return s->hash;
+}
+
+static PyObject *
+ndtype_at(PyObject *self, PyObject *args, PyObject *kwds)
+{
+    static char *kwlist[] = {"n", "dtype", NULL};
+    NDT_STATIC_CONTEXT(ctx);
+    PyObject *dtype = Py_None;
+    int n = 0;
+    PyObject *res;
+    const ndt_t *t;
+    const ndt_t *dt;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "i|O", kwlist, &n, &dtype)) {
+        return NULL; 
+    }
+
+    if (dtype == Py_None) {
+        dt = NULL;
+    }
+    else if (Ndt_Check(dtype)) {
+        dt = NDT(dtype);
+        ndt_incref(dt);
+    }
+    else if (PyUnicode_Check(dtype)) {
+        dt = from_string(dtype);
+        if (dt == NULL) {
+            return NULL;
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+            "dtype argument must be 'ndt' or 'str'");
+        return NULL;
+    }
+
+    t = ndt_copy_contiguous_at(NDT(self), n, dt, &ctx);
+    if (dt != NULL) {
+        ndt_decref(dt);
+    }
+    if (t == NULL) {
+        return seterr(&ctx);
     }
 
+    res = Ndt_FromType(t);
+    ndt_decref(t);
     return res;
 }
 
@@ -658,40 +660,178 @@ ndtype_match(PyObject *self, PyObject *other)
 }
 
 static PyObject *
-ndtype_apply(PyObject *self, PyObject *args)
+ndtype_unify(PyObject *self, PyObject *other)
 {
     NDT_STATIC_CONTEXT(ctx);
-    ndt_t *sig = NDT(self);
-    const ndt_t *in[NDT_MAX_ARGS];
-    ndt_apply_spec_t spec;
-    PyObject *flags = NULL, *out = NULL, *broadcast = NULL, *outer_dims = NULL;
-    PyObject *res = NULL;
-    Py_ssize_t nin;
-    Py_ssize_t i;
+    PyObject *u;
+    const ndt_t *t;
 
-    if (!PyTuple_Check(args) && !PyList_Check(args)) {
-        PyErr_SetString(PyExc_TypeError, "arguments must be a tuple or a list");
+    if (!Ndt_Check(other)) {
+        PyErr_SetString(PyExc_TypeError, "argument must be 'ndt'");
         return NULL;
     }
 
-    nin = PySequence_Fast_GET_SIZE(args);
-    if (nin > NDT_MAX_ARGS) {
-        PyErr_Format(PyExc_ValueError,
-            "maximum number of arguments is %d", NDT_MAX_ARGS);
+    t = ndt_unify(NDT(self), NDT(other), &ctx);
+    if (t == NULL) {
+        return seterr(&ctx);
+    }
+
+    u = Ndt_FromType(t);
+    ndt_decref(t);
+    return u;
+}
+
+static PyObject *
+get_item_with_error(PyObject *d, const char *key)
+{
+    PyObject *s, *v;
+
+    s = PyUnicode_FromString(key);
+    if (s == NULL) {
         return NULL;
     }
 
-    for (i = 0; i < nin; i++) {
-        PyObject *tmp = PySequence_Fast_GET_ITEM(args, i);
-        if (!Ndt_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "argument types must be ndt");
-            return NULL;
+    v = PyDict_GetItemWithError(d, s);
+    Py_DECREF(s);
+    return v;
+}
+
+static int
+parse_args(const ndt_t *types[NDT_MAX_ARGS], int *py_nin, int *py_nout, int *py_nargs,
+           PyObject *args, PyObject *kwargs)
+{
+    Py_ssize_t nin;
+    Py_ssize_t nout;
+
+    if (!args || !PyTuple_Check(args)) {
+        const char *tuple = args ? Py_TYPE(args)->tp_name : "NULL";
+        PyErr_Format(PyExc_SystemError,
+            "internal error: expected tuple, got '%.200s'",
+            tuple);
+        return -1;
+    }
+
+    if (kwargs && !PyDict_Check(kwargs)) {
+        PyErr_Format(PyExc_SystemError,
+            "internal error: expected dict, got '%.200s'",
+            Py_TYPE(kwargs)->tp_name);
+        return -1;
+    }
+
+    nin = PyTuple_GET_SIZE(args);
+    if (nin > NDT_MAX_ARGS) {
+        PyErr_Format(PyExc_TypeError,
+            "maximum number of arguments is %d, got %n", NDT_MAX_ARGS, nin);
+        return -1;
+    }
+
+    for (Py_ssize_t i = 0; i < nin; i++) {
+        PyObject *v = PyTuple_GET_ITEM(args, i);
+        if (!Ndt_Check(v)) {
+            PyErr_Format(PyExc_TypeError,
+                "expected ndt argument, got '%.200s'", Py_TYPE(v)->tp_name);
+            return -1;
         }
-        in[i] = CONST_NDT(tmp);
+
+        types[i] = NDT(v);
     }
 
-    spec = ndt_apply_spec_empty;
-    if (ndt_typecheck(&spec, sig, in, (int)nin, NULL, NULL, &ctx) < 0) {
+    if (kwargs == NULL || PyDict_Size(kwargs) == 0) {
+        nout = 0;
+    }
+    else if (PyDict_Size(kwargs) == 1) {
+        PyObject *out = get_item_with_error(kwargs, "out");
+        if (out == NULL) {
+            if (PyErr_Occurred()) {
+                return -1;
+            }
+            PyErr_SetString(PyExc_TypeError,
+                "the only supported keyword argument is 'out'");
+            return -1;
+        }
+
+        if (out == Py_None) {
+            nout = 0;
+        }
+        else if (Ndt_Check(out)) {
+            nout = 1;
+            if (nin+nout > NDT_MAX_ARGS) {
+                PyErr_Format(PyExc_TypeError,
+                    "maximum number of arguments is %d, got %n", NDT_MAX_ARGS, nin+nout);
+                return -1;
+            }
+
+            types[nin] = NDT(out);
+        }
+        else if (PyTuple_Check(out)) {
+            nout = PyTuple_GET_SIZE(out);
+            if (nout > NDT_MAX_ARGS || nin+nout > NDT_MAX_ARGS) {
+                PyErr_Format(PyExc_TypeError,
+                    "maximum number of arguments is %d, got %n", NDT_MAX_ARGS, nin+nout);
+                return -1;
+            }
+
+            for (Py_ssize_t i = 0; i < nout; i++) {
+                PyObject *v = PyTuple_GET_ITEM(out, i);
+                if (!Ndt_Check(v)) {
+                    PyErr_Format(PyExc_TypeError,
+                        "expected ndt argument, got '%.200s'", Py_TYPE(v)->tp_name);
+                    return -1;
+                }
+
+                types[nin+i] = NDT(v);
+            }
+        }
+        else {
+            PyErr_Format(PyExc_TypeError,
+                "'out' argument must be ndt or a tuple of ndt, got '%.200s'",
+                Py_TYPE(out)->tp_name);
+            return -1;
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+            "the only supported keyword argument is 'out'");
+        return -1;
+    }
+
+    for (int i = 0; i < nin+nout; i++) {
+        ndt_incref(types[i]);
+    }
+
+    *py_nin = (int)nin;
+    *py_nout = (int)nout;
+    *py_nargs = (int)nin+(int)nout;
+
+    return 0;
+}
+
+static PyObject *
+ndtype_apply(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    NDT_STATIC_CONTEXT(ctx);
+    const ndt_t *sig = NDT(self);
+    const ndt_t *types[NDT_MAX_ARGS] = {NULL};
+    const int64_t li[NDT_MAX_ARGS] = {0};
+    ndt_apply_spec_t spec = ndt_apply_spec_empty;
+    int py_nin, py_nout, py_nargs;
+    PyObject *res = NULL;
+    PyObject *flags = NULL;
+    PyObject *outer_dims = NULL;
+    PyObject *nin = NULL;
+    PyObject *nout = NULL;
+    PyObject *nargs = NULL;
+    PyObject *lst = NULL;
+    int ret;
+
+    if (parse_args(types, &py_nin, &py_nout, &py_nargs, args, kwargs) < 0) {
+        return NULL;
+    }
+
+    ret = ndt_typecheck(&spec, sig, types, li, py_nin, py_nout, false,
+                        NULL, NULL, &ctx);
+    ndt_type_array_clear(types, py_nargs);
+    if (ret < 0) {
         return seterr(&ctx);
     }
 
@@ -700,53 +840,52 @@ ndtype_apply(PyObject *self, PyObject *args)
         return NULL;
     }
 
-    out = PyList_New(spec.nout);
-    if (out == NULL) {
+    lst = PyList_New(spec.nargs);
+    if (lst == NULL) {
         ndt_apply_spec_clear(&spec);
         goto finish;
     }
 
-    for (i=spec.nout-1; i >= 0; i--) {
+    for (int i = 0; i < spec.nargs; i++) {
         PyObject *x = ndtype_alloc(&Ndt_Type);
         if (x == NULL) {
             ndt_apply_spec_clear(&spec);
             goto finish;
         }
-        NDT(x) = spec.out[i];
-        spec.out[i] = NULL; spec.nout--;
-        PyList_SET_ITEM(out, i, x);
+        NDT(x) = spec.types[i];
+        PyList_SET_ITEM(lst, i, x);
     }
 
-    broadcast = PyList_New(spec.nbroadcast);
-    if (broadcast == NULL) {
-        ndt_apply_spec_clear(&spec);
+    outer_dims = PyLong_FromLong(spec.outer_dims);
+    if (outer_dims == NULL) {
         goto finish;
     }
 
-    for (i=spec.nbroadcast-1; i >= 0; i--) {
-        PyObject *x = ndtype_alloc(&Ndt_Type);
-        if (x == NULL) {
-            ndt_apply_spec_clear(&spec);
-            goto finish;
-        }
-        NDT(x) = spec.broadcast[i];
-        spec.broadcast[i] = NULL; spec.nbroadcast--;
-        PyList_SET_ITEM(broadcast, i, x);
+    nin = PyLong_FromLong(spec.nin);
+    if (nin == NULL) {
+        goto finish;
     }
 
-    outer_dims = PyLong_FromLong(spec.outer_dims);
-    if (outer_dims == NULL) {
+    nout = PyLong_FromLong(spec.nout);
+    if (nout == NULL) {
+        goto finish;
+    }
+
+    nargs = PyLong_FromLong(spec.nargs);
+    if (nargs == NULL) {
         goto finish;
     }
 
-    res = PyObject_CallFunctionObjArgs((PyObject *)ApplySpec, flags, self,
-                                       args, broadcast, out, outer_dims, NULL);
+    res = PyObject_CallFunctionObjArgs((PyObject *)_ApplySpec, flags,
+                                       outer_dims, nin, nout, nargs, lst, NULL);
 
 finish:
     Py_XDECREF(flags);
-    Py_XDECREF(out);
-    Py_XDECREF(broadcast);
     Py_XDECREF(outer_dims);
+    Py_XDECREF(nin);
+    Py_XDECREF(nout);
+    Py_XDECREF(nargs);
+    Py_XDECREF(lst);
     return res;
 }
 
@@ -777,6 +916,7 @@ static PyObject *
 ndtype_ndim(PyObject *self, PyObject *args UNUSED)
 {
     const ndt_t *t = NDT(self);
+    int ldim;
 
     if (ndt_is_abstract(t)) {
         PyErr_SetString(PyExc_TypeError,
@@ -784,7 +924,8 @@ ndtype_ndim(PyObject *self, PyObject *args UNUSED)
         return NULL;
     }
 
-    return PyLong_FromLong(t->ndim);
+    ldim = ndt_logical_ndim(t);
+    return PyLong_FromLong(ldim);
 }
 
 static PyObject *
@@ -857,19 +998,8 @@ ndtype_strides(PyObject *self, PyObject *args UNUSED)
 static PyObject *
 ndtype_hidden_dtype(PyObject *self, PyObject *args UNUSED)
 {
-    NDT_STATIC_CONTEXT(ctx);
-    const ndt_t *t = NDT(self);
-    const ndt_t *dtype;
-    ndt_t *u;
-
-    dtype = ndt_hidden_dtype(t);
-
-    u = ndt_copy(dtype, &ctx); 
-    if (u == NULL) {
-        return seterr(&ctx);
-    }
-
-    return Ndt_FromType(u);
+    const ndt_t *dtype = ndt_hidden_dtype(NDT(self));
+    return Ndt_FromType(dtype);
 }
 
 static PyObject *
@@ -970,10 +1100,13 @@ static PyMethodDef ndtype_methods [] =
   /* Boolean functions on array types */
   { "is_c_contiguous", (PyCFunction)ndtype_ndt_is_c_contiguous, METH_NOARGS, doc_is_c_contiguous },
   { "is_f_contiguous", (PyCFunction)ndtype_ndt_is_f_contiguous, METH_NOARGS, doc_is_f_contiguous },
+  { "is_var_contiguous", (PyCFunction)dtype_ndt_is_var_contiguous, METH_NOARGS, NULL },
 
   /* Binary functions */
+  { "at", (PyCFunction)ndtype_at, METH_VARARGS|METH_KEYWORDS, NULL },
   { "match", (PyCFunction)ndtype_match, METH_O, doc_match },
-  { "apply", (PyCFunction)ndtype_apply, METH_O, "method likely to change" },
+  { "unify", (PyCFunction)ndtype_unify, METH_O, NULL },
+  { "apply", (PyCFunction)ndtype_apply, METH_VARARGS|METH_KEYWORDS, "method likely to change" },
 
   /* Other functions */
   { "to_format", (PyCFunction)ndtype_to_format, METH_NOARGS, NULL },
@@ -1005,14 +1138,12 @@ static PyTypeObject Ndt_Type =
     .tp_hash = ndtype_hash,
     .tp_str = (reprfunc) ndtype_str,
     .tp_getattro = (getattrofunc) PyObject_GenericGetAttr,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
-    .tp_traverse = (traverseproc)ndtype_traverse,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     .tp_richcompare = ndtype_richcompare,
     .tp_methods = ndtype_methods,
     .tp_getset = ndtype_getsets,
-    .tp_alloc = PyType_GenericAlloc,
     .tp_new = ndtype_new,
-    .tp_free = PyObject_GC_Del
+    .tp_free = PyObject_Del
 };
 
 
@@ -1034,13 +1165,6 @@ Ndt_Check(const PyObject *v)
     return PyObject_TypeCheck(v, &Ndt_Type);
 }
 
-static const ndt_t *
-CONST_NDT(const PyObject *v)
-{
-    assert(Ndt_Check(v));
-    return ((NdtObject *)v)->ndt;
-}
-
 static PyObject *
 Ndt_SetError(ndt_context_t *ctx)
 {
@@ -1048,67 +1172,18 @@ Ndt_SetError(ndt_context_t *ctx)
 }
 
 static PyObject *
-Ndt_CopySubtree(const PyObject *src, const ndt_t *t)
-{
-    NDT_STATIC_CONTEXT(ctx);
-    PyObject *dest;
-
-    if (!Ndt_Check(src)) {
-        PyErr_SetString(PyExc_TypeError, "expected ndt object");
-        return NULL;
-    }
-
-    dest = ndtype_alloc(Py_TYPE(src));
-    if (dest == NULL) {
-        return NULL;
-    }
-
-    NDT(dest) = ndt_copy(t, &ctx);
-    if (NDT(dest) == NULL) {
-        return seterr(&ctx);
-    }
-
-    RBUF(dest) = RBUF(src);
-    Py_XINCREF(RBUF(dest));
-
-    return dest;
-}
-
-static PyObject *
-Ndt_MoveSubtree(const PyObject *src, ndt_t *t)
-{
-    PyObject *dest;
-
-    if (!Ndt_Check(src)) {
-        PyErr_SetString(PyExc_TypeError, "expected ndt object");
-        return NULL;
-    }
-
-    dest = ndtype_alloc(Py_TYPE(src));
-    if (dest == NULL) {
-        ndt_del(t);
-        return NULL;
-    }
-
-    NDT(dest) = t;
-    RBUF(dest) = RBUF(src);
-    Py_XINCREF(RBUF(dest));
-
-    return dest;
-}
-
-static PyObject *
-Ndt_FromType(ndt_t *type)
+Ndt_FromType(const ndt_t *t)
 {
     PyObject *self;
 
     self = ndtype_alloc(&Ndt_Type);
     if (self == NULL) {
-        ndt_del(type);
         return NULL;
     }
 
-    NDT(self) = type;
+    ndt_incref(t);
+    NDT(self) = t;
+
     return self;
 }
 
@@ -1118,17 +1193,22 @@ Ndt_FromObject(PyObject *obj)
     return ndtype_from_object(&Ndt_Type, obj);
 }
 
+static PyObject *
+Ndt_FromOffsetsAndDtype(PyObject *offsets, bool *opt, const ndt_t *dtype)
+{
+    return ndtype_from_offsets_opt_and_dtype(&Ndt_Type, offsets, opt, dtype);
+}
+
+
 static PyObject *
 init_api(void)
 {
     ndtypes_api[Ndt_CheckExact_INDEX] = (void *)Ndt_CheckExact;
     ndtypes_api[Ndt_Check_INDEX] = (void *)Ndt_Check;
-    ndtypes_api[CONST_NDT_INDEX] = (void *)CONST_NDT;
     ndtypes_api[Ndt_SetError_INDEX] = (void *)Ndt_SetError;
-    ndtypes_api[Ndt_CopySubtree_INDEX] = (void *)Ndt_CopySubtree;
-    ndtypes_api[Ndt_MoveSubtree_INDEX] = (void *)Ndt_MoveSubtree;
     ndtypes_api[Ndt_FromType_INDEX] = (void *)Ndt_FromType;
     ndtypes_api[Ndt_FromObject_INDEX] = (void *)Ndt_FromObject;
+    ndtypes_api[Ndt_FromOffsetsAndDtype_INDEX] = (void *)Ndt_FromOffsetsAndDtype;
 
     return PyCapsule_New(ndtypes_api, "ndtypes._ndtypes._API", NULL);
 }
@@ -1145,7 +1225,8 @@ ndtype_typedef(PyObject *mod UNUSED, PyObject *args, PyObject *kwds)
     NDT_STATIC_CONTEXT(ctx);
     PyObject *name, *type;
     const char *cname, *ctype;
-    ndt_t *t;
+    const ndt_t *t;
+    int ret;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, &name, &type)) {
         return NULL;
@@ -1166,7 +1247,9 @@ ndtype_typedef(PyObject *mod UNUSED, PyObject *args, PyObject *kwds)
         return seterr(&ctx);
     }
 
-    if (ndt_typedef(cname, t, NULL, &ctx) < 0) {
+    ret = ndt_typedef(cname, t, NULL, &ctx);
+    ndt_decref(t);
+    if (ret < 0) {
         return seterr(&ctx);
     }
 
@@ -1179,9 +1262,10 @@ ndtype_instantiate(PyObject *mod UNUSED, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"name", "type", NULL};
     NDT_STATIC_CONTEXT(ctx);
     PyObject *name, *type;
+    PyObject *ret;
+    const ndt_t *t;
     const char *cname;
     char *cp;
-    ndt_t *t, *tp;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, &name, &type)) {
         return NULL;
@@ -1202,18 +1286,14 @@ ndtype_instantiate(PyObject *mod UNUSED, PyObject *args, PyObject *kwds)
         return seterr(&ctx);
     }
 
-    tp = ndt_copy(NDT(type), &ctx);
-    if (tp == NULL) {
-        ndt_free(cp);
-        return seterr(&ctx);
-    }
-
-    t = ndt_nominal(cp, tp, &ctx);
+    t = ndt_nominal(cp, NDT(type), false, &ctx);
     if (t == NULL) {
         return seterr(&ctx);
     }
 
-    return Ndt_MoveSubtree(type, t);
+    ret = Ndt_FromType(t);
+    ndt_decref(t);
+    return ret;
 }
 
 static PyMethodDef _ndtypes_methods [] =
@@ -1248,6 +1328,11 @@ PyInit__ndtypes(void)
     static int initialized = 0;
 
     if (!initialized) {
+        ndt_mallocfunc = PyMem_Malloc;
+        ndt_reallocfunc = PyMem_Realloc;
+        ndt_callocfunc = PyMem_Calloc;
+        ndt_freefunc = PyMem_Free;
+
         capsule = init_api();
         if (capsule == NULL) {
             return NULL;
@@ -1258,25 +1343,21 @@ PyInit__ndtypes(void)
         initialized = 1;
     }
 
-    if (PyType_Ready(&ResourceBuffer_Type) < 0) {
-        goto error;
-    }
-
     Ndt_Type.tp_base = &PyBaseObject_Type;
     if (PyType_Ready(&Ndt_Type) < 0) {
         goto error;
     }
 
-    /* ApplySpec */
+    /* _ApplySpec */
     collections = PyImport_ImportModule("collections");
     if (collections == NULL) {
         goto error;
     }
 
-    ApplySpec = (PyTypeObject *)PyObject_CallMethod(collections,
+    _ApplySpec = (PyTypeObject *)PyObject_CallMethod(collections,
                                     "namedtuple", "(ss)", "ApplySpec",
-                                    "flags sig in_types in_broadcast out_types outer_dims");
-    if (ApplySpec == NULL) {
+                                    "flags outer_dims nin nout nargs types");
+    if (_ApplySpec == NULL) {
         goto error;
     }
 
@@ -1285,7 +1366,7 @@ PyInit__ndtypes(void)
         goto error;
     }
 
-    if (PyDict_SetItemString(ApplySpec->tp_dict, "__module__", obj) < 0) {
+    if (PyDict_SetItemString(_ApplySpec->tp_dict, "__module__", obj) < 0) {
         goto error;
     }
     Py_CLEAR(obj);
@@ -1306,8 +1387,8 @@ PyInit__ndtypes(void)
         goto error;
     }
 
-    Py_INCREF(ApplySpec);
-    if (PyModule_AddObject(m, "ApplySpec", (PyObject *)ApplySpec) < 0) {
+    Py_INCREF(_ApplySpec);
+    if (PyModule_AddObject(m, "_ApplySpec", (PyObject *)_ApplySpec) < 0) {
         goto error;
     }