call overloading, and make constructors use it

base/array.jl

@@ -123,6 +123,14 @@ function getindex(T::NonTupleType, vals...)
     return a
 end
 
+function getindex(::Type{Any}, vals::ANY...)
+    a = Array(Any,length(vals))
+    for i = 1:length(vals)
+        a[i] = vals[i]
+    end
+    return a
+end
+
 getindex(T::(Type...)) = Array(T,0)
 
 # T[a:b] and T[a:s:b] also construct typed ranges

base/base.jl

@@ -1,19 +1,51 @@
-import Core.Array  # to add methods
-
 const NonTupleType = Union(DataType,UnionType,TypeConstructor)
 
 typealias Callable Union(Function,DataType)
 
 const Bottom = Union()
 
-convert(T, x) = convert_default(T, x, convert)
+# constructors for Core types in boot.jl
+call(T::Type{BoundsError}) = Core.call(T)
+call(T::Type{DivideError}) = Core.call(T)
+call(T::Type{DomainError}) = Core.call(T)
+call(T::Type{OverflowError}) = Core.call(T)
+call(T::Type{InexactError}) = Core.call(T)
+call(T::Type{MemoryError}) = Core.call(T)
+call(T::Type{StackOverflowError}) = Core.call(T)
+call(T::Type{UndefRefError}) = Core.call(T)
+call(T::Type{UndefVarError}, var::Symbol) = Core.call(T, var)
+call(T::Type{InterruptException}) = Core.call(T)
+call(T::Type{SymbolNode}, name::Symbol, t::ANY) = Core.call(T, name, t)
+call(T::Type{GetfieldNode}, value, name::Symbol, typ) = Core.call(T, value, name, typ)
+call(T::Type{ASCIIString}, d::Array{Uint8,1}) = Core.call(T, d)
+call(T::Type{UTF8String}, d::Array{Uint8,1}) = Core.call(T, d)
+call(T::Type{TypeVar}, args...) = Core.call(T, args...)
+call(T::Type{TypeConstructor}, args...) = Core.call(T, args...)
+call(T::Type{Expr}, args::ANY...) = _expr(args...)
+call(T::Type{LineNumberNode}, n::Int) = Core.call(T, n)
+call(T::Type{LabelNode}, n::Int) = Core.call(T, n)
+call(T::Type{GotoNode}, n::Int) = Core.call(T, n)
+call(T::Type{QuoteNode}, x::ANY) = Core.call(T, x)
+call(T::Type{NewvarNode}, s::Symbol) = Core.call(T, s)
+call(T::Type{TopNode}, s::Symbol) = Core.call(T, s)
+call(T::Type{Module}, args...) = Core.call(T, args...)
+call(T::Type{Task}, f::ANY) = Core.call(T, f)
+
+call{T}(::Type{T}, args...) = convert(T, args...)::T
+
+convert{T}(::Type{T}, x::T) = x
 
 convert(::(), ::()) = ()
 convert(::Type{Tuple}, x::Tuple) = x
 
+# allow convert to be called as if it were a single-argument constructor
+# call(T::Type, x) = convert(T, x)
+
 argtail(x, rest...) = rest
 tupletail(x::Tuple) = argtail(x...)
 
+convert(T::(Type, Type...), x::(Any, Any...)) =
+    tuple(convert(T[1],x[1]), convert(tupletail(T), tupletail(x))...)
 convert(T::(Any, Any...), x::(Any, Any...)) =
     tuple(convert(T[1],x[1]), convert(tupletail(T), tupletail(x))...)
 
@@ -180,7 +212,11 @@ map(f::Callable, a::Array{Any,1}) = Any[ f(a[i]) for i=1:length(a) ]
 macro thunk(ex); :(()->$(esc(ex))); end
 macro L_str(s); s; end
 
-function precompile(f, args::Tuple)
+function precompile(f::ANY, args::Tuple)
+    if isa(f,DataType)
+        args = tuple(Type{f}, args...)
+        f = f.name.module.call
+    end
     if isgeneric(f)
         ccall(:jl_compile_hint, Void, (Any, Any), f, args)
     end
@@ -207,8 +243,6 @@ macro goto(name::Symbol)
     Expr(:symbolicgoto, name)
 end
 
-# NOTE: Base shares Array with Core so we can add definitions to it
-
 Array{T,N}(::Type{T}, d::NTuple{N,Int}) =
     ccall(:jl_new_array, Array{T,N}, (Any,Any), Array{T,N}, d)
 

base/boot.jl

@@ -137,9 +137,9 @@ export
     Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode, SymbolNode, TopNode,
     GetfieldNode, NewvarNode,
     # object model functions
-    apply, fieldtype, getfield, setfield!, yieldto, throw, tuple, is, ===, isdefined,
-    # arraylen, arrayref, arrayset, arraysize, tuplelen, tupleref, convert_default,
-    # kwcall,
+    fieldtype, getfield, setfield!, yieldto, throw, tuple, is, ===, isdefined,
+    # arraylen, arrayref, arrayset, arraysize, tuplelen, tupleref,
+    # _apply, kwcall,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
     # type reflection
     issubtype, typeof, isa,
@@ -217,9 +217,6 @@ type InterruptException <: Exception end
 abstract String
 abstract DirectIndexString <: String
 
