ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/libndtypes/lexer.h

@@ -726,7 +726,7 @@ extern int yylex \
 #undef yyTABLES_NAME
 #endif
 
-#line 222 "lexer.l"
+#line 227 "lexer.l"
 
 
 #line 732 "lexer.h"

data/ext/ruby_ndtypes/ndtypes/libndtypes/lexer.l

@@ -144,24 +144,26 @@ yycolumn = 1;
 "void"         { return VOID; }
 "bool"         { return BOOL; }
 
-"Signed"       { return SIGNED_KIND; }
+"signed"       { return SIGNED_KIND; }
 "int8"         { return INT8; }
 "int16"        { return INT16; }
 "int32"        { return INT32; }
 "int64"        { return INT64; }
 
-"Unsigned"     { return UNSIGNED_KIND; }
+"unsigned"     { return UNSIGNED_KIND; }
 "uint8"        { return UINT8; }
 "uint16"       { return UINT16; }
 "uint32"       { return UINT32; }
 "uint64"       { return UINT64; }
 
-"Float"        { return FLOAT_KIND; }
+"float"        { return FLOAT_KIND; }
+"bfloat16"     { return BFLOAT16; }
 "float16"      { return FLOAT16; }
 "float32"      { return FLOAT32; }
 "float64"      { return FLOAT64; }
 
-"Complex"      { return COMPLEX_KIND; }
+"complex"      { return COMPLEX_KIND; }
+"bcomplex32"   { return BCOMPLEX32; }
 "complex32"    { return COMPLEX32; }
 "complex64"    { return COMPLEX64; }
 "complex128"   { return COMPLEX128; }
@@ -186,6 +188,9 @@ yycolumn = 1;
 
 "fixed"        { return FIXED; }
 "var"          { return VAR; }
+"array"        { return ARRAY; }
+
+"of"           { return OF; }
 
 "..."          { return ELLIPSIS; }
 "->"           { return RARROW; }

data/ext/ruby_ndtypes/ndtypes/libndtypes/libndtypes.so

@@ -0,0 +1 @@
+ext/ruby_ndtypes/ndtypes/libndtypes/libndtypes.so.0.2.0dev3

data/ext/ruby_ndtypes/ndtypes/libndtypes/libndtypes.so.0

@@ -0,0 +1 @@
+ext/ruby_ndtypes/ndtypes/libndtypes/libndtypes.so.0.2.0dev3

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

@@ -103,7 +103,7 @@ resolve_broadcast(symtable_entry_t w, symtable_t *tbl, ndt_context_t *ctx)
 }
 
 static int
-check_contig(ndt_t *ptypes[], ndt_t *ctypes[], int64_t nargs)
+check_contig(const ndt_t *ptypes[], const ndt_t *ctypes[], int64_t nargs)
 {
     for (int i = 0; i < nargs; i++) {
         const ndt_t *p = ptypes[i];
@@ -130,14 +130,14 @@ check_contig(ndt_t *ptypes[], ndt_t *ctypes[], int64_t nargs)
     return 1;
 }
 
-static ndt_t *
-to_fortran(const ndt_t *p, ndt_t *c, ndt_context_t *ctx)
+static const ndt_t *
+to_fortran(const ndt_t *p, const ndt_t *c, ndt_context_t *ctx)
 {
     if (p->tag == EllipsisDim && p->EllipsisDim.tag == RequireF) {
-        ndt_t *t = ndt_to_fortran(c, ctx);
-        return t;
+        return ndt_to_fortran(c, ctx);
     }
     else {
+        ndt_incref(c);
         return c;
     }
 }
@@ -217,41 +217,124 @@ resolve_typevar(const char *key, symtable_entry_t w, symtable_t *tbl, ndt_contex
     }
 }
 
+typedef struct {
+    int64_t index;
+    const ndt_t *type;
+} indexed_type_t;
+
+static indexed_type_t indexed_type_error = { 0, NULL };
+
+static inline int64_t
+adjust_index(const int64_t i, const int64_t shape, ndt_context_t *ctx)
+{
+    const int64_t k = i < 0 ? i + shape : i;
+
+    if (k < 0 || k >= shape) {
+        ndt_err_format(ctx, NDT_IndexError,
+            "index with value %" PRIi64 " out of bounds", i);
+        return -1;
+    }
+
+    return k;
+}
+
+static inline indexed_type_t
+var_dim_next(const indexed_type_t *x, const int64_t start, const int64_t step,
+             const int64_t i)
+{
+    indexed_type_t next;
+    const ndt_t *t = x->type;
+
+    next.index = start + i * step;
+    next.type = t->VarDim.type;
+
+    return next;
+}
+
+/* skip stored indices */
+static indexed_type_t
+apply_stored_index(const indexed_type_t *x, ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+    int64_t start, step, shape;
+
+    if (t->tag != VarDimElem) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+                       "apply_stored_index: need VarDimElem");
+        return indexed_type_error;
+    }
+
+    shape = ndt_var_indices(&start, &step, t, x->index, ctx);
+    if (shape < 0) {
+        return indexed_type_error;
+    }
+
+    const int64_t i = adjust_index(t->VarDimElem.index, shape, ctx);
+    if (i < 0) {
+        return indexed_type_error;
+    }
+
+    return var_dim_next(x, start, step, i);
+}
+
+static indexed_type_t
+apply_stored_indices(const indexed_type_t *x, ndt_context_t *ctx)
+{
+    indexed_type_t tl = *x;
+
+    while (tl.type->tag == VarDimElem) {
+        tl = apply_stored_index(&tl, ctx);
+    }
+
+    return tl;
+}
+
 static int
