RFC: Allow tuples as type parameters.

doc/manual/types.rst

@@ -1,7 +1,7 @@
 .. _man-types:
 
 *********
- Types    
+ Types
 *********
 
 Type systems have traditionally fallen into two quite different camps:
@@ -61,7 +61,7 @@ Julia's type system that should be mentioned up front are:
 -  Only values, not variables, have types — variables are simply names
    bound to values.
 -  Both abstract and concrete types can be paramaterized by other types
-   and by certain other values (currently integers and symbols).
+   and by certain other values (currently integers, symbols, bools, and tuples thereof).
    Type parameters may be completely omitted when they
    do not need to be referenced or restricted.
 
@@ -1153,4 +1153,3 @@ If you apply ``super`` to other type objects (or non-type objects), a
 
     julia> super((Float64,Int64))
     ERROR: no method super(Type{(Float64,Int64)})
-

src/jltypes.c

@@ -1447,8 +1447,18 @@ int jl_types_equal_generic(jl_value_t *a, jl_value_t *b, int useenv)
 
 static int valid_type_param(jl_value_t *v)
 {
-    // TODO: maybe more things
-    return jl_is_type(v) || jl_is_long(v) || jl_is_symbol(v) || jl_is_typevar(v) || jl_is_bool(v);
+    if (jl_is_tuple(v)) {
+        size_t i;
+        size_t l = jl_tuple_len(v);
+        for(i=0; i < l; i++) {
+            if (!valid_type_param(jl_tupleref(v,i)))
+                return 0;
+        }
+        return 1;
+    } else {
+        // TODO: maybe more things
+        return jl_is_type(v) || jl_is_long(v) || jl_is_symbol(v) || jl_is_typevar(v) || jl_is_bool(v);
+    }
 }
 
 jl_value_t *jl_apply_type_(jl_value_t *tc, jl_value_t **params, size_t n)

test/core.jl

@@ -1181,6 +1181,7 @@ end
 f5150(T) = Array(Rational{T},1)
 @test typeof(f5150(Int)) === Array{Rational{Int},1}
 
+
 # issue #5165
 bitstype 64 T5165{S}
 make_t(x::Int64) = Base.box(T5165{Nothing}, Base.unbox(Int64, x))
@@ -1189,3 +1190,26 @@ b5165 = IOBuffer()
 for x in xs5165
     println(b5165, x)   # segfaulted
 end
+
+# support tuples as type parameters
+
+type TupleParam{P}
+    x::Bool
+end
+
+function tupledispatch(a::TupleParam{(1,:a)})
+    a.x
+end
+
+let
+    # tuples can be used as type params
+    t1 = TupleParam{(1,:a)}(true)
+    t2 = TupleParam{(1,:b)}(true)
+
+    # tuple type params can't contain invalid type params
+    @test_throws t3 = TupleParam{(1,"nope")}(true)
+
+    # dispatch works properly
+    @test tupledispatch(t1) == true
+    @test_throws tupledispatch(t2)
+end