-# simple convert for use by constructors of types in Core
-convert(T, x) = convert_default(T, x, convert)
-
 type SymbolNode
     name::Symbol
     typ
@@ -243,3 +240,38 @@ end
 typealias ByteString Union(ASCIIString,UTF8String)
 
 include(fname::ByteString) = ccall(:jl_load_, Any, (Any,), fname)
+
+# constructors for built-in types
+
+TypeVar(n::Symbol) =
+    ccall(:jl_new_typevar, Any, (Any, Any, Any), n, Union(), Any)::TypeVar
+TypeVar(n::Symbol, ub::ANY) =
+    (isa(ub,Bool) ?
+     ccall(:jl_new_typevar_, Any, (Any, Any, Any, Any), n, Union(), Any, ub)::TypeVar :
+     ccall(:jl_new_typevar, Any, (Any, Any, Any), n, Union(), ub::Type)::TypeVar)
+TypeVar(n::Symbol, lb::ANY, ub::ANY) =
+    (isa(ub,Bool) ?
+     ccall(:jl_new_typevar_, Any, (Any, Any, Any, Any), n, Union(), lb::Type, ub)::TypeVar :
+     ccall(:jl_new_typevar, Any, (Any, Any, Any), n, lb::Type, ub::Type)::TypeVar)
+TypeVar(n::Symbol, lb::ANY, ub::ANY, b::Bool) =
+    ccall(:jl_new_typevar_, Any, (Any, Any, Any, Any), n, lb::Type, ub::Type, b)::TypeVar
+
+TypeConstructor(p::ANY, t::ANY) = ccall(:jl_new_type_constructor, Any, (Any, Any), p::Tuple, t::Type)
+
+Expr(args::ANY...) = _expr(args...)
+
+LineNumberNode(n::Int) = ccall(:jl_new_struct, Any, (Any,Any...), LineNumberNode, n)::LineNumberNode
+LabelNode(n::Int) = ccall(:jl_new_struct, Any, (Any,Any...), LabelNode, n)::LabelNode
+GotoNode(n::Int) = ccall(:jl_new_struct, Any, (Any,Any...), GotoNode, n)::GotoNode
+QuoteNode(x::ANY) = ccall(:jl_new_struct, Any, (Any,Any...), QuoteNode, x)::QuoteNode
+NewvarNode(s::Symbol) = ccall(:jl_new_struct, Any, (Any,Any...), NewvarNode, s)::NewvarNode
+TopNode(s::Symbol) = ccall(:jl_new_struct, Any, (Any,Any...), TopNode, s)::TopNode
+
+Module(name::Symbol) = ccall(:jl_f_new_module, Any, (Any,), name)::Module
+Module() = Module(:anonymous)
+
+Task(f::ANY) = ccall(:jl_new_task, Any, (Any, Int), f::Function, 0)::Task
+
+# simple convert for use by constructors of types in Core
+convert(::Type{Any}, x::ANY) = x
+convert{T}(::Type{T}, x::T) = x

base/c.jl

@@ -112,11 +112,11 @@ function find_library{T<:ByteString, S<:ByteString}(libnames::Array{T,1}, extrap
     return ""
 end
 
-function ccallable(f::Callable, rt::Type, argt::(Type...), name::Union(String,Symbol)=string(f))
+function ccallable(f::Function, rt::Type, argt::(Type...), name::Union(String,Symbol)=string(f))
     ccall(:jl_extern_c, Void, (Any, Any, Any, Ptr{Uint8}), f, rt, argt, name)
 end
 
-function ccallable(f::Callable, argt::(Type...), name::Union(String,Symbol)=string(f))
+function ccallable(f::Function, argt::(Type...), name::Union(String,Symbol)=string(f))
     ccall(:jl_extern_c, Void, (Any, Ptr{Void}, Any, Ptr{Uint8}), f, C_NULL, argt, name)
 end
 

base/deprecated.jl

@@ -157,7 +157,7 @@ end
 
 scale!{T<:Base.LinAlg.BlasReal}(X::Array{T}, s::Complex) = error("scale!: Cannot scale a real array by a complex value in-place.  Use scale(X::Array{Real}, s::Complex) instead.")
 
-@deprecate which(f::Callable, args...) @which f(args...)
+@deprecate which(f, args...) @which f(args...)
 @deprecate rmdir rm
 
 # 0.4 deprecations
@@ -186,6 +186,12 @@ const Nothing = Void
 export None
 const None = Union()
 
+export apply
+function apply(f, args...)
+    depwarn("apply(f, x) is deprecated, use `f(x...)` instead", :apply)
+    return Core._apply(call, f, args...)
+end
+
 @deprecate median(v::AbstractArray; checknan::Bool=true)  median(v)
 @deprecate median(v::AbstractArray, region; checknan::Bool=true)  median(v, region)
 @deprecate median!(v::AbstractVector; checknan::Bool=true)  median!(v)

base/exports.jl

@@ -269,6 +269,7 @@ export
     At_mul_Bt!,
     At_rdiv_B,
     At_rdiv_Bt,
+    call,
 
 # scalar math
     @evalpoly,

base/expr.jl

@@ -47,7 +47,7 @@ function show(io::IO, tv::TypeVar)
         show(io, tv.lb)
         print(io, "<:")
     end
-    print(io, tv.name)
+    write(io, tv.name)
     if !is(tv.ub, Any)
         print(io, "<:")
         show(io, tv.ub)