type system revision and new subtype algorithm

NEWS.md

@@ -4,6 +4,19 @@ Julia v0.6.0 Release Notes
 New language features
 ---------------------
 
+  * New type system capabilities ([#8974], [#18457])
+    * Type parameter constraints can refer to previous parameters, e.g.
+      `type Foo{R<:Real, A<:AbstractArray{R}}`. Can also be used in method definitions.
+    * New syntax `Array{T} where T<:Integer`, indicating a union of types over all
+      specified values of `T` (represented by a `UnionAll` type). This provides behavior
+      similar to parametric methods or `typealias`, but can be used anywhere a type is
+      accepted. This syntax can also be used in method definitions, e.g.
+      `function inv(M::Matrix{T}) where T<:AbstractFloat`.
+      Anonymous functions can have type parameters via the syntax
+      `((x::Array{T}) where T<:Real) -> 2x`.
+    * Much more accurate subtype and type intersection algorithms. Method sorting and
+      identification of equivalent and ambiguous methods are improved as a result.
+
 Language changes
 ----------------
 
@@ -103,6 +116,16 @@ This section lists changes that do not have deprecation warnings.
      special 1×n-sized `AbstractMatrix`), not a `Matrix`, etc. In particular, for
      `v::AbstractVector` we now have `(v.').' === v` and `v.' * v` is a scalar. ([#19670])
 
+  * Parametric types with "unspecified" parameters, such as `Array`, are now represented
+    as `UnionAll` types instead of `DataType`s ([#18457]).
+
+  * `Union` types have two fields, `a` and `b`, instead of a single `types` field.
+    The empty type `Union{}` is represented by a singleton of type `BottomType` ([#18457]).
+
+  * The type `NTuple{N}` now refers to tuples where every element has the same type
+    (since it is shorthand for `NTuple{N,T} where T`). To get the old behavior of matching
+    any tuple, use `NTuple{N,Any}` ([#18457]).
+
 Library improvements
 --------------------
 

base/REPLCompletions.jl

@@ -315,7 +315,7 @@ function get_type(sym, fn)
 end
 # Method completion on function call expression that look like :(max(1))
 function complete_methods(ex_org::Expr)
-    args_ex = DataType[]
+    args_ex = Any[]
     func, found = get_value(ex_org.args[1], Main)
     !found && return String[]
     for ex in ex_org.args[2:end]
@@ -330,7 +330,8 @@ function complete_methods(ex_org::Expr)
     io = IOBuffer()
     for method in ml
         # Check if the method's type signature intersects the input types
-        if typeintersect(Tuple{method.sig.parameters[1 : min(na, end)]...}, t_in) != Union{}
+        ms = method.sig
+        if typeintersect(Base.rewrap_unionall(Tuple{Base.unwrap_unionall(ms).parameters[1 : min(na, end)]...}, ms), t_in) != Union{}
             show(io, method, kwtype=kwtype)
             push!(out, String(take!(io)))
         end

base/abstractarray.jl

@@ -89,8 +89,7 @@ julia> extrema(b)
 """
 linearindices(A)                 = (@_inline_meta; OneTo(_length(A)))
 linearindices(A::AbstractVector) = (@_inline_meta; indices1(A))
-eltype{T}(::Type{AbstractArray{T}}) = T
-eltype{T,N}(::Type{AbstractArray{T,N}}) = T
+eltype(::Type{A}) where A<:AbstractArray{E} where E  = E
 elsize{T}(::AbstractArray{T}) = sizeof(T)
 
 """
@@ -204,7 +203,7 @@ julia> strides(A)
 ```
 """
 strides(A::AbstractArray) = _strides((1,), A)
-_strides{T,N}(out::NTuple{N}, A::AbstractArray{T,N}) = out
+_strides{T,N}(out::NTuple{N,Any}, A::AbstractArray{T,N}) = out
 function _strides{M,T,N}(out::NTuple{M}, A::AbstractArray{T,N})
     @_inline_meta
     _strides((out..., out[M]*size(A, M)), A)
@@ -267,6 +266,7 @@ should define `linearindexing` in the type-domain:
     Base.linearindexing{T<:MyArray}(::Type{T}) = Base.LinearFast()
 """
 linearindexing(A::AbstractArray) = linearindexing(typeof(A))
+linearindexing(::Type{Union{}}) = LinearFast()
 linearindexing{T<:AbstractArray}(::Type{T}) = LinearSlow()
 linearindexing{T<:Array}(::Type{T}) = LinearFast()
 linearindexing{T<:Range}(::Type{T}) = LinearFast()
@@ -997,8 +997,6 @@ promote_eltype(v1, vs...) = promote_type(eltype(v1), promote_eltype(vs...))
 #TODO: ERROR CHECK
 cat(catdim::Integer) = Array{Any,1}(0)
 
-vcat() = Array{Any,1}(0)
-hcat() = Array{Any,1}(0)
 typed_vcat{T}(::Type{T}) = Array{T,1}(0)
 typed_hcat{T}(::Type{T}) = Array{T,1}(0)
 

base/array.jl

@@ -1005,6 +1005,10 @@ end
 
 
 # concatenations of homogeneous combinations of vectors, horizontal and vertical
+
+vcat() = Array{Any,1}(0)
+hcat() = Array{Any,1}(0)
+
 function hcat{T}(V::Vector{T}...)
     height = length(V[1])
     for j = 2:length(V)

base/boot.jl

@@ -31,7 +31,8 @@
 #end
 
 #type Union <: Type
-#    types::Tuple
+#    a
+#    b
 #end
 
 #type TypeVar
@@ -40,8 +41,8 @@
 #    ub::Type
 #end
 
-#type TypeConstructor
-#    parameters::Tuple
+#type UnionAll
+#    var::TypeVar
 #    body
 #end
 
@@ -120,7 +121,7 @@ import Core.Intrinsics.ccall
 export
     # key types
     Any, DataType, Vararg, ANY, NTuple,
-    Tuple, Type, TypeConstructor, TypeName, TypeVar, Union, Void,
+    Tuple, Type, UnionAll, TypeName, TypeVar, Union, Void,
     SimpleVector, AbstractArray, DenseArray,
     # special objects
     Function, CodeInfo, Method, MethodTable, TypeMapEntry, TypeMapLevel,
@@ -258,18 +259,11 @@ end
 TypeVar(n::Symbol) =
     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, Any)
 TypeVar(n::Symbol, ub::ANY) =
-    (isa(ub,Bool) ?
-     ccall(:jl_new_typevar_, Ref{TypeVar}, (Any, Any, Any, Any), n, Union{}, Any, ub) :
-     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, ub::Type))
+    ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, Union{}, ub)
 TypeVar(n::Symbol, lb::ANY, ub::ANY) =
-    (isa(ub,Bool) ?
-     ccall(:jl_new_typevar_, Ref{TypeVar}, (Any, Any, Any, Any), n, Union{}, lb::Type, ub) :
-     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, lb::Type, ub::Type))
-TypeVar(n::Symbol, lb::ANY, ub::ANY, b::Bool) =
-    ccall(:jl_new_typevar_, Ref{TypeVar}, (Any, Any, Any, Any), n, lb::Type, ub::Type, b)
-
-TypeConstructor(p::ANY, t::ANY) =
-    ccall(:jl_new_type_constructor, Ref{TypeConstructor}, (Any, Any), p::SimpleVector, t::Type)
+    ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, lb, ub)
+
+UnionAll(v::TypeVar, t::ANY) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
 
 Void() = nothing
 

base/broadcast.jl

@@ -14,7 +14,7 @@ typealias ScalarType Union{Type{Any}, Type{Nullable}}
 ## Broadcasting utilities ##
 # fallbacks for some special cases
 @inline broadcast(f, x::Number...) = f(x...)
-@inline broadcast{N}(f, t::NTuple{N}, ts::Vararg{NTuple{N}}) = map(f, t, ts...)
+@inline broadcast{N}(f, t::NTuple{N,Any}, ts::Vararg{NTuple{N,Any}}) = map(f, t, ts...)
 
 # special cases for "X .= ..." (broadcast!) assignments
 broadcast!(::typeof(identity), X::AbstractArray, x::Number) = fill!(X, x)

base/deprecated.jl

@@ -125,14 +125,14 @@ end
 @deprecate get_rounding rounding
 
 #13465
-@deprecate cov(x::AbstractVector; corrected=true, mean=Base.mean(x)) Base.covm(x, mean, corrected)
-@deprecate cov(X::AbstractMatrix; vardim=1, corrected=true, mean=Base.mean(X, vardim)) Base.covm(X, mean, vardim, corrected)
-@deprecate cov(x::AbstractVector, y::AbstractVector; corrected=true, mean=(Base.mean(x), Base.mean(y))) Base.covm(x, mean[1], y, mean[2], corrected)
+#@deprecate cov(x::AbstractVector; corrected=true, mean=Base.mean(x)) Base.covm(x, mean, corrected)
+#@deprecate cov(X::AbstractMatrix; vardim=1, corrected=true, mean=Base.mean(X, vardim)) Base.covm(X, mean, vardim, corrected)
+#@deprecate cov(x::AbstractVector, y::AbstractVector; corrected=true, mean=(Base.mean(x), Base.mean(y))) Base.covm(x, mean[1], y, mean[2], corrected)
 @deprecate cov(X::AbstractVecOrMat, Y::AbstractVecOrMat; vardim=1, corrected=true, mean=(Base.mean(X, vardim), Base.mean(Y, vardim))) Base.covm(X, mean[1], Y, mean[2], vardim, corrected)
 
-@deprecate cor(x::AbstractVector; mean=Base.mean(x)) Base.corm(x, mean)
-@deprecate cor(X::AbstractMatrix; vardim=1, mean=Base.mean(X, vardim)) Base.corm(X, mean, vardim)
-@deprecate cor(x::AbstractVector, y::AbstractVector; mean=(Base.mean(x), Base.mean(y))) Base.corm(x, mean[1], y, mean[2])
+#@deprecate cor(x::AbstractVector; mean=Base.mean(x)) Base.corm(x, mean)
+#@deprecate cor(X::AbstractMatrix; vardim=1, mean=Base.mean(X, vardim)) Base.corm(X, mean, vardim)
+#@deprecate cor(x::AbstractVector, y::AbstractVector; mean=(Base.mean(x), Base.mean(y))) Base.corm(x, mean[1], y, mean[2])
 @deprecate cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; vardim=1, mean=(Base.mean(X, vardim), Base.mean(Y, vardim))) Base.corm(X, mean[1], Y, mean[2], vardim)
 
 @deprecate_binding SparseMatrix SparseArrays
@@ -315,8 +315,8 @@ for (Fun, func) in [(:IdFun, :identity),
         (::Type{typeof($(func))})() = $(func)
     end
 end
-@deprecate_binding CentralizedAbs2Fun typeof(centralizedabs2fun(0)).name.primary
-(::Type{typeof(centralizedabs2fun(0)).name.primary})(m::Number) = centralizedabs2fun(m)
+@deprecate_binding CentralizedAbs2Fun typeof(centralizedabs2fun(0)).name.wrapper
+(::Type{typeof(centralizedabs2fun(0)).name.wrapper})(m::Number) = centralizedabs2fun(m)
 @deprecate specialized_unary(f::Function) f
 @deprecate specialized_binary(f::Function) f
 @deprecate specialized_bitwise_unary(f::Function) f

base/dict.jl

@@ -137,15 +137,14 @@ const AnyDict = Dict{Any,Any}
 
 Dict{K,V}(ps::Pair{K,V}...)            = Dict{K,V}(ps)
 Dict{K  }(ps::Pair{K}...,)             = Dict{K,Any}(ps)
-Dict{V  }(ps::Pair{TypeVar(:K),V}...,) = Dict{Any,V}(ps)
+Dict{V  }(ps::(Pair{K,V} where K)...,) = Dict{Any,V}(ps)
 Dict(     ps::Pair...)                 = Dict{Any,Any}(ps)
 
 function Dict(kv)
     try
-        Base.associative_with_eltype(Dict, kv, eltype(kv))
+        associative_with_eltype((K, V) -> Dict{K, V}, kv, eltype(kv))
     catch e
-        if any(x->isempty(methods(x, (typeof(kv),))), [start, next, done]) ||
-            !all(x->isa(x,Union{Tuple,Pair}),kv)
+        if !applicable(start, kv) || !all(x->isa(x,Union{Tuple,Pair}),kv)
             throw(ArgumentError("Dict(kv): kv needs to be an iterator of tuples or pairs"))
         else
             rethrow(e)
@@ -155,17 +154,17 @@ end
 
 typealias TP{K,V} Union{Type{Tuple{K,V}},Type{Pair{K,V}}}
 
-associative_with_eltype{K,V}(DT, kv, ::TP{K,V}) = DT{K,V}(kv)
-associative_with_eltype{K,V}(DT, kv::Generator, ::TP{K,V}) = DT{K,V}(kv)
-associative_with_eltype{K,V}(DT, ::Type{Pair{K,V}}) = DT{K,V}()
-associative_with_eltype(DT, ::Type) = DT()
-associative_with_eltype(DT, kv, t) = grow_to!(associative_with_eltype(DT, _default_eltype(typeof(kv))), kv)
-function associative_with_eltype(DT, kv::Generator, t)
+associative_with_eltype{K,V}(DT_apply, kv, ::TP{K,V}) = DT_apply(K, V)(kv)
+associative_with_eltype{K,V}(DT_apply, kv::Generator, ::TP{K,V}) = DT_apply(K, V)(kv)
+associative_with_eltype{K,V}(DT_apply, ::Type{Pair{K,V}}) = DT_apply(K, V)()
+associative_with_eltype(DT_apply, ::Type) = DT_apply(Any, Any)()
+associative_with_eltype{F}(DT_apply::F, kv, t) = grow_to!(associative_with_eltype(DT_apply, _default_eltype(typeof(kv))), kv)
+function associative_with_eltype{F}(DT_apply::F, kv::Generator, t)
     T = _default_eltype(typeof(kv))
-    if T <: Union{Pair,NTuple{2}} && isleaftype(T)
-        return associative_with_eltype(DT, kv, T)
+    if T <: Union{Pair, Tuple{Any, Any}} && isleaftype(T)
+        return associative_with_eltype(DT_apply, kv, T)
     end
-    return grow_to!(associative_with_eltype(DT, T), kv)
+    return grow_to!(associative_with_eltype(DT_apply, T), kv)
 end
 
 # this is a special case due to (1) allowing both Pairs and Tuples as elements,

base/docs/Docs.jl

@@ -88,7 +88,11 @@ function signature(expr::Expr)
             end
             push!(sig.args[end].args, argtype(arg))
         end
-        Expr(:let, Expr(:block, sig), typevars(expr)...)
+        tv = typevars(expr)
+        for i = length(tv):-1:1
+            sig = Expr(:where, sig, tv[i])
+        end
+        sig
     else
         signature(expr.args[1])
     end
@@ -103,14 +107,11 @@ end
 argtype(other) = :Any
 
 function typevars(expr::Expr)
-    isexpr(expr, :curly) && return [tvar(x) for x in expr.args[2:end]]
+    isexpr(expr, :curly) && return expr.args[2:end]
     typevars(expr.args[1])
 end
 typevars(::Symbol) = []
 
-tvar(x::Expr)   = :($(x.args[1]) = TypeVar($(quot(x.args[1])), $(x.args[2]), true))
-tvar(s::Symbol) = :($(s) = TypeVar($(quot(s)), Any, true))
-
 # Docsystem types.
 # ================
 
@@ -283,6 +284,7 @@ function doc(binding::Binding, sig::Type = Union{})
 end
 
 # Some additional convenience `doc` methods that take objects rather than `Binding`s.
+doc(obj::UnionAll) = doc(Base.unwrap_unionall(obj))
 doc(object, sig::Type = Union{}) = doc(aliasof(object, typeof(object)), sig)
 doc(object, sig...)              = doc(object, Tuple{sig...})
 

base/essentials.jl

@@ -2,7 +2,7 @@
 
 using Core: CodeInfo
 
-typealias Callable Union{Function,DataType}
+typealias Callable Union{Function,Type}
 
 const Bottom = Union{}
 
@@ -47,13 +47,13 @@ end
 argtail(x, rest...) = rest
 tail(x::Tuple) = argtail(x...)
 
-tuple_type_head(T::TypeConstructor) = tuple_type_head(T.body)
+tuple_type_head(T::UnionAll) = tuple_type_head(T.body)
 function tuple_type_head(T::DataType)
     @_pure_meta
     T.name === Tuple.name || throw(MethodError(tuple_type_head, (T,)))
     return T.parameters[1]
 end
-tuple_type_tail(T::TypeConstructor) = tuple_type_tail(T.body)
+tuple_type_tail(T::UnionAll) = tuple_type_tail(T.body)
 function tuple_type_tail(T::DataType)
     @_pure_meta
     T.name === Tuple.name || throw(MethodError(tuple_type_tail, (T,)))
@@ -69,9 +69,31 @@ function tuple_type_cons{S,T<:Tuple}(::Type{S}, ::Type{T})
     Tuple{S, T.parameters...}
 end
 
-isvarargtype(t::ANY) = isa(t, DataType) && (t::DataType).name === Vararg.name
+function unwrap_unionall(a::ANY)
+    while isa(a,UnionAll)
+        a = a.body
+    end
+    return a
+end
+
+function rewrap_unionall(t::ANY, u::ANY)
+    if !isa(u, UnionAll)
+        return t
+    end
+    return UnionAll(u.var, rewrap_unionall(t, u.body))
+end
+
+const _va_typename = Vararg.body.body.name
+function isvarargtype(t::ANY)
+    t = unwrap_unionall(t)
+    isa(t, DataType) && (t::DataType).name === _va_typename
+end
+
 isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
-unwrapva(t::ANY) = isvarargtype(t) ? t.parameters[1] : t
+function unwrapva(t::ANY)
+    t2 = unwrap_unionall(t)
+    isvarargtype(t2) ? t2.parameters[1] : t
+end
 
 convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::Tuple{Any, Vararg{Any}}) =
     tuple(convert(tuple_type_head(T),x[1]), convert(tuple_type_tail(T), tail(x))...)
@@ -90,6 +112,7 @@ ptr_arg_unsafe_convert(::Type{Ptr{Void}}, x) = x
 cconvert(T::Type, x) = convert(T, x) # do the conversion eagerly in most cases
 cconvert{P<:Ptr}(::Type{P}, x) = x # but defer the conversion to Ptr to unsafe_convert
 unsafe_convert{T}(::Type{T}, x::T) = x # unsafe_convert (like convert) defaults to assuming the convert occurred
+unsafe_convert{T<:Ptr}(::Type{T}, x::T) = x  # to resolve ambiguity with the next method
 unsafe_convert{P<:Ptr}(::Type{P}, x::Ptr) = convert(P, x)
 
 reinterpret{T}(::Type{T}, x) = box(T, x)

base/float.jl

@@ -63,6 +63,7 @@ for t1 in (Float32,Float64)
         end
     end
 end
+convert(::Type{Integer}, x::Float16) = convert(Integer, Float32(x))
 convert{T<:Integer}(::Type{T}, x::Float16) = convert(T, Float32(x))