-match_concrete_var_dim(const ndt_t *t, int64_t tindex,
-                       const ndt_t *u, int64_t uindex,
+match_concrete_var_dim(const indexed_type_t *a, const indexed_type_t *b,
                        const int outer_dims, ndt_context_t *ctx)
 {
-    int64_t tshape, tstart, tstep;
-    int64_t ushape, ustart, ustep;
+    int64_t xshape, xstart, xstep;
+    int64_t yshape, ystart, ystep;
 
     if (outer_dims == 0) {
         return 1;
     }
+
+    const indexed_type_t x = apply_stored_indices(a, ctx);
+    if (x.type == NULL) {
+        return -1;
+    }
+
+    const indexed_type_t y = apply_stored_indices(b, ctx);
+    if (x.type == NULL) {
+        return -1;
+    }
+
+    const ndt_t * const t = x.type;
+    const ndt_t * const u = y.type;
+
     if (t->Concrete.VarDim.itemsize != u->Concrete.VarDim.itemsize) {
         return 0;
     }
 
-    tshape = ndt_var_indices(&tstart, &tstep, t, tindex, ctx);
-    if (tshape < 0) {
+    xshape = ndt_var_indices(&xstart, &xstep, t, x.index, ctx);
+    if (xshape < 0) {
         return -1;
     }
 
-    ushape = ndt_var_indices(&ustart, &ustep, u, uindex, ctx);
-    if (ushape < 0) {
+    yshape = ndt_var_indices(&ystart, &ystep, u, y.index, ctx);
+    if (yshape < 0) {
         return -1;
     }
 
-    if (ushape != tshape) {
+    if (xshape != yshape) {
         return 0;
     }
 
-    for (int64_t i = 0; i < tshape; i++) {
-        int64_t tnext = tstart + i * tstep;
-        int64_t unext = ustart + i * ustep;
-        int ret = match_concrete_var_dim(t->VarDim.type, tnext,
-                                         u->VarDim.type, unext,
-                                         outer_dims-1, ctx);
+    for (int64_t i = 0; i < xshape; i++) {
+        const indexed_type_t xnext = var_dim_next(&x, xstart, xstep, i);
+        const indexed_type_t ynext = var_dim_next(&y, ystart, ystep, i);
+        int ret = match_concrete_var_dim(&xnext, &ynext, outer_dims-1, ctx);
         if (ret <= 0) {
             return ret;
         }
@@ -265,6 +348,7 @@ resolve_var(symtable_entry_t w, symtable_t *tbl, ndt_context_t *ctx)
 {
     const char *key = "var";
     symtable_entry_t v;
+    int vdims, wdims;
 
     v = symtable_find(tbl, key);
     if (v.tag == Unbound) {
@@ -274,16 +358,36 @@ resolve_var(symtable_entry_t w, symtable_t *tbl, ndt_context_t *ctx)
         return 1;
     }
 
-    if (w.VarSeq.size != v.VarSeq.size) {
+    vdims = ndt_logical_ndim(v.VarSeq.dims[0]);
+    wdims = ndt_logical_ndim(w.VarSeq.dims[0]);
+
+    if (wdims != vdims) {
         return 0;
     }
-    if (v.VarSeq.size == 0) {
+    if (vdims == 0) {
         return 1;
     }
 
-    return match_concrete_var_dim(w.VarSeq.dims[0], 0,
-                                  v.VarSeq.dims[0], 0,
-                                  v.VarSeq.size, ctx);
+    const indexed_type_t x = { w.VarSeq.linear_index, w.VarSeq.dims[0] };
+    const indexed_type_t y = { v.VarSeq.linear_index, v.VarSeq.dims[0] };
+    return match_concrete_var_dim(&x, &y, vdims, ctx);
+}
+
+static int
+resolve_array(symtable_entry_t w, symtable_t *tbl, ndt_context_t *ctx)
+{
+    const char *key = "array";
+    symtable_entry_t v;
+
+    v = symtable_find(tbl, key);
+    if (v.tag == Unbound) {
+        if (symtable_add(tbl, key, w, ctx) < 0) {
+            return -1;
+        }
+        return 1;
+    }
+
+    return v.ArraySeq.size == w.ArraySeq.size;
 }
 
 static int
@@ -332,8 +436,32 @@ match_record_fields(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
 }
 
 static int
-match_categorical(ndt_value_t *p, int64_t plen,
-                  ndt_value_t *c, int64_t clen)
+match_union_tags(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
+                 ndt_context_t *ctx)
+{
+    int64_t i;
+    int n;
+
+    assert(p->tag == Union && c->tag == Union);
+
+    if (p->Union.ntags != c->Union.ntags) {
+        return 0;
+    }
+
+    for (i = 0; i < p->Union.ntags; i++) {
+        n = strcmp(p->Union.tags[i], c->Union.tags[i]);
+        if (n != 0) return 0;
+
+        n = match_datashape(p->Union.types[i], c->Union.types[i], tbl, ctx);
+        if (n <= 0) return n;
+    }
+
+    return 1;
+}
+
+static int
+match_categorical(const ndt_value_t *p, int64_t plen,
+                  const ndt_value_t *c, int64_t clen)
 {
     int64_t i;
 
@@ -378,7 +506,7 @@ outer_inner(symtable_entry_t *v, int i, const ndt_t *t, int ndim)
         }
         return outer_inner(v, i+1, t->FixedDim.type, ndim);
     }
-    case VarDim: {
+    case VarDim: case VarDimElem: {
         switch (v->tag) {
         case VarSeq:
             v->VarSeq.size = i+1;
@@ -389,6 +517,18 @@ outer_inner(symtable_entry_t *v, int i, const ndt_t *t, int ndim)
         }
         return outer_inner(v, i+1, t->VarDim.type, ndim);
     }
+    case Array: {
+        switch (v->tag) {
+        case ArraySeq:
+            v->ArraySeq.size = i+1;
+            v->ArraySeq.dims[i] = t;
+            break;
+        default:
+            return NULL;
+        }
+        return outer_inner(v, i+1, t->Array.type, ndim);
+    }
+
     default:
         return NULL;
     }
@@ -400,6 +540,10 @@ match_datashape(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
 {
     int n;
 
+    if (c->tag == VarDimElem) {
+        return match_datashape(p, c->VarDimElem.type, tbl, ctx);
+    }
+
     if (ndt_is_optional(c) != ndt_is_optional(p)) return 0;
 
     switch (p->tag) {
@@ -445,57 +589,11 @@ match_datashape(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
         return match_datashape(p->SymbolicDim.type, c->FixedDim.type, tbl, ctx);
     }
 
-    case EllipsisDim: {
-        symtable_entry_t outer;
-        const ndt_t *inner;
-
-        if (p->EllipsisDim.tag == RequireC && !ndt_is_c_contiguous(c)) {
-            return 0;
-        }
-        if (p->EllipsisDim.tag == RequireF && !ndt_is_f_contiguous(c)) {
-            return 0;
-        }
-
-        if (p->EllipsisDim.name == NULL) {
-            outer.tag = BroadcastSeq;
-            outer.BroadcastSeq.size = 0;
-        }
-        else if (strcmp(p->EllipsisDim.name, "var") == 0) {
-            outer.tag = VarSeq;
-            outer.VarSeq.size = 0;
-        }
-        else {
-            outer.tag = FixedSeq;
-            outer.FixedSeq.size = 0;
-        }
-
-        inner = outer_inner(&outer, 0, c, p->EllipsisDim.type->ndim);
-        if (inner == NULL) {
-            return 0;
-        }
-
-        n = match_datashape(p->EllipsisDim.type, inner, tbl, ctx);
-        if (n <= 0) {
-            return n;
-        }
-
-        switch (outer.tag) {
-        case BroadcastSeq:
-            return resolve_broadcast(outer, tbl, ctx);
-        case FixedSeq:
-            return resolve_fixed(p->EllipsisDim.name, outer, tbl, ctx);
-        case VarSeq:
-            return resolve_var(outer, tbl, ctx);
-        default: /* NOT REACHED */
-            ndt_internal_error("invalid tag");
-        }
-    }
-
     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 String:
         return p->tag == c->tag;
     case FixedString:
@@ -528,6 +626,10 @@ match_datashape(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
         return c->tag == Categorical &&
                match_categorical(p->Categorical.types, p->Categorical.ntypes,
                                  c->Categorical.types, c->Categorical.ntypes);
+    case Array:
+        if (c->tag != Array) return 0;
+        if (c->Array.itemsize != p->Array.itemsize) return 0;
+        return match_datashape(p->Array.type, c->Array.type, tbl, ctx);
     case Ref:
         if (c->tag != Ref) return 0;
         return match_datashape(p->Ref.type, c->Ref.type, tbl, ctx);
@@ -536,9 +638,12 @@ match_datashape(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
         if (c->tag != Tuple) return 0;
         return match_tuple_fields(p, c, tbl, ctx);
     case Record:
-        if (p->Tuple.flag == Variadic) return 0;
+        if (p->Record.flag == Variadic) return 0;
         if (c->tag != Record) return 0;
         return match_record_fields(p, c, tbl, ctx);
+    case Union:
+        if (c->tag != Union) return 0;
+        return match_union_tags(p, c, tbl, ctx);
     case Function: {
         int64_t i;
         if (c->tag != Function ||
@@ -576,12 +681,83 @@ match_datashape(const ndt_t *p, const ndt_t *c, symtable_t *tbl,
     case Constr:
         return c->tag == Constr && strcmp(p->Constr.name, c->Constr.name) == 0 &&
                ndt_equal(p->Constr.type, c->Constr.type);
+    case VarDimElem:
+        ndt_err_format(ctx, NDT_ValueError,
+            "VarDimElem cannot occur in pattern");
+        return -1;
+    case EllipsisDim:
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "match_datashape: internal_error: unexpected EllipsisDim");
+        return -1;
     }
 
     /* NOT REACHED: tags should be exhaustive. */
     ndt_internal_error("invalid type");
 }
 
+static int
+match_datashape_top(const ndt_t *p, const ndt_t *c, int64_t linear_index,
+                    symtable_t *tbl, ndt_context_t *ctx)
+{
+    switch (p->tag) {
+    case EllipsisDim: {
+        symtable_entry_t outer;
+        const ndt_t *inner;
+        int n;
+
+        if (p->EllipsisDim.tag == RequireC && !ndt_is_c_contiguous(c)) {
+            return 0;
+        }
+        if (p->EllipsisDim.tag == RequireF && !ndt_is_f_contiguous(c)) {
+            return 0;
+        }
+
+        if (p->EllipsisDim.name == NULL) {
+            outer.tag = BroadcastSeq;
+            outer.BroadcastSeq.size = 0;
+        }
+        else if (strcmp(p->EllipsisDim.name, "var") == 0) {
+            outer.tag = VarSeq;
+            outer.VarSeq.size = 0;
+            outer.VarSeq.linear_index = linear_index;
+        }
+        else if (strcmp(p->EllipsisDim.name, "array") == 0) {
+            outer.tag = ArraySeq;
+            outer.ArraySeq.size = 0;
+        }
+        else {
+            outer.tag = FixedSeq;
+            outer.FixedSeq.size = 0;
+        }
+
+        inner = outer_inner(&outer, 0, c, p->EllipsisDim.type->ndim);
+        if (inner == NULL) {
+            return 0;
+        }
+
+        n = match_datashape(p->EllipsisDim.type, inner, tbl, ctx);
+        if (n <= 0) {
+            return n;
+        }
+
+        switch (outer.tag) {
+        case BroadcastSeq:
+            return resolve_broadcast(outer, tbl, ctx);
+        case FixedSeq:
+            return resolve_fixed(p->EllipsisDim.name, outer, tbl, ctx);
+        case VarSeq:
+            return resolve_var(outer, tbl, ctx);
+        case ArraySeq:
+            return resolve_array(outer, tbl, ctx);
+        default: /* NOT REACHED */
+            ndt_internal_error("invalid tag");
+        }
+    }
+    default:
+        return match_datashape(p, c, tbl, ctx);
+    }
+}
+
 int
 ndt_match(const ndt_t *p, const ndt_t *c, ndt_context_t *ctx)
 {
@@ -597,19 +773,18 @@ ndt_match(const ndt_t *p, const ndt_t *c, ndt_context_t *ctx)
         return -1;
     }
 
-    ret = match_datashape(p, c, tbl, ctx);
+    ret = match_datashape_top(p, c, 0, tbl, ctx);
     symtable_del(tbl);
     return ret;
 }
 
-static ndt_t *
+static const ndt_t *
 broadcast(const ndt_t *t, const int64_t *shape,
           int outer_dims, int inner_dims,
           bool use_max, ndt_context_t *ctx)
 {
     ndt_ndarray_t u;
-    const ndt_t *dtype;
-    ndt_t *v;
+    const ndt_t *v, *w;
     int64_t step;
     int ndim;
     int i, k;
@@ -619,14 +794,12 @@ broadcast(const ndt_t *t, const int64_t *shape,
         return NULL;
     }
 
-    dtype = ndt_dtype(t);
-    v = ndt_copy(dtype, ctx);
-    if (v == NULL) {
-        return NULL;
-    }
+    v = ndt_dtype(t);
+    ndt_incref(v);
 
     for (i=ndim-1; i>=ndim-inner_dims; i--) {
-        v = ndt_fixed_dim(v, u.shape[i], u.steps[i], ctx);
+        w = ndt_fixed_dim(v, u.shape[i], u.steps[i], ctx);
+        ndt_move(&v, w);
         if (v == NULL) {
             return NULL;
         }
@@ -634,7 +807,8 @@ broadcast(const ndt_t *t, const int64_t *shape,
 
     for (k=outer_dims-1; i>=0 && k>=0; i--, k--) {
         step = u.shape[i]<=1 ? 0 : u.steps[i];
-        v = ndt_fixed_dim(v, shape[k], step, ctx);
+        w = ndt_fixed_dim(v, shape[k], step, ctx);
+        ndt_move(&v, w);
         if (v == NULL) {
             return NULL;
         }
@@ -642,11 +816,12 @@ broadcast(const ndt_t *t, const int64_t *shape,
 
     for (; k>=0; k--) {
         if (use_max) {
-            v = ndt_fixed_dim(v, shape[k], INT64_MAX, ctx);
+            w = ndt_fixed_dim(v, shape[k], INT64_MAX, ctx);
         }
         else {
-            v = ndt_fixed_dim(v, shape[k], 0, ctx);
+            w = ndt_fixed_dim(v, shape[k], 0, ctx);
         }
+        ndt_move(&v, w);
         if (v == NULL) {
             return NULL;
         }
@@ -656,34 +831,44 @@ broadcast(const ndt_t *t, const int64_t *shape,
 }
 
 int
-ndt_broadcast_all(ndt_apply_spec_t *spec, const ndt_t *sig,
-                  const ndt_t *in[], const int nin,
-                  const int64_t *shape, int outer_dims,
-                  ndt_context_t *ctx)
+ndt_broadcast_all(ndt_apply_spec_t *spec, const ndt_t *sig, bool check_broadcast,
+                  const int64_t *shape, const int outer_dims, ndt_context_t *ctx)
 {
-    ndt_t *u;
+    const int nin = spec->nin;
+    const int nout = spec->nout;
     int inner_dims;
     int i;
 
     for (i = 0; i < nin; i++) {
         inner_dims = sig->Function.types[i]->ndim-1;
-        spec->broadcast[i] = broadcast(in[i], shape,
-                                       outer_dims, inner_dims, false, ctx);
-        if (spec->broadcast[i] == NULL) {
+        const ndt_t *t = spec->types[i];
+        const ndt_t *u = broadcast(t, shape, outer_dims, inner_dims, false, ctx);
+        if (u == NULL) {
             return -1;
         }
-        spec->nbroadcast++;
+        ndt_decref(t);
+        spec->types[i] = u;
     }
 
-    for (i = 0; i < spec->nout; i++) {
+    for (i = 0; i < nout; i++) {
         inner_dims = sig->Function.types[nin+i]->ndim-1;
-        u = broadcast(spec->out[i], shape,
-                      outer_dims, inner_dims, true, ctx);
+        const ndt_t *t = spec->types[nin+i];
+        const ndt_t *u = broadcast(t, shape, outer_dims, inner_dims, true, ctx);
         if (u == NULL) {
             return -1;
         }
-        ndt_del(spec->out[i]);
-        spec->out[i] = u;
+
+        if (check_broadcast) {
+            if (!ndt_equal(t, u)) {
+                ndt_err_format(ctx, NDT_ValueError,
+                    "explicit 'out' type not compatible with input types");
+                ndt_decref(u);
+                return -1;
+            }
+        }
+
+        ndt_decref(t);
+        spec->types[nin+i] = u;
     }
 
     spec->outer_dims = outer_dims;
@@ -692,8 +877,7 @@ ndt_broadcast_all(ndt_apply_spec_t *spec, const ndt_t *sig,
 }
 
 static int
-broadcast_all(ndt_apply_spec_t *spec, const ndt_t *sig,
-              const ndt_t *in[], const int nin,
+broadcast_all(ndt_apply_spec_t *spec, const ndt_t *sig, bool check_broadcast,
               const symtable_t *tbl, ndt_context_t *ctx)
 {
     symtable_entry_t v;
@@ -705,7 +889,7 @@ broadcast_all(ndt_apply_spec_t *spec, const ndt_t *sig,
         return -1;
     }
 
-    return ndt_broadcast_all(spec, sig, in, nin,
+    return ndt_broadcast_all(spec, sig, check_broadcast,
                              v.BroadcastSeq.dims, v.BroadcastSeq.size,
                              ctx);
 }
@@ -746,20 +930,23 @@ resolve_constraint(const ndt_constraint_t *c, const void *args, symtable_t *tbl,
  */
 int
 ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
-              const ndt_t *in[], const int nin,
+              const ndt_t *types[], const int64_t li[],
+              const int nin, const int nout, bool check_broadcast,
               const ndt_constraint_t *c, const void *args,
               ndt_context_t *ctx)
 {
     symtable_t *tbl;
-    ndt_t *t;
+    const ndt_t *t;
     const char *name;
-    int ret;
+    const int nargs = nin + nout;
     int64_t i;
+    int ret;
 
     assert(spec->flags == 0);
-    assert(spec->nout == 0);
-    assert(spec->nbroadcast == 0);
     assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
 
     if (sig->tag != Function) {
         ndt_err_format(ctx, NDT_ValueError,
@@ -773,8 +960,30 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
         return -1;
     }
 
-    for (i = 0; i < nin; i++) {
-        if (ndt_is_abstract(in[i])) {
+    /*
+     * Two configurations are allowed:
+     *   1) nout==0 and all 'out' types are inferred.
+     *   2) nout==sig->Function.nout and all 'out' types are given.
+     */
+    if (nout && nout != sig->Function.nout) {
+        ndt_err_format(ctx, NDT_ValueError,
+            "expected %" PRIi64 " 'out' arguments, got %d", sig->Function.nout, nout);
+        return -1;
+    }
+
+    /*
+     * Broadcast configurations:
+     *   nout==0 -> check_broadcast==false.
+     */
+    if (!nout && check_broadcast == true) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "internal error: without explicit 'out' arguments "
+            "'check_broadcast' must be false");
+        return -1;
+    }
+
+    for (i = 0; i < nargs; i++) {
+        if (ndt_is_abstract(types[i])) {
             ndt_err_format(ctx, NDT_ValueError,
                 "type checking requires concrete argument types");
             return -1;
@@ -786,8 +995,8 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
         return -1;
     }
 
-    for (i = 0; i < nin; i++) {
-        ret = match_datashape(sig->Function.types[i], in[i], tbl, ctx);
+    for (i = 0; i < nargs; i++) {
+        ret = match_datashape_top(sig->Function.types[i], types[i], li[i], tbl, ctx);
         if (ret <= 0) {
             symtable_del(tbl);
 
@@ -805,15 +1014,34 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
         return -1;
     }
 
-    for (i = 0; i < sig->Function.nout; i++) {
-        spec->out[i] = ndt_substitute(sig->Function.types[nin+i], tbl, false, ctx);
-        if (spec->out[i] == NULL) {
-            ndt_apply_spec_clear(spec);
-            symtable_del(tbl);
-            return -1;
+    spec->nin = 0;
+    for (i = 0; i < nin; i++) {
+        ndt_incref(types[i]);
+        spec->types[i] = types[i];
+        spec->nin++;
+    }
+
+    spec->nout = 0;
+    if (nout == 0) {
+        /* Infer the return types. */
+        for (i = 0; i < sig->Function.nout; i++) {
+            spec->types[nin+i] = ndt_substitute(sig->Function.types[nin+i], tbl, false, ctx);
+            if (spec->types[nin+i] == NULL) {
+                ndt_apply_spec_clear(spec);
+                symtable_del(tbl);
+                return -1;
+            }
+            spec->nout++;
+        }
+    }
+    else {
+        for (i = 0; i < nout; i++) {
+            ndt_incref(types[nin+i]);
+            spec->types[nin+i] = types[nin+i];
+            spec->nout++;
         }
-        spec->nout++;
     }
+    spec->nargs = spec->nin + spec->nout;
 
     if (sig->flags & NDT_ELLIPSIS) {
         if (sig->Function.nargs == 0 || sig->Function.types[0]->tag != EllipsisDim) {
@@ -833,8 +1061,17 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
             case FixedSeq:
                 spec->outer_dims = v.FixedSeq.size;
                 break;
-            case VarSeq:
-                spec->outer_dims = v.VarSeq.size;
+            case VarSeq: {
+                if (v.VarSeq.size > 0) {
+                    spec->outer_dims = ndt_logical_ndim(v.VarSeq.dims[0]);
+                }
+                else {
+                    spec->outer_dims = 0;
+                }
+                break;
+            }
+            case ArraySeq:
+                spec->outer_dims = v.ArraySeq.size;
                 break;
             default:
                 ndt_err_format(ctx, NDT_RuntimeError,
@@ -845,7 +1082,7 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
             }
         }
         else {
-            if (broadcast_all(spec, sig, in, nin, tbl, ctx) < 0) {
+            if (broadcast_all(spec, sig, check_broadcast, tbl, ctx) < 0) {
                 ndt_apply_spec_clear(spec);
                 symtable_del(tbl);
                 return -1;
@@ -855,31 +1092,33 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
 
     symtable_del(tbl);
 
-    for (i = 0; i < sig->Function.nout; i++) {
-        ndt_t *_p = sig->Function.types[nin+i];
-        ndt_t *_c = spec->out[i];
-        ndt_t *_t = to_fortran(_p, _c, ctx);
-        if (_t == NULL) {
-            ndt_apply_spec_clear(spec);
-            return -1;
-        }
-        if (_t != _c) {
-            ndt_del(_c);
+    if (nout == 0) {
+        for (i = 0; i < sig->Function.nout; i++) {
+           const ndt_t *_p = sig->Function.types[nin+i];
+           const ndt_t *_c = spec->types[nin+i];
+           const ndt_t *_t = to_fortran(_p, _c, ctx);
+
+           if (_t == NULL) {
+              ndt_apply_spec_clear(spec);
+              return -1;
+           }
+
+            ndt_decref(_c);
+            spec->types[nin+i] = _t;
         }
-        spec->out[i] = _t;
     }
 
-    if (!check_contig(sig->Function.types, (ndt_t **)in, nin)) {
+    if (!check_contig(sig->Function.types, types, nargs)) {
         ndt_err_format(ctx, NDT_TypeError, "argument types do not match");
+        ndt_apply_spec_clear(spec);
         return -1;
     }
-    if (!check_contig(sig->Function.types+nin, spec->out, spec->nout)) {
-        ndt_err_format(ctx, NDT_TypeError, "argument types do not match");
+
+    if (ndt_select_kernel_strategy(spec, ctx) < 0) {
+        ndt_apply_spec_clear(spec);
         return -1;
     }
 
-    ndt_select_kernel_strategy(spec, sig, in, nin);
-
     return 0;
 }
 
@@ -888,11 +1127,11 @@ ndt_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
 /*                  Optimized binary typecheck for fixed input               */
 /*****************************************************************************/
 
-static ndt_t *
-binary_broadcast_1D(const ndt_ndarray_t *t, const ndt_t *dtype,
-                    const int64_t *shape, int size, ndt_context_t *ctx)
+static const ndt_t *
+fast_broadcast(const ndt_ndarray_t *t, const ndt_t *dtype,
+               const int64_t *shape, int size, ndt_context_t *ctx)
 {
-    ndt_t *v;
+    const ndt_t *v;
     int64_t step;
     int i, k;
 
@@ -903,14 +1142,18 @@ binary_broadcast_1D(const ndt_ndarray_t *t, const ndt_t *dtype,
 
     for (i=t->ndim-1, k=size-1; i>=0 && k>=0; i--, k--) {
         step = t->shape[i]<=1 ? 0 : t->steps[i];
-        v = ndt_fixed_dim(v, shape[k], step, ctx);
+        const ndt_t *w = ndt_fixed_dim(v, shape[k], step, ctx);
+        ndt_decref(v);
+        v = w;
         if (v == NULL) {
             return NULL;
         }
     }
 
     for (; k>=0; k--) {
-        v = ndt_fixed_dim(v, shape[k], 0, ctx);
+        const ndt_t *w = ndt_fixed_dim(v, shape[k], 0, ctx);
+        ndt_decref(v);
+        v = w;
         if (v == NULL) {
             return NULL;
         }
@@ -919,15 +1162,19 @@ binary_broadcast_1D(const ndt_ndarray_t *t, const ndt_t *dtype,
     return v;
 }
 
-static ndt_t *
-fixed_dim_from_shape(const int64_t shape[], int len, ndt_t *dtype,
+static const ndt_t *
+fixed_dim_from_shape(const int64_t shape[], int len, const ndt_t *dtype,
                      ndt_context_t *ctx)
 {
-    ndt_t *t;
+    const ndt_t *t;
     int i;
 
+    ndt_incref(dtype);
+
     for (i=len-1, t=dtype; i >= 0; i--) {
-        t = ndt_fixed_dim(t, shape[i], INT64_MAX, ctx);
+        const ndt_t *u = ndt_fixed_dim(t, shape[i], INT64_MAX, ctx);
+        ndt_decref(t);
+        t = u;
         if (t == NULL) {
             return NULL;
         }
@@ -936,83 +1183,313 @@ fixed_dim_from_shape(const int64_t shape[], int len, ndt_t *dtype,
     return t;
 }
 
-static bool
-shape_equal(const ndt_ndarray_t *a, const ndt_ndarray_t *b)
+static int
+broadcast_error(const char *msg, ndt_context_t *ctx)
 {
-    if (b->ndim != a->ndim) {
-        return false;
+    ndt_err_format(ctx, NDT_TypeError, "%s", msg);
+    return -1;
+}
+
+static int
+_ndt_unary_broadcast(ndt_apply_spec_t *spec,
+                     const ndt_ndarray_t *x, const ndt_t *dtype_x,
+                     const ndt_t *out, const ndt_t *dtype_out,
+                     const bool check_broadcast, const int inner,
+                     ndt_context_t *ctx)
+{
+    int64_t shape[NDT_MAX_DIM];
+    int size = x->ndim;
+    ndt_ndarray_t y;
+    const ndt_t *t;
+
+    for (int i = 0; i < size; i++) {
+        shape[i] = x->shape[i];
     }
 
-    for (int i = 0; i < a->ndim; i++) {
-        if (b->shape[i] != a->shape[i]) {
-            return false;
+    if (out != NULL) {
+        if (ndt_as_ndarray(&y, out, ctx) < 0) {
+            return -1;
         }
+
+        size = _resolve_broadcast(shape, size, y.shape, y.ndim);
+        if (size < 0) {
+            return broadcast_error("could not broadcast output argument", ctx);
+        }
+    }
+
+    spec->types[0] = fast_broadcast(x, dtype_x, shape, size, ctx);
+    if (spec->types[0] == NULL) {
+        return -1;
+    }
+
+    if (out != NULL) {
+        if (check_broadcast) {
+            t = fixed_dim_from_shape(shape, size, dtype_out, ctx);
+            if (t == NULL) {
+                ndt_decref(spec->types[0]);
+                return -1;
+            }
+
+            if (!ndt_equal(t, out)) {
+                ndt_err_format(ctx, NDT_ValueError,
+                    "explicit 'out' type not compatible with input types");
+                ndt_decref(spec->types[0]);
+                ndt_decref(t);
+                return -1;
+            }
+        }
+        else {
+            t = fast_broadcast(&y, dtype_out, shape, size, ctx);
+            if (t == NULL) {
+                ndt_decref(spec->types[0]);
+                return -1;
+            }
+        }
+    }
+    else {
+        t = fixed_dim_from_shape(shape, size, dtype_out, ctx);
+        if (t == NULL) {
+            ndt_decref(spec->types[0]);
+            return -1;
+        }
+    }
+    spec->types[1] = t;
+
+    spec->outer_dims = size-inner;
+    spec->nin = 1;
+    spec->nout = 1;
+    spec->nargs = 2;
+
+    if (ndt_select_kernel_strategy(spec, ctx) < 0) {
+        ndt_apply_spec_clear(spec);
+        return -1;
+    }
+
+    return 0;
+}
+
+static bool
+unary_all_ellipses(const ndt_t *t0, const ndt_t *t1, ndt_context_t *ctx)
+{
+    if ((t0->tag != EllipsisDim || t0->EllipsisDim.name != NULL) ||
+        (t1->tag != EllipsisDim || t1->EllipsisDim.name != NULL)) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "fast unary typecheck expects leading ellipsis dimensions");
+        return false;
     }
 
     return true;
 }
 
-static int
-_ndt_binary_broadcast(ndt_apply_spec_t *spec, const ndt_t *sig,
-                      const ndt_ndarray_t *x, const ndt_ndarray_t *y,
-                      const ndt_t *in[], const int nin, ndt_t *dtype,
-                      int inner, ndt_context_t *ctx)
+static bool
+unary_all_same_symbol(const ndt_t *t0, const ndt_t *t1)
 {
-    int64_t shape[NDT_MAX_DIM];
-    int size;
-
-    if (shape_equal(x, y)) {
-        spec->nout = 1;
-        spec->nbroadcast = 0;
-        spec->outer_dims = x->ndim-inner;
-        spec->out[0] = fixed_dim_from_shape(x->shape, x->ndim, dtype, ctx);
-        if (spec->out[0] == NULL) {
-            return -1;
-        }
+    if (t0->tag != SymbolicDim || t1->tag != SymbolicDim) {
+        return false;
     }
-    else {
-        for (int i = 0; i < x->ndim; i++) {
-            shape[i] = x->shape[i];
+
+    return strcmp(t0->SymbolicDim.name, t1->SymbolicDim.name) == 0;
+}
+
+static bool
+unary_all_ndim0(const ndt_t *t0, const ndt_t *t1)
+{
+    return t0->ndim == 0 && t1->ndim == 0;
+}
+
+/*
+ * Optimized type checking for very specific signatures. The caller must
+ * have identified the kernel location and the signature.  For performance
+ * reasons, no substitution is performed on the dtype, so the dtype must be
+ * concrete.
+ *
+ * Supported signature: 1) ... * T0 -> ... * T1
+ */
+int
+ndt_fast_unary_fixed_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
+                               const ndt_t *types[], const int nin, const int nout,
+                               const bool check_broadcast, ndt_context_t *ctx)
+{
+    const ndt_t *p0, *p1;
+    ndt_ndarray_t x;
+    const ndt_t *out = NULL;
+    const ndt_t *dtype = NULL;
+
+    assert(spec->flags == 0);
+    assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
+
+    if (sig->tag != Function ||
+        sig->Function.nin != 1) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "fast unary typecheck expects a signature with one input and "
+            "one output");
+        return -1;
+    }
+
+    if (nin != 1) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "fast unary typecheck expects one input argument");
+        return -1;
+    }
+
+    p0 = sig->Function.types[0];
+    p1 = sig->Function.types[1];
+
+    if (nout) {
+        if (nout != 1) {
+            ndt_err_format(ctx, NDT_RuntimeError,
+                "fast unary typecheck expects at most one explicit out argument");
+            return -1;
         }
+        out = types[1];
+        dtype = ndt_dtype(types[1]);
 
-        size = _resolve_broadcast(shape, x->ndim, y->shape, y->ndim);
-        if (size < 0) {
-            ndt_err_format(ctx, NDT_TypeError, "broadcast error");
-            ndt_del(dtype);
+        if (!ndt_equal(dtype, ndt_dtype(p1))) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "dtype of the out argument does not match");
             return -1;
         }
+    }
+    else {
+        dtype = ndt_dtype(sig->Function.types[1]);
+    }
+
+    if (ndt_is_abstract(dtype)) {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "fast unary typecheck expects a concrete dtype");
+        return -1;
+    }
+
+    if (!unary_all_ellipses(p0, p1, ctx)) {
+        return -1;
+    }
+
+    if (ndt_as_ndarray(&x, types[0], ctx) < 0) {
+        return -1;
+    }
+
+    p0 = p0->EllipsisDim.type;
+    p1 = p1->EllipsisDim.type;
+
+    if (unary_all_same_symbol(p0, p1)) {
+        return _ndt_unary_broadcast(spec,
+                                    &x, ndt_dtype(types[0]),
+                                    out, dtype, check_broadcast,
+                                    1, ctx);
+    }
+    else if (unary_all_ndim0(p0, p1)) {
+        return _ndt_unary_broadcast(spec,
+                                    &x, ndt_dtype(types[0]),
+                                    out, dtype, check_broadcast,
+                                    0, ctx);
+    }
+    else {
+        ndt_err_format(ctx, NDT_RuntimeError,
+            "unsupported signature in fast unary typecheck");
+        return -1;
+    }
+}
+
+static int
+_ndt_binary_broadcast(ndt_apply_spec_t *spec,
+                      const ndt_ndarray_t *x, const ndt_t *dtype_x,
+                      const ndt_ndarray_t *y, const ndt_t *dtype_y,
+                      const ndt_t *out, const ndt_t *dtype_out,
+                      const bool check_broadcast, const int inner,
+                      ndt_context_t *ctx)
+{
+    int64_t shape[NDT_MAX_DIM];
+    int size = x->ndim;
+    ndt_ndarray_t z;
+    const ndt_t *t;
 
-        spec->nout = 1;
-        spec->nbroadcast = 2;
-        spec->outer_dims = size-inner;
+    for (int i = 0; i < size; i++) {
+        shape[i] = x->shape[i];
+    }
+
+    size = _resolve_broadcast(shape, size, y->shape, y->ndim);
+    if (size < 0) {
+        return broadcast_error("could not broadcast input arguments", ctx);
+    }
 
-        spec->out[0] = fixed_dim_from_shape(shape, size, dtype, ctx);
-        if (spec->out[0] == NULL) {
+    if (out != NULL) {
+        if (ndt_as_ndarray(&z, out, ctx) < 0) {
             return -1;
         }
 
-        spec->broadcast[0] = binary_broadcast_1D(x, ndt_dtype(in[0]), shape, size, ctx);
-        if (spec->broadcast[0] == NULL) {
-            ndt_del(spec->out[0]);
-            return -1;
+        size = _resolve_broadcast(shape, size, z.shape, z.ndim);
+        if (size < 0) {
+            return broadcast_error("could not broadcast output argument", ctx);
         }
+    }
+
+    spec->types[0] = fast_broadcast(x, dtype_x, shape, size, ctx);
+    if (spec->types[0] == NULL) {
+        return -1;
+    }
+
+    spec->types[1] = fast_broadcast(y, dtype_y, shape, size, ctx);
+    if (spec->types[1] == NULL) {
+        ndt_decref(spec->types[0]);
+        return -1;
+    }
+
+    if (out != NULL) {
+        if (check_broadcast) {
+            t = fixed_dim_from_shape(shape, size, dtype_out, ctx);
+            if (t == NULL) {
+                ndt_decref(spec->types[0]);
+                ndt_decref(spec->types[1]);
+                return -1;
+            }
 
-        spec->broadcast[1] = binary_broadcast_1D(y, ndt_dtype(in[1]), shape, size, ctx);
-        if (spec->broadcast[1] == NULL) {
-            ndt_del(spec->out[0]);
-            ndt_del(spec->broadcast[0]);
+            if (!ndt_equal(t, out)) {
+                ndt_err_format(ctx, NDT_ValueError,
+                    "explicit 'out' type not compatible with input types");
+                ndt_decref(spec->types[0]);
+                ndt_decref(spec->types[1]);
+                ndt_decref(t);
+                return -1;
+            }
+        }
+        else {
+            t = fast_broadcast(&z, dtype_out, shape, size, ctx);
+            if (t == NULL) {
+                ndt_decref(spec->types[0]);
+                ndt_decref(spec->types[1]);
+                return -1;
+            }
+        }
+    }
+    else {
+        t = fixed_dim_from_shape(shape, size, dtype_out, ctx);
+        if (t == NULL) {
+            ndt_decref(spec->types[0]);
+            ndt_decref(spec->types[1]);
             return -1;
         }
     }
+    spec->types[2] = t;
 
-    ndt_select_kernel_strategy(spec, sig, in, nin);
+    spec->outer_dims = size-inner;
+    spec->nin = 2;
+    spec->nout = 1;
+    spec->nargs = 3;
+
+    if (ndt_select_kernel_strategy(spec, ctx) < 0) {
+        ndt_apply_spec_clear(spec);
+        return -1;
+    }
 
     return 0;
 }
 
 static bool
-all_ellipses(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2,
-             ndt_context_t *ctx)
+binary_all_ellipses(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2,
+                    ndt_context_t *ctx)
 {
     if ((t0->tag != EllipsisDim || t0->EllipsisDim.name != NULL) ||
         (t1->tag != EllipsisDim || t1->EllipsisDim.name != NULL) ||
@@ -1026,7 +1503,7 @@ all_ellipses(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2,
 }
 
 static bool
-all_same_symbol(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2)
+binary_all_same_symbol(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2)
 {
     if (t0->tag != SymbolicDim || t1->tag != SymbolicDim ||
         t2->tag != SymbolicDim) {
@@ -1038,37 +1515,37 @@ all_same_symbol(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2)
 }
 
 static bool
-all_ndim0(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2)
+binary_all_ndim0(const ndt_t *t0, const ndt_t *t1, const ndt_t *t2)
 {
     return t0->ndim == 0 && t1->ndim == 0 && t2->ndim == 0;
 }
 
 /*
  * Optimized type checking for very specific signatures. The caller must
- * have identified the kernel location, signature and the dtype.  For
- * performance reasons, no substitution is performed on the dtype, so
- * the dtype must be concrete.
+ * have identified the kernel location and the signature.  For performance
+ * reasons, no substitution is performed on the dtype, so the dtype must be
+ * concrete.
  *
- * Supported signatures:
- *   1) ... * N * T0, ... * N * T1 -> N * T2
- *   2) ... * T0, ... * T1 -> ... * T2
+ * Supported signature: 1) ... * T0, ... * T1 -> ... * T2
  */
 int
 ndt_fast_binary_fixed_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
-                                const ndt_t *in[], const int nin, ndt_t *dtype,
-                                ndt_context_t *ctx)
+                                const ndt_t *types[], const int nin, const int nout,
+                                const bool check_broadcast, ndt_context_t *ctx)
 {
-    ndt_t *p0, *p1, *p2;
+    const ndt_t *p0, *p1, *p2;
     ndt_ndarray_t x, y;
+    const ndt_t *out = NULL;
+    const ndt_t *dtype = NULL;
 
     assert(spec->flags == 0);
-    assert(spec->nout == 0);
-    assert(spec->nbroadcast == 0);
     assert(spec->outer_dims == 0);
+    assert(spec->nin == 0);
+    assert(spec->nout == 0);
+    assert(spec->nargs == 0);
 
     if (sig->tag != Function ||
-        sig->Function.nin != 2 ||
-        sig->Function.nout != 1) {
+        sig->Function.nin != 2) {
         ndt_err_format(ctx, NDT_RuntimeError,
             "fast binary typecheck expects a signature with two inputs and "
             "one output");
@@ -1081,27 +1558,44 @@ ndt_fast_binary_fixed_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
         return -1;
     }
 
+    p0 = sig->Function.types[0];
+    p1 = sig->Function.types[1];
+    p2 = sig->Function.types[2];
+
+    if (nout) {
+        if (nout != 1) {
+            ndt_err_format(ctx, NDT_RuntimeError,
+                "fast binary typecheck expects at most one explicit out argument");
+            return -1;
+        }
+        out = types[2];
+        dtype = ndt_dtype(types[2]);
+
+        if (!ndt_equal(dtype, ndt_dtype(p2))) {
+            ndt_err_format(ctx, NDT_ValueError,
+                "dtype of the out argument does not match");
+            return -1;
+        }
+    }
+    else {
+        dtype = ndt_dtype(sig->Function.types[2]);
+    }
+
     if (ndt_is_abstract(dtype)) {
         ndt_err_format(ctx, NDT_RuntimeError,
             "fast binary typecheck expects a concrete dtype");
         return -1;
     }
 
-    p0 = sig->Function.types[0];
-    p1 = sig->Function.types[1];
-    p2 = sig->Function.types[2];
-
-    if (!all_ellipses(p0, p1, p2, ctx)) {
+    if (!binary_all_ellipses(p0, p1, p2, ctx)) {
         return -1;
     }
 
-    if (ndt_as_ndarray(&x, in[0], ctx) < 0) {
-        ndt_del(dtype);
+    if (ndt_as_ndarray(&x, types[0], ctx) < 0) {
         return -1;
     }
 
-    if (ndt_as_ndarray(&y, in[1], ctx) < 0) {
-        ndt_del(dtype);
+    if (ndt_as_ndarray(&y, types[1], ctx) < 0) {
         return -1;
     }
 
@@ -1109,20 +1603,27 @@ ndt_fast_binary_fixed_typecheck(ndt_apply_spec_t *spec, const ndt_t *sig,
     p1 = p1->EllipsisDim.type;
     p2 = p2->EllipsisDim.type;
 
-    if (all_same_symbol(p0, p1, p2)) {
+    if (binary_all_same_symbol(p0, p1, p2)) {
         if (x.ndim > 0 && y.ndim > 0) {
             const int64_t xshape = x.shape[x.ndim-1];
             const int64_t yshape = y.shape[y.ndim-1];
             if (xshape != 1 && yshape != 1 && xshape != yshape) {
                 ndt_err_format(ctx, NDT_TypeError, "mismatch in inner dimensions");
-                ndt_del(dtype);
                 return -1;
             }
         }
-        return _ndt_binary_broadcast(spec, sig, &x, &y, in, nin, dtype, 1, ctx);
-    }
-    else if (all_ndim0(p0, p1, p2)) {
-        return _ndt_binary_broadcast(spec, sig, &x, &y, in, nin, dtype, 0, ctx);
+        return _ndt_binary_broadcast(spec,
+                                     &x, ndt_dtype(types[0]),
+                                     &y, ndt_dtype(types[1]),
+                                     out, dtype, check_broadcast,
+                                     1, ctx);
+    }
+    else if (binary_all_ndim0(p0, p1, p2)) {
+        return _ndt_binary_broadcast(spec,
+                                     &x, ndt_dtype(types[0]),
+                                     &y, ndt_dtype(types[1]),
+                                     out, dtype, check_broadcast,
+                                     0, ctx);
     }
     else {
         ndt_err_format(ctx, NDT_RuntimeError,