ndtypes 0.2.0dev5 → 0.2.0dev6

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

@@ -31,6 +31,10 @@
  */
 
 
+#ifdef _MSC_VER
+  #include <windows.h>
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
@@ -54,6 +58,12 @@ max(uint16_t x, uint16_t y)
     return x >= y ? x : y;
 }
 
+static inline int64_t
+max_i64(int64_t x, int64_t y)
+{
+    return x >= y ? x : y;
+}
+
 static inline int
 ispower2(uint16_t n)
 {
@@ -79,11 +89,29 @@ round_up(int64_t offset, uint16_t align, bool *overflow)
 static uint32_t
 ndt_subtree_flags(const ndt_t *type)
 {
-    if (type && type->flags & (NDT_OPTION|NDT_SUBTREE_OPTION)) {
-        return NDT_SUBTREE_OPTION;
+    uint32_t flags = 0U;
+
+    if (type == NULL) {
+        return flags;
     }
 
-    return 0;
+    if (type->flags & (NDT_OPTION|NDT_SUBTREE_OPTION)) {
+        flags |= NDT_SUBTREE_OPTION;
+    }
+
+    if (type->flags & NDT_POINTER) {
+        flags |= NDT_POINTER;
+    }
+
+    if (type->flags & NDT_REF) {
+        flags |= NDT_REF;
+    }
+
+    if (type->flags & NDT_CHAR) {
+        flags |= NDT_CHAR;
+    }
+
+    return flags;
 }
 
 /* Determine general subtree and ellipsis flags. */
@@ -109,7 +137,7 @@ ndt_itemsize(const ndt_t *t)
     switch (t->tag) {
     case FixedDim:
         return t->Concrete.FixedDim.itemsize;
-    case VarDim:
+    case VarDim: case VarDimElem:
         return t->Concrete.VarDim.itemsize;
     default:
         return t->datasize;
@@ -121,6 +149,38 @@ ndt_itemsize(const ndt_t *t)
 /*                                Predicates                                 */
 /*****************************************************************************/
 
+bool
+ndt_is_static(const ndt_t *t)
+{
+    switch (t->tag) {
+    case String:
+    case Bool:
+    case SignedKind: case Int8: case Int16: case Int32: case Int64:
+    case UnsignedKind: case Uint8: case Uint16: case Uint32: case Uint64:
+    case FloatKind: case BFloat16: case Float16: case Float32: case Float64:
+    case ComplexKind: case BComplex32: case Complex32: case Complex64: case Complex128:
+        return true;
+    default:
+        return false;
+    }
+}
+
+bool
+ndt_is_static_tag(enum ndt tag)
+{
+    switch (tag) {
+    case String:
+    case Bool:
+    case SignedKind: case Int8: case Int16: case Int32: case Int64:
+    case UnsignedKind: case Uint8: case Uint16: case Uint32: case Uint64:
+    case FloatKind: case BFloat16: case Float16: case Float32: case Float64:
+    case ComplexKind: case BComplex32: case Complex32: case Complex64: case Complex128:
+        return true;
+    default:
+        return false;
+    }
+}
+
 /* Type field access */
 int
 ndt_is_abstract(const ndt_t *t)
@@ -147,6 +207,18 @@ ndt_subtree_is_optional(const ndt_t *t)
     return t->flags & NDT_SUBTREE_OPTION;
 }
 
+int
+ndt_is_pointer_free(const ndt_t *t)
+{
+    return !(t->flags & NDT_POINTER);
+}
+
+int
+ndt_is_ref_free(const ndt_t *t)
+{
+    return !(t->flags & NDT_REF);
+}
+
 /* Array predicates */
 int
 ndt_is_ndarray(const ndt_t *t)
@@ -222,6 +294,44 @@ ndt_is_f_contiguous(const ndt_t *t)
     return 1;
 }
 
+static int
+_is_var_contiguous(const ndt_t *t, int32_t nitems)
+{
+    if (t->ndim == 0) {
+        return 1;
+    }
+
+    switch (t->tag) {
+    case VarDim: {
+        const int32_t noffsets = t->Concrete.VarDim.offsets->n;
+        const int32_t *offsets = t->Concrete.VarDim.offsets->v;
+
+        if (noffsets != nitems+1) {
+            return 0;
+        }
+
+        if (t->Concrete.VarDim.nslices != 0 ||
+            t->Concrete.VarDim.slices != NULL) {
+            return 0;
+        }
+
+        return _is_var_contiguous(t->VarDim.type, offsets[noffsets-1]);
+    }
+    default:
+        return 0;
+    }
+}
+
+int
+ndt_is_var_contiguous(const ndt_t *t)
+{
+    if (ndt_is_abstract(t)) {
+        return 0;
+    }
+
+    return _is_var_contiguous(t, 1);
+}
+
 int
 ndt_really_fortran(const ndt_t *t)
 {
@@ -236,8 +346,8 @@ ndt_is_scalar(const ndt_t *t)
     case Bool:
     case Int8: case Int16: case Int32: case Int64:
     case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
+    case BFloat16: case Float16: case Float32: case Float64:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
     case FixedString: case FixedBytes:
     case String: case Bytes:
     case Char:
@@ -274,7 +384,7 @@ int
 ndt_is_float(const ndt_t *t)
 {
     switch (t->tag) {
-    case Float16: case Float32: case Float64:
+    case BFloat16: case Float16: case Float32: case Float64:
         return 1;
     default:
         return 0;
@@ -285,7 +395,7 @@ int
 ndt_is_complex(const ndt_t *t)
 {
     switch (t->tag) {
-    case Complex32: case Complex64: case Complex128:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
         return 1;
     default:
         return 0;
@@ -304,8 +414,8 @@ ndt_is_little_endian(const ndt_t *t)
     switch (t->tag) {
     case Int8: case Int16: case Int32: case Int64:
     case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
+    case BFloat16: case Float16: case Float32: case Float64:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
         if (t->flags & NDT_LITTLE_ENDIAN) {
             return 1;
         }
@@ -324,8 +434,8 @@ ndt_is_big_endian(const ndt_t *t)
     switch (t->tag) {
     case Int16: case Int32: case Int64:
     case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
+    case BFloat16: case Float16: case Float32: case Float64:
+    case BComplex32: case Complex32: case Complex64: case Complex128:
         if (t->flags & NDT_BIG_ENDIAN) {
             return 1;
         }
@@ -449,7 +559,7 @@ get_align(uint16_opt_t align, uint16_t default_align, ndt_context_t *ctx)
  * 'name' is NULL for a tuple field.
  */
 ndt_field_t *
-ndt_field(char *name, ndt_t *type, uint16_opt_t align, uint16_opt_t pack,
+ndt_field(char *name, const ndt_t *type, uint16_opt_t align, uint16_opt_t pack,
           uint16_opt_t pad, ndt_context_t *ctx)
 {
     ndt_field_t *field;
@@ -462,7 +572,6 @@ ndt_field(char *name, ndt_t *type, uint16_opt_t align, uint16_opt_t pack,
     min_align = min_field_align(type, align, pack, ctx);
     if (min_align == UINT16_MAX) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
@@ -470,10 +579,11 @@ ndt_field(char *name, ndt_t *type, uint16_opt_t align, uint16_opt_t pack,
     field = ndt_alloc_size(sizeof *field);
     if (field == NULL) {
         ndt_free(name);
-        ndt_del(type);
         return ndt_memory_error(ctx);
     }
     field->name = name;
+
+    ndt_incref(type);
     field->type = type;
 
     /* concrete access */
@@ -493,7 +603,7 @@ ndt_field_del(ndt_field_t *field)
 {
     if (field) {
         ndt_free(field->name);
-        ndt_del(field->type);
+        ndt_decref(field->type);
         ndt_free(field);
     }
 }
@@ -509,14 +619,14 @@ ndt_field_array_del(ndt_field_t *fields, int64_t shape)
 
     for (i = 0; i < shape; i++) {
         ndt_free(fields[i].name);
-        ndt_del(fields[i].type);
+        ndt_decref(fields[i].type);
     }
 
     ndt_free(fields);
 }
 
 void
-ndt_type_array_clear(ndt_t **types, int64_t shape)
+ndt_type_array_clear(const ndt_t **types, int64_t shape)
 {
     int64_t i;
 
@@ -525,15 +635,15 @@ ndt_type_array_clear(ndt_t **types, int64_t shape)
     }
 
     for (i = 0; i < shape; i++) {
-        ndt_del(types[i]);
+        ndt_decref(types[i]);
     }
 }
 
 void
-ndt_type_array_del(ndt_t **types, int64_t shape)
+ndt_type_array_del(const ndt_t **types, int64_t shape)
 {
     ndt_type_array_clear(types, shape);
-    ndt_free(types);
+    ndt_free((void *)types);
 }
 
 
@@ -542,35 +652,29 @@ ndt_type_array_del(ndt_t **types, int64_t shape)
 /*****************************************************************************/
 
 /*
- * Add a typedef name -> type to the symbol table.  Steals the 'type'
- * reference.
+ * Add a typedef name -> type to the symbol table.
  */
 int
-ndt_typedef(const char *name, ndt_t *type, const ndt_methods_t *m, ndt_context_t *ctx)
+ndt_typedef(const char *name, const ndt_t *type, const ndt_methods_t *m, ndt_context_t *ctx)
 {
-    if (ndt_typedef_add(name, type, m, ctx) < 0) {
-        return -1;
-    }
-
-    return 0;
+    return ndt_typedef_add(name, type, m, ctx);
 }
 
 int
 ndt_typedef_from_string(const char *name, const char *type, const ndt_methods_t *m,
                         ndt_context_t *ctx)
 {
-    ndt_t *t;
+    const ndt_t *t;
+    int ret;
 
     t = ndt_from_string(type, ctx);
     if (t == NULL) {
         return -1;
     }
 
-    if (ndt_typedef_add(name, t, m, ctx) < 0) {
-        return -1;
-    }
-
-    return 0;
+    ret = ndt_typedef_add(name, t, m, ctx);
+    ndt_decref(t);
+    return ret;
 }
 
 
@@ -578,7 +682,7 @@ ndt_typedef_from_string(const char *name, const char *type, const ndt_methods_t
 /*                              Type invariants                               */
 /******************************************************************************/
 
-/* Invariants for all types except for var and ellipsis dimensions. */
+/* Invariants for all types except for dimensions. */
 static int
 check_type_invariants(const ndt_t *type, ndt_context_t *ctx)
 {
@@ -588,9 +692,29 @@ check_type_invariants(const ndt_t *type, ndt_context_t *ctx)
         return 0;
     }
 
-    if (type->tag == VarDim) {
+    if (type->ndim >= NDT_MAX_DIM) {
+        ndt_err_format(ctx, NDT_TypeError, "ndim > %d", NDT_MAX_DIM);
+        return 0;
+    }
+
+    return 1;
+}
+
+/* Invariants for fixed dimensions. */
+static int
+check_fixed_invariants(const ndt_t *type, ndt_context_t *ctx)
+{
+    if (type->tag == Module) {
         ndt_err_format(ctx, NDT_TypeError,
-            "nested or non-uniform var dimensions are not supported");
+            "nested module types are not supported");
+        return 0;
+    }
+
+    if (type->tag == VarDim || type->tag == VarDimElem ||
+        type->tag == Array) {
+        ndt_err_format(ctx, NDT_TypeError,
+            "fixed dimensions cannot contain var dimensions "
+            "or flexible arrays");
         return 0;
     }
 
@@ -612,13 +736,16 @@ check_abstract_var_invariants(const ndt_t *type, ndt_context_t *ctx)
         return 0;
     }
 
-    if (type->tag == FixedDim || type->tag == SymbolicDim) {
+    if (type->tag == FixedDim || type->tag == SymbolicDim ||
+        type->tag == Array) {
         ndt_err_format(ctx, NDT_TypeError,
-            "mixed fixed and var dim are not supported");
+            "var dimensions cannot contain fixed dimensions or "
+            "flexible arrays");
         return 0;
     }
 
-    if (type->tag == VarDim && ndt_is_concrete(type)) {
+    if ((type->tag == VarDim && ndt_is_concrete(type)) ||
+        type->tag == VarDimElem) {
         ndt_err_format(ctx, NDT_TypeError,
             "mixing abstract and concrete var dimensions is not allowed");
         return 0;
@@ -634,7 +761,7 @@ check_abstract_var_invariants(const ndt_t *type, ndt_context_t *ctx)
 
 /* Invariants for concrete var dimensions. */
 static int
-check_var_invariants(enum ndt_offsets flag, const ndt_t *type, ndt_context_t *ctx)
+check_var_invariants(const ndt_t *type, ndt_context_t *ctx)
 {
     if (type->tag == Module) {
         ndt_err_format(ctx, NDT_TypeError,
@@ -642,23 +769,20 @@ check_var_invariants(enum ndt_offsets flag, const ndt_t *type, ndt_context_t *ct
         return 0;
     }
 
-    if (type->tag == FixedDim || type->tag == SymbolicDim) {
+    if (type->tag == FixedDim || type->tag == SymbolicDim ||
+        type->tag == Array) {
         ndt_err_format(ctx, NDT_TypeError,
-            "mixed fixed and var dim are not supported");
+            "var dimensions cannot contain fixed dimensions or "
+            "flexible arrays");
         return 0;
     }
 
-    if (type->tag == VarDim) {
+    if (type->tag == VarDim || type->tag == VarDimElem) {
         if (ndt_is_abstract(type)) {
             ndt_err_format(ctx, NDT_TypeError,
                 "mixing abstract and concrete var dimensions is not allowed");
             return 0;
         }
-        if (flag != type->Concrete.VarDim.flag) {
-            ndt_err_format(ctx, NDT_TypeError,
-                "mixing internal and external offsets is not allowed");
-            return 0;
-        }
     }
 
     if (type->ndim >= NDT_MAX_DIM) {
@@ -669,6 +793,32 @@ check_var_invariants(enum ndt_offsets flag, const ndt_t *type, ndt_context_t *ct
     return 1;
 }
 
+/* Invariants for array dimensions. */
+static int
+check_array_invariants(const ndt_t *type, ndt_context_t *ctx)
+{
+    if (type->tag == Module) {
+        ndt_err_format(ctx, NDT_TypeError,
+            "nested module types are not supported");
+        return 0;
+    }
+
+    if (type->tag == FixedDim || type->tag == SymbolicDim ||
+        type->tag == VarDim || type->tag == VarDimElem) {
+        ndt_err_format(ctx, NDT_TypeError,
+            "cannot mix fixed or var dimensions with flexible arrays");
+        return 0;
+    }
+
+    if (!ndt_is_ref_free(type)) {
+        ndt_err_format(ctx, NDT_TypeError,
+            "flexible array elements cannot be contain references");
+        return 0;
+    }
+
+    return 1;
+}
+
 /* Invariants for ellipsis dimensions. */
 static int
 check_ellipsis_invariants(const ndt_t *type, ndt_context_t *ctx)
@@ -697,7 +847,7 @@ strcmp_null(const char *s, const char *t)
 }
 
 static int
-check_function_invariants(ndt_t * const *types, int64_t nin, int64_t nargs,
+check_function_invariants(const ndt_t **types, int64_t nin, int64_t nargs,
                           ndt_context_t *ctx)
 {
     int64_t count = 0;
@@ -746,7 +896,7 @@ error:
 }
 
 static bool
-is_elemwise(ndt_t * const *types, int64_t nargs)
+is_elemwise(const ndt_t **types, int64_t nargs)
 {
     for (int64_t i = 0; i < nargs; i++) {
         if ((types[i]->ndim == 1 && types[i]->tag == EllipsisDim) ||
@@ -765,7 +915,7 @@ is_elemwise(ndt_t * const *types, int64_t nargs)
 /******************************************************************************/
 
 ndt_t *
-ndt_new(enum ndt tag, ndt_context_t *ctx)
+ndt_new(enum ndt tag, uint32_t flags, ndt_context_t *ctx)
 {
     ndt_t *t;
 
@@ -776,17 +926,19 @@ ndt_new(enum ndt tag, ndt_context_t *ctx)
 
     t->tag = tag;
     t->access = Abstract;
-    t->flags = 0;
+    t->flags = flags;
     t->ndim = 0;
 
     t->datasize = 0;
     t->align = UINT16_MAX;
 
+    t->refcnt = 1;
+
     return t;
 }
 
 static ndt_t *
-ndt_new_extra(enum ndt tag, int64_t n, ndt_context_t *ctx)
+ndt_new_extra(enum ndt tag, int64_t n, uint32_t flags, ndt_context_t *ctx)
 {
     bool overflow = 0;
     ndt_t *t;
@@ -805,12 +957,14 @@ ndt_new_extra(enum ndt tag, int64_t n, ndt_context_t *ctx)
 
     t->tag = tag;
     t->access = Abstract;
-    t->flags = 0;
+    t->flags = flags;
     t->ndim = 0;
 
     t->datasize = 0;
     t->align = UINT16_MAX;
 
+    t->refcnt = 1;
+
     return t;
 }
 
@@ -828,12 +982,12 @@ ndt_function_new(int64_t nargs, ndt_context_t *ctx)
         return NULL;
     }
 
-    t = ndt_new_extra(Function, extra, ctx);
+    t = ndt_new_extra(Function, extra, 0, ctx);
     if (t == NULL) {
         return NULL;
     }
     t->Function.nargs = nargs;
-    t->Function.types = (ndt_t **)t->extra;
+    t->Function.types = (const ndt_t **)t->extra;
 
     for (i = 0; i < nargs; i++) {
         t->Function.types[i] = NULL;
@@ -843,7 +997,7 @@ ndt_function_new(int64_t nargs, ndt_context_t *ctx)
 }
 
 ndt_t *
-ndt_tuple_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
+ndt_tuple_new(enum ndt_variadic flag, int64_t shape, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t = NULL;
     bool overflow = 0;
@@ -870,14 +1024,14 @@ ndt_tuple_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
         return NULL;
     }
 
-    t = ndt_new_extra(Tuple, extra, ctx);
+    t = ndt_new_extra(Tuple, extra, opt, ctx);
     if (t == NULL) {
         return NULL;
     }
 
     t->Tuple.flag = flag;
     t->Tuple.shape = shape;
-    t->Tuple.types = (ndt_t **)t->extra;
+    t->Tuple.types = (const ndt_t **)t->extra;
     t->Concrete.Tuple.offset = (int64_t *)(t->extra + offset_offset);
     t->Concrete.Tuple.align = (uint16_t *)(t->extra + align_offset);
     t->Concrete.Tuple.pad = (uint16_t *)(t->extra + pad_offset);
@@ -893,7 +1047,7 @@ ndt_tuple_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
 }
 
 ndt_t *
-ndt_record_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
+ndt_record_new(enum ndt_variadic flag, int64_t shape, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t = NULL;
     bool overflow = 0;
@@ -923,7 +1077,7 @@ ndt_record_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
         return NULL;
     }
 
-    t = ndt_new_extra(Record, extra, ctx);
+    t = ndt_new_extra(Record, extra, opt, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -931,7 +1085,7 @@ ndt_record_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
     t->Record.flag = flag;
     t->Record.shape = shape;
     t->Record.names = (char **)t->extra;
-    t->Record.types = (ndt_t **)(t->extra + types_offset);
+    t->Record.types = (const ndt_t **)(t->extra + types_offset);
     t->Concrete.Record.offset = (int64_t *)(t->extra + offset_offset);
     t->Concrete.Record.align = (uint16_t *)(t->extra + align_offset);
     t->Concrete.Record.pad = (uint16_t *)(t->extra + pad_offset);
@@ -947,7 +1101,41 @@ ndt_record_new(enum ndt_variadic flag, int64_t shape, ndt_context_t *ctx)
     return t;
 }
 
-void
+ndt_t *
+ndt_union_new(int64_t ntags, bool opt, ndt_context_t *ctx)
+{
+    ndt_t *t = NULL;
+    bool overflow = 0;
+    int64_t extra;
+    int64_t types_offset;
+    int64_t i;
+
+    types_offset = MULi64(ntags, sizeof(char *), &overflow);
+    extra = MULi64(2, types_offset, &overflow);
+
+    if (overflow) {
+        ndt_err_format(ctx, NDT_ValueError, "union size too large");
+        return NULL;
+    }
+
+    t = ndt_new_extra(Union, extra, opt, ctx);
+    if (t == NULL) {
+        return NULL;
+    }
+
+    t->Union.ntags = ntags;
+    t->Union.tags = (char **)t->extra;
+    t->Union.types = (const ndt_t **)(t->extra + types_offset);
+
+    for (i = 0; i < ntags; i++) {
+        t->Union.tags[i] = NULL;
+        t->Union.types[i] = NULL;
+    }
+
+    return t;
+}
+
+static void
 ndt_del(ndt_t *t)
 {
     if (t == NULL) {
@@ -957,29 +1145,27 @@ ndt_del(ndt_t *t)
     switch (t->tag) {
     case Module: {
         ndt_free(t->Module.name);
-        ndt_del(t->Module.type);
+        ndt_decref(t->Module.type);
         goto free_type;
     }
 
     case Function: {
         int64_t i;
         for (i = 0; i < t->Function.nargs; i++) {
-            ndt_del(t->Function.types[i]);
+            ndt_decref(t->Function.types[i]);
         }
         goto free_type;
     }
 
     case FixedDim: {
-        ndt_del(t->FixedDim.type);
+        ndt_decref(t->FixedDim.type);
         goto free_type;
     }
 
-    case VarDim: {
-        ndt_del(t->VarDim.type);
+    case VarDim: case VarDimElem: {
+        ndt_decref(t->VarDim.type);
         if (ndt_is_concrete(t)) {
-            if (t->Concrete.VarDim.flag == InternalOffsets) {
-                ndt_free((int32_t *)t->Concrete.VarDim.offsets);
-            }
+            ndt_decref_offsets(t->Concrete.VarDim.offsets);
             ndt_free(t->Concrete.VarDim.slices);
         }
         goto free_type;
@@ -987,20 +1173,25 @@ ndt_del(ndt_t *t)
 
     case SymbolicDim: {
         ndt_free(t->SymbolicDim.name);
-        ndt_del(t->SymbolicDim.type);
+        ndt_decref(t->SymbolicDim.type);
         goto free_type;
     }
 
     case EllipsisDim: {
         ndt_free(t->EllipsisDim.name);
-        ndt_del(t->EllipsisDim.type);
+        ndt_decref(t->EllipsisDim.type);
+        goto free_type;
+    }
+
+    case Array: {
+        ndt_decref(t->Array.type);
         goto free_type;
     }
 
     case Tuple: {
         int64_t i;
         for (i = 0; i < t->Tuple.shape; i++) {
-            ndt_del(t->Tuple.types[i]);
+            ndt_decref(t->Tuple.types[i]);
         }
         goto free_type;
     }
@@ -1009,25 +1200,34 @@ ndt_del(ndt_t *t)
         int64_t i;
         for (i = 0; i < t->Record.shape; i++) {
             ndt_free(t->Record.names[i]);
-            ndt_del(t->Record.types[i]);
+            ndt_decref(t->Record.types[i]);
+        }
+        goto free_type;
+    }
+
+    case Union: {
+        int64_t i;
+        for (i = 0; i < t->Union.ntags; i++) {
+            ndt_free(t->Union.tags[i]);
+            ndt_decref(t->Union.types[i]);
         }
         goto free_type;
     }
 
     case Ref: {
-        ndt_del(t->Ref.type);
+        ndt_decref(t->Ref.type);
         goto free_type;
     }
 
     case Constr: {
         ndt_free(t->Constr.name);
-        ndt_del(t->Constr.type);
+        ndt_decref(t->Constr.type);
         goto free_type;
     }
 
     case Nominal: {
         ndt_free(t->Nominal.name);
-        ndt_del(t->Nominal.type);
+        ndt_decref(t->Nominal.type);
         goto free_type;
     }
 
@@ -1044,17 +1244,16 @@ ndt_del(ndt_t *t)
     case AnyKind: case ScalarKind:
     case FixedStringKind: case FixedString:
     case FixedBytesKind: case FixedBytes:
-    case String: case Bytes: case Char:
-    case Bool:
-    case SignedKind:
-    case Int8: case Int16: case Int32: case Int64:
-    case UnsignedKind:
-    case Uint8: case Uint16: case Uint32: case Uint64:
-    case FloatKind:
-    case Float16: case Float32: case Float64:
-    case ComplexKind:
-    case Complex32: case Complex64: case Complex128:
+    case Bytes: case Char:
         goto free_type;
+
+    case String:
+    case Bool:
+    case SignedKind: case Int8: case Int16: case Int32: case Int64:
+    case UnsignedKind: case Uint8: case Uint16: case Uint32: case Uint64:
+    case FloatKind: case BFloat16: case Float16: case Float32: case Float64:
+    case ComplexKind: case BComplex32: case Complex32: case Complex64: case Complex128:
+        return;
     }
 
     /* NOT REACHED: tags should be exhaustive. */
@@ -1065,43 +1264,150 @@ free_type:
     ndt_free(t);
 }
 
+void
+ndt_incref(const ndt_t *t)
+{
+    if (ndt_is_static(t)) {
+        return;
+    }
 
-/******************************************************************************/
-/*                               Type functions                               */
-/******************************************************************************/
+    ndt_t *u = (ndt_t *)t;
+#ifdef _MSC_VER
+    (void)InterlockedIncrement64(&u->refcnt);
+#else
+    ++u->refcnt;
+#endif
+}
 
-/* Set the option flag of a type */
-ndt_t *
-ndt_option(ndt_t *t)
+void
+ndt_decref(const ndt_t *t)
 {
-    t->flags |= NDT_OPTION;
-    return t;
+    if (t == NULL || ndt_is_static(t)) {
+        return;
+    }
+
+    ndt_t *u = (ndt_t *)t;
+#ifdef _MSC_VER
+    if (InterlockedDecrement64(&u->refcnt) == 0) {
+        ndt_del(u);
+    }
+#else
+    if (--u->refcnt == 0) {
+        ndt_del(u);
+    }
+#endif
 }
 
+void
+ndt_move(const ndt_t **dst, const ndt_t *src)
+{
+    ndt_decref(*dst);
+    *dst = src;
+}
+
+
+ndt_offsets_t *
+ndt_offsets_new(int32_t size, ndt_context_t  *ctx)
+{
+    ndt_offsets_t *offsets;
+
+    offsets = ndt_alloc(1, sizeof *offsets);
+    if (offsets == NULL) {
+        return ndt_memory_error(ctx);
+    }
+
+    offsets->v = ndt_calloc(size, sizeof *offsets->v);
+    if (offsets->v == NULL) {
+        ndt_free(offsets);
+        return ndt_memory_error(ctx);
+    }
+
+    offsets->refcnt = 1;
+    offsets->n = size;
+
+    return offsets;
+}
+ 
+ndt_offsets_t *
+ndt_offsets_from_ptr(int32_t *ptr, int32_t size, ndt_context_t  *ctx)
+{
+    ndt_offsets_t *offsets;
+
+    offsets = ndt_alloc(1, sizeof *offsets);
+    if (offsets == NULL) {
+        ndt_free(ptr);
+        return ndt_memory_error(ctx);
+    }
+    offsets->refcnt = 1;
+    offsets->n = size;
+    offsets->v = ptr;
+
+    return offsets;
+}
+ 
+void
+ndt_incref_offsets(const ndt_offsets_t *x)
+{
+    ndt_offsets_t *offsets = (ndt_offsets_t *)x;
+#ifdef _MSC_VER
+    (void)InterlockedIncrement64(&offsets->refcnt);
+#else
+    ++offsets->refcnt;
+#endif
+}
+
+void
+ndt_decref_offsets(const ndt_offsets_t *x)
+{
+    ndt_offsets_t *offsets = (ndt_offsets_t *)x;
+
+    if (offsets == NULL) {
+        return;
+    }
+
+#ifdef _MSC_VER
+    if (InterlockedDecrement64(&offsets->refcnt) == 0) {
+        ndt_free((void *)offsets->v);
+        ndt_free(offsets);
+    }
+#else
+    if (--offsets->refcnt == 0) {
+        ndt_free((void *)offsets->v);
+        ndt_free(offsets);
+    }
+#endif
+}
+
+
+/******************************************************************************/
+/*                               Type functions                               */
+/******************************************************************************/
+
 /* Abstract namespace type */
-ndt_t *
-ndt_module(char *name, ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_module(char *name, const ndt_t *type, ndt_context_t *ctx)
 {
     ndt_t *t;
 
-    t = ndt_new(Module, ctx);
+    t = ndt_new(Module, 0, ctx);
     if (t == NULL) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
+    ndt_incref(type);
+
     /* abstract type */
     t->Module.name = name;
     t->Module.type = type;
-    t->flags = ndt_subtree_flags(type);
+    t->flags |= ndt_subtree_flags(type);
 
     return t;
 }
 
 /* Abstract function signatures */
-ndt_t *
-ndt_function(ndt_t * const *types, int64_t nargs, int64_t nin, int64_t nout,
+const ndt_t *
+ndt_function(const ndt_t **types, int64_t nargs, int64_t nin, int64_t nout,
              ndt_context_t *ctx)
 {
     ndt_t *t;
@@ -1110,16 +1416,12 @@ ndt_function(ndt_t * const *types, int64_t nargs, int64_t nin, int64_t nout,
     assert(0 <= nin && 0 <= nout && nargs == nin+nout);
 
     if (!check_function_invariants(types, nin, nargs, ctx)) {
-        ndt_type_array_clear((ndt_t **)types, nargs);
         return NULL;
     }
 
     /* abstract type */
     t = ndt_function_new(nargs, ctx);
     if (t == NULL) {
-        for (i = 0; i < nargs; i++) {
-            ndt_del(types[i]);
-        }
         return NULL;
     }
     t->Function.elemwise = is_elemwise(types, nargs);
@@ -1127,6 +1429,7 @@ ndt_function(ndt_t * const *types, int64_t nargs, int64_t nin, int64_t nout,
     t->Function.nout = nout;
 
     for (i = 0; i < nargs; i++) {
+        ndt_incref(types[i]);
         t->Function.types[i] = types[i];
         t->flags |= ndt_dim_flags(types[i]);
     }
@@ -1134,10 +1437,10 @@ ndt_function(ndt_t * const *types, int64_t nargs, int64_t nin, int64_t nout,
     return t;
 }
 
-ndt_t *
-ndt_any_kind(ndt_context_t *ctx)
+const ndt_t *
+ndt_any_kind(bool opt, ndt_context_t *ctx)
 {
-    return ndt_new(AnyKind, ctx);
+    return ndt_new(AnyKind, opt, ctx);
 }
 
 
@@ -1150,10 +1453,12 @@ ndt_any_kind(ndt_context_t *ctx)
  * is assumed to be either a dtype with ndim==0 or a FixedDim.
  */
 static inline int64_t
-fixed_step(ndt_t *type, int64_t step, bool *overflow)
+fixed_step(const ndt_t *type, int64_t step, bool *overflow)
 {
     assert(ndt_is_concrete(type));
     assert(type->tag != VarDim);
+    assert(type->tag != VarDimElem);
+    assert(type->tag != Array);
 
     if (step != INT64_MAX) {
         return step;
@@ -1175,7 +1480,7 @@ fixed_step(ndt_t *type, int64_t step, bool *overflow)
 }
 
 static inline int64_t
-fixed_datasize(ndt_t *type, int64_t shape, int64_t step, int64_t itemsize,
+fixed_datasize(const ndt_t *type, int64_t shape, int64_t step, int64_t itemsize,
                bool *overflow)
 {
     int64_t index_range;
@@ -1191,16 +1496,18 @@ fixed_datasize(ndt_t *type, int64_t shape, int64_t step, int64_t itemsize,
     datasize = MULi64(index_range, itemsize, overflow);
     return ADDi64(datasize, type->datasize, overflow);
 }
- 
-static ndt_t *
+
+static const ndt_t *
 _ndt_to_fortran(const ndt_t *t, int64_t step, ndt_context_t *ctx)
 {
     bool overflow = 0;
-    ndt_t *dt;
+    const ndt_t *u;
+    const ndt_t *dt;
     int64_t next_step;
 
     if (t->ndim == 0) {
-        return ndt_copy(t, ctx);
+        ndt_incref(t);
+        return t;
     }
 
     next_step = MULi64(step, t->FixedDim.shape, &overflow);
@@ -1216,11 +1523,13 @@ _ndt_to_fortran(const ndt_t *t, int64_t step, ndt_context_t *ctx)
         return NULL;
     }
 
-    return ndt_fixed_dim(dt, t->FixedDim.shape, step, ctx);
+    u = ndt_fixed_dim(dt, t->FixedDim.shape, step, ctx);
+    ndt_decref(dt);
+    return u;
 }
 
 /* Return a copy of a C-contiguous array in Fortran order. */
-ndt_t *
+const ndt_t *
 ndt_to_fortran(const ndt_t *t, ndt_context_t *ctx)
 {
     if (ndt_is_abstract(t)) {
@@ -1238,14 +1547,13 @@ ndt_to_fortran(const ndt_t *t, ndt_context_t *ctx)
     return _ndt_to_fortran(t, 1, ctx);
 }
 
-ndt_t *
-ndt_fixed_dim(ndt_t *type, int64_t shape, int64_t step, ndt_context_t *ctx)
+const ndt_t *
+ndt_fixed_dim(const ndt_t *type, int64_t shape, int64_t step, ndt_context_t *ctx)
 {
     ndt_t *t;
     bool overflow = 0;
 
-    if (!check_type_invariants(type, ctx)) {
-        ndt_del(type);
+    if (!check_fixed_invariants(type, ctx)) {
         return NULL;
     }
 
@@ -1255,16 +1563,18 @@ ndt_fixed_dim(ndt_t *type, int64_t shape, int64_t step, ndt_context_t *ctx)
     }
 
     /* abstract type */
-    t = ndt_new(FixedDim, ctx);
+    t = ndt_new(FixedDim, 0, ctx);
     if (t == NULL) {
-        ndt_del(type);
         return NULL;
     }
     t->FixedDim.tag = RequireNA;
     t->FixedDim.shape = shape;
+
+    ndt_incref(type);
     t->FixedDim.type = type;
+
     t->ndim = type->ndim + 1;
-    t->flags = ndt_dim_flags(type);
+    t->flags |= ndt_dim_flags(type);
 
     t->Concrete.FixedDim.itemsize = 0;
     t->Concrete.FixedDim.step = INT64_MAX;
@@ -1283,18 +1593,18 @@ ndt_fixed_dim(ndt_t *type, int64_t shape, int64_t step, ndt_context_t *ctx)
 
     if (overflow) {
         ndt_err_format(ctx, NDT_ValueError, "data size too large");
-        ndt_del(t);
+        ndt_decref(t);
         return NULL;
     }
 
     return t;
 }
 
-ndt_t *
-ndt_fixed_dim_tag(ndt_t *type, enum ndt_contig tag, int64_t shape, int64_t step,
+const ndt_t *
+ndt_fixed_dim_tag(const ndt_t *type, enum ndt_contig tag, int64_t shape, int64_t step,
                   ndt_context_t *ctx)
 {
-    ndt_t *t = ndt_fixed_dim(type, shape, step, ctx);
+    ndt_t *t = (ndt_t *)ndt_fixed_dim(type, shape, step, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -1307,31 +1617,29 @@ ndt_fixed_dim_tag(ndt_t *type, enum ndt_contig tag, int64_t shape, int64_t step,
     return t;
 }
 
-ndt_t *
-ndt_abstract_var_dim(ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_abstract_var_dim(const ndt_t *type, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t = NULL;
 
     if (!check_abstract_var_invariants(type, ctx)) {
-        ndt_del(type);
         return NULL;
     }
 
     /* abstract type */
-    t = ndt_new(VarDim, ctx);
+    t = ndt_new(VarDim, opt, ctx);
     if (t == NULL) {
-        ndt_del(type);
         return NULL;
     }
+    ndt_incref(type);
     t->VarDim.type = type;
+
     t->ndim = type->ndim+1;
-    t->flags = ndt_dim_flags(type);
+    t->flags |= ndt_dim_flags(type);
 
     /* concrete access */
     t->access = Abstract;
-    t->Concrete.VarDim.flag = ExternalOffsets;
     t->Concrete.VarDim.itemsize = 0;
-    t->Concrete.VarDim.noffsets = 0;
     t->Concrete.VarDim.offsets = NULL;
     t->Concrete.VarDim.nslices = 0;
     t->Concrete.VarDim.slices = NULL;
@@ -1355,17 +1663,16 @@ ndt_var_indices(int64_t *res_start, int64_t *res_step, const ndt_t *t,
     int32_t i;
 
     assert(ndt_is_concrete(t));
-    assert(t->tag == VarDim);
+    assert(t->tag == VarDim || t->tag == VarDimElem);
 
-    if (index < 0 || index+1 >= t->Concrete.VarDim.noffsets) {
-        ndt_err_format(ctx, NDT_ValueError,
-            "var dim index out of range: index=%" PRIi64 ", noffsets=%" PRIi32,
-            index, t->Concrete.VarDim.noffsets);
+    if (index < 0 || index+1 >= t->Concrete.VarDim.offsets->n) {
+        ndt_err_format(ctx, NDT_IndexError,
+            "index with value %" PRIi64 " out of bounds", index);
         return -1;
     }
 
-    list_start = t->Concrete.VarDim.offsets[index];
-    list_stop = t->Concrete.VarDim.offsets[index+1];
+    list_start = t->Concrete.VarDim.offsets->v[index];
+    list_stop = t->Concrete.VarDim.offsets->v[index+1];
     list_shape = list_stop - list_start;
 
     *res_start = 0;
@@ -1387,6 +1694,52 @@ ndt_var_indices(int64_t *res_start, int64_t *res_step, const ndt_t *t,
     return res_shape;
 }
 
+/* Same as ndt_var_indices(), but skips empty slices in the stack. */
+int64_t
+ndt_var_indices_non_empty(int64_t *res_start, int64_t *res_step, const ndt_t *t,
+                          int64_t index, ndt_context_t *ctx)
+{
+    int64_t list_start, list_stop, list_shape;
+    int64_t start, stop, step;
+    int64_t shape, res_shape;
+    const ndt_slice_t *slices;
+    int32_t i;
+
+    assert(ndt_is_concrete(t));
+    assert(t->tag == VarDim || t->tag == VarDimElem);
+
+    if (index < 0 || index+1 >= t->Concrete.VarDim.offsets->n) {
+        ndt_err_format(ctx, NDT_IndexError,
+            "index with value %" PRIi64 " out of bounds", index);
+        return -1;
+    }
+
+    list_start = t->Concrete.VarDim.offsets->v[index];
+    list_stop = t->Concrete.VarDim.offsets->v[index+1];
+    list_shape = list_stop - list_start;
+
+    *res_start = 0;
+    *res_step = 1;
+    res_shape = list_shape;
+    slices = t->Concrete.VarDim.slices;
+
+    for (i = 0; i < t->Concrete.VarDim.nslices; i++) {
+        start = slices[i].start;
+        stop = slices[i].stop;
+        step = slices[i].step;
+        shape = ndt_slice_adjust_indices(res_shape, &start, &stop, step);
+        if (shape > 0) {
+            res_shape = shape;
+            *res_start += (start * *res_step);
+            *res_step *= step;
+        }
+    }
+
+    *res_start += list_start;
+
+    return res_shape;
+}
+
 ndt_slice_t *
 ndt_var_add_slice(int32_t *nslices, const ndt_t *t, 
                   int64_t start, int64_t stop, int64_t step,
@@ -1395,8 +1748,12 @@ ndt_var_add_slice(int32_t *nslices, const ndt_t *t,
     int n = t->Concrete.VarDim.nslices;
     ndt_slice_t *slices;
 
-    assert(ndt_is_concrete(t));
-    assert(t->tag == VarDim);
+    if (t->tag != VarDim || ndt_is_abstract(t)) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "ndt_var_add_slice: internal_error: argument must be a "
+            "concrete var dim");
+        return NULL;
+    }
 
     if (n == INT_MAX) {
         ndt_err_format(ctx, NDT_RuntimeError, "slice stack overflow");
@@ -1418,12 +1775,11 @@ ndt_var_add_slice(int32_t *nslices, const ndt_t *t,
     return slices;
 }
 
-ndt_t *
-ndt_var_dim(ndt_t *type,
-            enum ndt_offsets flag,
-            int32_t noffsets, const int32_t *offsets,
+const ndt_t *
+ndt_var_dim(const ndt_t *type,
+            const ndt_offsets_t *offsets,
             int32_t nslices, ndt_slice_t *slices,
-            ndt_context_t *ctx)
+            bool opt, ndt_context_t *ctx)
 {
     bool overflow = 0;
     ndt_t *t;
@@ -1432,37 +1788,33 @@ ndt_var_dim(ndt_t *type,
     assert(offsets != NULL);
     assert(!!nslices == !!slices);
 
-    if (!check_var_invariants(flag, type, ctx)) {
-        ndt_del(type);
+    if (!check_var_invariants(type, ctx)) {
         goto error;
     }
 
-    if (noffsets < 2) {
+    if (offsets->n < 2) {
         ndt_err_format(ctx, NDT_InvalidArgumentError, "var_dim: noffsets < 2");
-        ndt_del(type);
         goto error;
     }
 
     if (!ndt_is_concrete(type)) {
         ndt_err_format(ctx, NDT_InvalidArgumentError,
                        "var_dim: expected concrete type");
-        ndt_del(type);
         goto error;
     }
 
     switch (type->tag) {
-    case VarDim:
-        if (offsets[noffsets-1] != type->Concrete.VarDim.noffsets-1) {
+    case VarDim: case VarDimElem:
+        if (offsets->v[offsets->n-1] != type->Concrete.VarDim.offsets->n-1) {
             ndt_err_format(ctx, NDT_ValueError,
                 "var_dim: missing or invalid number of offset arguments");
-            ndt_del(type);
             goto error;
         }
         datasize = type->datasize;
         itemsize = type->Concrete.VarDim.itemsize;
         break;
     default:
-        datasize = MULi64(offsets[noffsets-1], type->datasize, &overflow);
+        datasize = MULi64(offsets->v[offsets->n-1], type->datasize, &overflow);
         itemsize = type->datasize;
         break;
     }
@@ -1470,27 +1822,26 @@ ndt_var_dim(ndt_t *type,
     if (overflow) {
         ndt_err_format(ctx, NDT_ValueError,
             "overflow in creating var dimension");
-        ndt_del(type);
         goto error;
     }
 
     /* abstract type */
-    t = ndt_new(VarDim, ctx);
+    t = ndt_new(VarDim, opt, ctx);
     if (t == NULL) {
-        ndt_del(type);
         goto error;
     }
+    ndt_incref(type);
+    ndt_incref_offsets(offsets);
+
     t->VarDim.type = type;
     t->ndim = type->ndim+1;
-    t->flags = ndt_dim_flags(type);
+    t->flags |= ndt_dim_flags(type);
 
     /* concrete access */
     t->access = Concrete;
     t->datasize = datasize;
     t->align = type->align;
-    t->Concrete.VarDim.flag = flag;
     t->Concrete.VarDim.itemsize = itemsize;
-    t->Concrete.VarDim.noffsets = noffsets;
     t->Concrete.VarDim.offsets = offsets;
     t->Concrete.VarDim.nslices = nslices;
     t->Concrete.VarDim.slices = slices;
@@ -1499,44 +1850,42 @@ ndt_var_dim(ndt_t *type,
 
 
 error:
-    if (flag == InternalOffsets) {
-        ndt_free((int32_t *)offsets);
-    }
     ndt_free(slices);
     return NULL;
 }
 
-ndt_t *
-ndt_symbolic_dim(char *name, ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_symbolic_dim(char *name, const ndt_t *type, ndt_context_t *ctx)
 {
     ndt_t *t;
 
-    if (!check_type_invariants(type, ctx)) {
+    if (!check_fixed_invariants(type, ctx)) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
     /* abstract type */
-    t = ndt_new(SymbolicDim, ctx);
+    t = ndt_new(SymbolicDim, 0, ctx);
     if (t == NULL) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
     t->SymbolicDim.tag = RequireNA;
     t->SymbolicDim.name = name;
+
+    ndt_incref(type);
     t->SymbolicDim.type = type;
+
     t->ndim = type->ndim + 1;
-    t->flags = ndt_dim_flags(type);
+    t->flags |= ndt_dim_flags(type);
 
     return t;
 }
 
-ndt_t *
-ndt_symbolic_dim_tag(char *name, ndt_t *type, enum ndt_contig tag, ndt_context_t *ctx)
+const ndt_t *
+ndt_symbolic_dim_tag(char *name, const ndt_t *type, enum ndt_contig tag, ndt_context_t *ctx)
 {
-    ndt_t *t = ndt_symbolic_dim(name, type, ctx);
+    ndt_t *t = (ndt_t *)ndt_symbolic_dim(name, type, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -1545,15 +1894,14 @@ ndt_symbolic_dim_tag(char *name, ndt_t *type, enum ndt_contig tag, ndt_context_t
     return t;
 }
 
-ndt_t *
-ndt_ellipsis_dim(char *name, ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_ellipsis_dim(char *name, const ndt_t *type, ndt_context_t *ctx)
 {
     ndt_t *t;
     uint32_t flags;
 
     if (!check_ellipsis_invariants(type, ctx)) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
@@ -1561,30 +1909,31 @@ ndt_ellipsis_dim(char *name, ndt_t *type, ndt_context_t *ctx)
     if (flags & NDT_ELLIPSIS) {
         ndt_err_format(ctx, NDT_ValueError, "more than one ellipsis");
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
     /* abstract type */
-    t = ndt_new(EllipsisDim, ctx);
+    t = ndt_new(EllipsisDim, 0, ctx);
     if (t == NULL) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
     t->EllipsisDim.tag = RequireNA;
     t->EllipsisDim.name = name;
+
+    ndt_incref(type);
     t->EllipsisDim.type = type;
-    t->flags = flags | NDT_ELLIPSIS;
+
+    t->flags |= (flags|NDT_ELLIPSIS);
     t->ndim = type->ndim + 1;
 
     return t;
 }
 
-ndt_t *
-ndt_ellipsis_dim_tag(char *name, ndt_t *type, enum ndt_contig tag, ndt_context_t *ctx)
+const ndt_t *
+ndt_ellipsis_dim_tag(char *name, const ndt_t *type, enum ndt_contig tag, ndt_context_t *ctx)
 {
-    ndt_t *t = ndt_ellipsis_dim(name, type, ctx);
+    ndt_t *t = (ndt_t *)ndt_ellipsis_dim(name, type, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -1686,9 +2035,44 @@ init_concrete_fields(ndt_t *t, int64_t *offsets, uint16_t *align, uint16_t *pad,
     return 0;
 }
 
-ndt_t *
-ndt_tuple(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
-          uint16_opt_t align, uint16_opt_t pack, ndt_context_t *ctx)
+/*
+ * Initialize the access information of a concrete union.
+ * Assumptions:
+ *   1) t->tag == Union
+ *   2) t->access == Concrete
+ *   3) 0 <= i < ntags ==> fields[i].access == Concrete
+ *   4) len(fields) == ntags
+ */
+static int
+init_concrete_tags(ndt_t *t, const ndt_field_t *fields, int64_t ntags,
+                   ndt_context_t *ctx)
+{
+    int64_t maxsize = 0;
+    int64_t i;
+
+    for (i = 0; i < ntags; i++) {
+        assert(fields[i].access == Concrete);
+        assert(fields[i].type->access == Concrete);
+
+        if (fields[i].type->flags & NDT_REF) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "union types cannot contain references");
+            return -1;
+        }
+
+        maxsize = max_i64(fields[i].type->datasize, maxsize);
+    }
+
+    assert(t->access == Concrete);
+    t->align = 1;
+    t->datasize = 1+maxsize;
+
+    return 0;
+}
+
+const ndt_t *
+ndt_tuple(enum ndt_variadic flag, const ndt_field_t *fields, int64_t shape,
+          uint16_opt_t align, uint16_opt_t pack, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
     int64_t i;
@@ -1697,15 +2081,13 @@ ndt_tuple(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
 
     for (i = 0; i < shape; i++) {
         if (!check_type_invariants(fields[i].type, ctx)) {
-            ndt_field_array_del(fields, shape);
             return NULL;
         }
     }
 
     /* abstract type */
-    t = ndt_tuple_new(flag, shape, ctx);
+    t = ndt_tuple_new(flag, shape, opt, ctx);
     if (t == NULL) {
-        ndt_field_array_del(fields, shape);
         return NULL;
     }
 
@@ -1724,17 +2106,16 @@ ndt_tuple(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
                 fields[i].Concrete.explicit_align) {
                 ndt_err_format(ctx, NDT_InvalidArgumentError,
                                "explicit field alignment in abstract tuple");
-                ndt_field_array_del(fields, shape);
                 ndt_free(t);
                 return NULL;
             }
         }
         for (i = 0; i < shape; i++) {
             assert(fields[i].name == NULL);
+            ndt_incref(fields[i].type);
             t->Tuple.types[i] = fields[i].type;
             t->flags |= ndt_subtree_flags(fields[i].type);
         }
-        ndt_free(fields);
         return t;
     }
     else {
@@ -1743,23 +2124,22 @@ ndt_tuple(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
                                  t->Concrete.Tuple.align,
                                  t->Concrete.Tuple.pad,
                                  fields, shape, align, pack, ctx) < 0) {
-            ndt_field_array_del(fields, shape);
             ndt_free(t);
             return NULL;
         }
         for (i = 0; i < shape; i++) {
             assert(fields[i].name == NULL);
+            ndt_incref(fields[i].type);
             t->Tuple.types[i] = fields[i].type;
             t->flags |= ndt_subtree_flags(fields[i].type);
         }
-        ndt_free(fields);
         return t;
     }
 }
 
-ndt_t *
-ndt_record(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
-           uint16_opt_t align, uint16_opt_t pack, ndt_context_t *ctx)
+const ndt_t *
+ndt_record(enum ndt_variadic flag, const ndt_field_t *fields, int64_t shape,
+           uint16_opt_t align, uint16_opt_t pack, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
     int64_t i;
@@ -1768,15 +2148,13 @@ ndt_record(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
 
     for (i = 0; i < shape; i++) {
         if (!check_type_invariants(fields[i].type, ctx)) {
-            ndt_field_array_del(fields, shape);
             return NULL;
         }
     }
 
     /* abstract type */
-    t = ndt_record_new(flag, shape, ctx);
+    t = ndt_record_new(flag, shape, opt, ctx);
     if (t == NULL) {
-        ndt_field_array_del(fields, shape);
         return NULL;
     }
 
@@ -1795,18 +2173,23 @@ ndt_record(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
                 fields[i].Concrete.explicit_align) {
                 ndt_err_format(ctx, NDT_InvalidArgumentError,
                                "explicit field alignment in abstract tuple");
-                /* at this point names and types still belong to the fields */
-                ndt_field_array_del(fields, shape);
                 ndt_free(t);
                 return NULL;
             }
         }
         for (i = 0; i < shape; i++) {
-            t->Record.names[i] = fields[i].name;
+            char *s = ndt_strdup(fields[i].name, ctx);
+            if (s == NULL) {
+                ndt_decref(t);
+                return NULL;
+            }
+            t->Record.names[i] = s;
+
+            ndt_incref(fields[i].type);
             t->Record.types[i] = fields[i].type;
+
             t->flags |= ndt_subtree_flags(fields[i].type);
         }
-        ndt_free(fields);
         return t;
     }
     else {
@@ -1815,39 +2198,159 @@ ndt_record(enum ndt_variadic flag, ndt_field_t *fields, int64_t shape,
                                  t->Concrete.Record.align,
                                  t->Concrete.Record.pad,
                                  fields, shape, align, pack, ctx) < 0) {
-            /* at this point names and types still belong to the fields */
-            ndt_field_array_del(fields, shape);
             ndt_free(t);
             return NULL;
         }
         for (i = 0; i < shape; i++) {
-            t->Record.names[i] = fields[i].name;
+            char *s = ndt_strdup(fields[i].name, ctx);
+            if (s == NULL) {
+                ndt_decref(t);
+                return NULL;
+            }
+            t->Record.names[i] = s;
+
+            ndt_incref(fields[i].type);
             t->Record.types[i] = fields[i].type;
+
             t->flags |= ndt_subtree_flags(fields[i].type);
         }
-        ndt_free(fields);
         return t;
     }
 }
 
-ndt_t *
-ndt_ref(ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_union(const ndt_field_t *fields, int64_t ntags, bool opt,
+          ndt_context_t *ctx)
+{
+    ndt_t *t;
+    int64_t i;
+
+    if (ntags == 0 || fields == NULL) {
+        ndt_err_format(ctx, NDT_ValueError, "unions cannot be empty");
+        return NULL;
+    }
+
+    if (ntags > 255) {
+        ndt_err_format(ctx, NDT_ValueError, "union too large (max 255 members)");
+        return NULL;
+    }
+
+    for (i = 0; i < ntags; i++) {
+        if (!check_type_invariants(fields[i].type, ctx)) {
+            return NULL;
+        }
+    }
+
+    /* abstract type */
+    t = ndt_union_new(ntags, opt, ctx);
+    if (t == NULL) {
+        return NULL;
+    }
+
+    /* check concrete access */
+    t->access = Concrete;
+    for (i = 0; i < ntags; i++) {
+        if (fields[i].access == Abstract) {
+            t->access = Abstract;
+        }
+    }
+
+    if (t->access == Abstract) {
+        /* check if any field has explicit 'align' or 'pack' attributes */
+        for (i = 0; i < ntags; i++) {
+            if (fields[i].access == Concrete &&
+                fields[i].Concrete.explicit_align) {
+                ndt_err_format(ctx, NDT_InvalidArgumentError,
+                               "explicit field alignment in abstract tuple");
+                ndt_free(t);
+                return NULL;
+            }
+        }
+        for (i = 0; i < ntags; i++) {
+            char *s = ndt_strdup(fields[i].name, ctx);
+            if (s == NULL) {
+                ndt_decref(t);
+                return NULL;
+            }
+            t->Union.tags[i] = s;
+
+            ndt_incref(fields[i].type);
+            t->Union.types[i] = fields[i].type;
+
+            t->flags |= ndt_subtree_flags(fields[i].type);
+        }
+        return t;
+    }
+    else {
+        if (init_concrete_tags(t, fields, ntags, ctx) < 0) {
+            ndt_free(t);
+            return NULL;
+        }
+
+        for (i = 0; i < ntags; i++) {
+            char *s = ndt_strdup(fields[i].name, ctx);
+            if (s == NULL) {
+                ndt_decref(t);
+                return NULL;
+            }
+            t->Union.tags[i] = s;
+
+            ndt_incref(fields[i].type);
+            t->Union.types[i] = fields[i].type;
+
+            t->flags |= ndt_subtree_flags(fields[i].type);
+        }
+        return t;
+    }
+}
+
+const ndt_t *
+ndt_array(const ndt_t *type, bool opt, ndt_context_t *ctx)
+{
+    ndt_t *t;
+
+    if (!check_array_invariants(type, ctx)) {
+        return NULL;
+    }
+
+    /* abstract type */
+    t = ndt_new(Array, opt|NDT_POINTER, ctx);
+    if (t == NULL) {
+        return NULL;
+    }
+    ndt_incref(type);
+    t->Array.itemsize = type->datasize;
+    t->Array.type = type;
+
+    t->flags |= ndt_subtree_flags(type);
+    t->ndim = type->ndim + 1;
+
+    /* concrete access */
+    t->access = type->access;
+    t->datasize = sizeof(ndt_array_t);
+    t->align = alignof(ndt_array_t);
+
+    return t;
+}
+
+const ndt_t *
+ndt_ref(const ndt_t *type, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
 
     if (!check_type_invariants(type, ctx)) {
-        ndt_del(type);
         return NULL;
     }
 
     /* abstract type */
-    t = ndt_new(Ref, ctx);
+    t = ndt_new(Ref, opt|NDT_POINTER|NDT_REF, ctx);
     if (t == NULL) {
-        ndt_del(type);
         return NULL;
     }
+    ndt_incref(type);
     t->Ref.type = type;
-    t->flags = ndt_subtree_flags(type);
+
+    t->flags |= ndt_subtree_flags(type);
 
     /* concrete access */
     t->access = type->access;
@@ -1857,28 +2360,29 @@ ndt_ref(ndt_t *type, ndt_context_t *ctx)
     return t;
 }
 
-ndt_t *
-ndt_constr(char *name, ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_constr(char *name, const ndt_t *type, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
 
     if (!check_type_invariants(type, ctx)) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
-    t = ndt_new(Constr, ctx);
+    t = ndt_new(Constr, opt, ctx);
     if (t == NULL) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
     /* abstract type */
     t->Constr.name = name;
+
+    ndt_incref(type);
     t->Constr.type = type;
-    t->flags = ndt_subtree_flags(type);
+
+    t->flags |= ndt_subtree_flags(type);
 
     /* concrete access */
     t->access = type->access;
@@ -1890,8 +2394,8 @@ ndt_constr(char *name, ndt_t *type, ndt_context_t *ctx)
     return t;
 }
 
-ndt_t *
-ndt_nominal(char *name, ndt_t *type, ndt_context_t *ctx)
+const ndt_t *
+ndt_nominal(char *name, const ndt_t *type, bool opt, ndt_context_t *ctx)
 {
     const ndt_typedef_t *d;
     ndt_t *t;
@@ -1899,7 +2403,6 @@ ndt_nominal(char *name, ndt_t *type, ndt_context_t *ctx)
     d = ndt_typedef_find(name, ctx);
     if (d == NULL) {
         ndt_free(name);
-        ndt_del(type);
         return NULL;
     }
 
@@ -1911,29 +2414,25 @@ ndt_nominal(char *name, ndt_t *type, ndt_context_t *ctx)
                     "type is not an instance of %s", name);
             }
             ndt_free(name);
-            ndt_del(type);
             return NULL;
         }
     }
     else {
-        type = ndt_copy(d->type, ctx);
-        if (type == NULL) {
-            ndt_free(name);
-            return NULL;
-        }
+        type = d->type;
     }
+    ndt_incref(type);
 
     /* abstract type */
-    t = ndt_new(Nominal, ctx);
+    t = ndt_new(Nominal, opt, ctx);
     if (t == NULL) {
         ndt_free(name);
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
     t->Nominal.name = name;
     t->Nominal.type = type;
     t->Nominal.meth = &d->meth;
-    t->flags = ndt_subtree_flags(type);
+    t->flags |= ndt_subtree_flags(type);
 
     /* concrete access */
     t->access = type->access;
@@ -1948,10 +2447,10 @@ ndt_nominal(char *name, ndt_t *type, ndt_context_t *ctx)
 /*                               Scalar types                                 */
 /******************************************************************************/
 
-ndt_t *
-ndt_scalar_kind(ndt_context_t *ctx)
+const ndt_t *
+ndt_scalar_kind(bool opt, ndt_context_t *ctx)
 {
-    return ndt_new(ScalarKind, ctx);
+    return ndt_new(ScalarKind, opt, ctx);
 }
 
 /* Define a sort order for the typed values in the categorical set. */
@@ -1964,8 +2463,8 @@ cmp(const void *x, const void *y)
     return ndt_value_compare(p, q);
 }
 
-ndt_t *
-ndt_categorical(ndt_value_t *types, int64_t ntypes, ndt_context_t *ctx)
+const ndt_t *
+ndt_categorical(const ndt_value_t *types, int64_t ntypes, bool opt, ndt_context_t *ctx)
 {
     ndt_value_t *tmp;
     ndt_t *t;
@@ -1993,7 +2492,7 @@ ndt_categorical(ndt_value_t *types, int64_t ntypes, ndt_context_t *ctx)
     ndt_free(tmp);
 
     /* abstract type */
-    t = ndt_new(Categorical, ctx);
+    t = ndt_new(Categorical, opt, ctx);
     if (t == NULL) {
         ndt_value_array_del(types, ntypes);
         return NULL;
@@ -2009,20 +2508,20 @@ ndt_categorical(ndt_value_t *types, int64_t ntypes, ndt_context_t *ctx)
     return t;
 }
 
-ndt_t *
-ndt_fixed_string_kind(ndt_context_t *ctx)
+const ndt_t *
+ndt_fixed_string_kind(bool opt, ndt_context_t *ctx)
 {
-    return ndt_new(FixedStringKind, ctx);
+    return ndt_new(FixedStringKind, opt, ctx);
 }
 
-ndt_t *
-ndt_fixed_string(int64_t size, enum ndt_encoding encoding, ndt_context_t *ctx)
+const ndt_t *
+ndt_fixed_string(int64_t size, enum ndt_encoding encoding, bool opt, ndt_context_t *ctx)
 {
     bool overflow = 0;
     ndt_t *t;
 
     /* abstract type */
-    t = ndt_new(FixedString, ctx);
+    t = ndt_new(FixedString, opt, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -2037,21 +2536,21 @@ ndt_fixed_string(int64_t size, enum ndt_encoding encoding, ndt_context_t *ctx)
     if (overflow) {
         ndt_err_format(ctx, NDT_ValueError,
             "overflow while creating fixed string");
-        ndt_del(t);
+        ndt_decref(t);
         return NULL;
     }
 
     return t;
 }
 
-ndt_t *
-ndt_fixed_bytes_kind(ndt_context_t *ctx)
+const ndt_t *
+ndt_fixed_bytes_kind(bool opt, ndt_context_t *ctx)
 {
-    return ndt_new(FixedBytesKind, ctx);
+    return ndt_new(FixedBytesKind, opt, ctx);
 }
 
-ndt_t *
-ndt_fixed_bytes(int64_t size, uint16_opt_t align_attr, ndt_context_t *ctx)
+const ndt_t *
+ndt_fixed_bytes(int64_t size, uint16_opt_t align_attr, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
     uint16_t align;
@@ -2068,7 +2567,7 @@ ndt_fixed_bytes(int64_t size, uint16_opt_t align_attr, ndt_context_t *ctx)
     }
 
     /* abstract type */
-    t = ndt_new(FixedBytes, ctx);
+    t = ndt_new(FixedBytes, opt, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -2083,27 +2582,8 @@ ndt_fixed_bytes(int64_t size, uint16_opt_t align_attr, ndt_context_t *ctx)
     return t;
 }
 
-ndt_t *
-ndt_string(ndt_context_t *ctx)
-{
-    ndt_t *t;
-
-    /* abstract type */
-    t = ndt_new(String, ctx);
-    if (t == NULL) {
-        return NULL;
-    }
-
-    /* concrete access */
-    t->access = Concrete;
-    t->datasize = sizeof(char *);
-    t->align = alignof(char *);
-
-    return t;
-}
-
-ndt_t *
-ndt_bytes(uint16_opt_t target_align, ndt_context_t *ctx)
+const ndt_t *
+ndt_bytes(uint16_opt_t target_align, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
     uint16_t align;
@@ -2114,7 +2594,7 @@ ndt_bytes(uint16_opt_t target_align, ndt_context_t *ctx)
     }
 
     /* abstract type */
-    t = ndt_new(Bytes, ctx);
+    t = ndt_new(Bytes, opt|NDT_POINTER, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -2128,13 +2608,13 @@ ndt_bytes(uint16_opt_t target_align, ndt_context_t *ctx)
     return t;
 }
 
-ndt_t *
-ndt_char(enum ndt_encoding encoding, ndt_context_t *ctx)
+const ndt_t *
+ndt_char(enum ndt_encoding encoding, bool opt, ndt_context_t *ctx)
 {
     ndt_t *t;
 
     /* abstract type */
-    t = ndt_new(Char, ctx);
+    t = ndt_new(Char, opt|NDT_CHAR, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -2148,122 +2628,7 @@ ndt_char(enum ndt_encoding encoding, ndt_context_t *ctx)
     return t;
 }
 
-ndt_t *
-ndt_signed_kind(ndt_context_t *ctx)
-{
-    return ndt_new(SignedKind, ctx);
-}
-
-ndt_t *
-ndt_unsigned_kind(ndt_context_t *ctx)
-{
-    return ndt_new(UnsignedKind, ctx);
-}
-
-ndt_t *
-ndt_float_kind(ndt_context_t *ctx)
-{
-    return ndt_new(FloatKind, ctx);
-}
-
-ndt_t *
-ndt_complex_kind(ndt_context_t *ctx)
-{
-    return ndt_new(ComplexKind, ctx);
-}
-
-ndt_t *
-ndt_primitive(enum ndt tag, uint32_t flags, ndt_context_t *ctx)
-{
-    ndt_t *t;
-
-    if (flags != 0 && flags != NDT_LITTLE_ENDIAN && flags != NDT_BIG_ENDIAN) {
-        ndt_err_format(ctx, NDT_ValueError,
-            "flags argument must be 0 or NDT_LITTLE_ENDIAN or NDT_BIG_ENDIAN");
-        return NULL;
-    }
-
-    /* abstract type */
-    t = ndt_new(tag, ctx);
-    if (t == NULL) {
-        return NULL;
-    }
-    t->flags |= flags;
-
-    /* concrete access */
-    t->access = Concrete;
-
-    switch(tag) {
-    case Bool:
-        t->datasize = sizeof(bool);
-        t->align = alignof(bool);
-        break;
-    case Int8:
-        t->datasize = sizeof(int8_t);
-        t->align = alignof(int8_t);
-        break;
-    case Int16:
-        t->datasize = sizeof(int16_t);
-        t->align = alignof(int16_t);
-        break;
-    case Int32:
-        t->datasize = sizeof(int32_t);
-        t->align = alignof(int32_t);
-        break;
-    case Int64:
-        t->datasize = sizeof(int64_t);
-        t->align = alignof(int64_t);
-        break;
-    case Uint8:
-        t->datasize = sizeof(uint8_t);
-        t->align = alignof(uint8_t);
-        break;
-    case Uint16:
-        t->datasize = sizeof(uint16_t);
-        t->align = alignof(uint16_t);
-        break;
-    case Uint32:
-        t->datasize = sizeof(uint32_t);
-        t->align = alignof(uint32_t);
-        break;
-    case Uint64:
-        t->datasize = sizeof(uint64_t);
-        t->align = alignof(uint64_t);
-        break;
-    case Float16:
-        t->datasize = 2;
-        t->align = 2;
-        break;
-    case Float32:
-        t->datasize = sizeof(float);
-        t->align = alignof(float);
-        break;
-    case Float64:
-        t->datasize = sizeof(double);
-        t->align = alignof(double);
-        break;
-    case Complex32:
-        t->datasize = 4;
-        t->align = 2;
-        break;
-    case Complex64:
-        t->datasize = sizeof(ndt_complex64_t);
-        t->align = alignof(ndt_complex64_t);
-        break;
-    case Complex128:
-        t->datasize = sizeof(ndt_complex128_t);
-        t->align = alignof(ndt_complex128_t);
-        break;
-    default:
-        ndt_err_format(ctx, NDT_ValueError, "not a primitive type"),
-        ndt_free(t);
-        return NULL;
-    }
-
-    return t;
-}
-
-ndt_t *
+const ndt_t *
 ndt_signed(int size, uint32_t flags, ndt_context_t *ctx)
 {
     switch (size) {
@@ -2278,7 +2643,7 @@ ndt_signed(int size, uint32_t flags, ndt_context_t *ctx)
     }
 }
 
-ndt_t *
+const ndt_t *
 ndt_unsigned(int size, uint32_t flags, ndt_context_t *ctx)
 {
     switch (size) {
@@ -2293,7 +2658,7 @@ ndt_unsigned(int size, uint32_t flags, ndt_context_t *ctx)
     }
 }
 
-ndt_t *
+const ndt_t *
 ndt_from_alias(enum ndt_alias tag, uint32_t flags, ndt_context_t *ctx)
 {
     switch (tag) {
@@ -2306,13 +2671,13 @@ ndt_from_alias(enum ndt_alias tag, uint32_t flags, ndt_context_t *ctx)
     }
 }
 
-ndt_t *
+const ndt_t *
 ndt_typevar(char *name, ndt_context_t *ctx)
 {
     ndt_t *t;
 
     /* abstract type */
-    t = ndt_new(Typevar, ctx);
+    t = ndt_new(Typevar, 0, ctx);
     if (t == NULL) {
         ndt_free(name);
         return NULL;