Syntax to using where

base/array.jl

@@ -61,7 +61,7 @@ match the length or number of `dims`.
 Array
 
 vect() = Array{Any,1}(0)
-vect{T}(X::T...) = T[ X[i] for i=1:length(X) ]
+vect(X::T...) where {T} = T[ X[i] for i = 1:length(X) ]
 
 function vect(X...)
     T = promote_typeof(X...)

base/c.jl

@@ -158,9 +158,9 @@ Only conversion to/from UTF-8 is currently supported.
 """
 function transcode end
 
-transcode{T<:Union{UInt8,UInt16,UInt32,Int32}}(::Type{T}, src::Vector{T}) = src
-transcode{T<:Union{Int32,UInt32}}(::Type{T}, src::String) = T[T(c) for c in src]
-transcode{T<:Union{Int32,UInt32}}(::Type{T}, src::Vector{UInt8}) = transcode(T, String(src))
+transcode(::Type{T}, src::Vector{T}) where {T<:Union{UInt8,UInt16,UInt32,Int32}} = src
+transcode(::Type{T}, src::String) where {T<:Union{Int32,UInt32}} = T[T(c) for c in src]
+transcode(::Type{T}, src::Vector{UInt8}) where {T<:Union{Int32,UInt32}} = transcode(T, String(src))
 function transcode(::Type{UInt8}, src::Vector{<:Union{Int32,UInt32}})
     buf = IOBuffer()
     for c in src; print(buf, Char(c)); end

base/complex.jl

@@ -87,8 +87,8 @@ Float64
 ```
 """
 real(T::Type) = typeof(real(zero(T)))
-real{T<:Real}(::Type{T}) = T
-real{T<:Real}(::Type{Complex{T}}) = T
+real(::Type{T}) where {T<:Real} = T
+real(::Type{Complex{T}}) where {T<:Real} = T
 
 """
     isreal(x) -> Bool
@@ -366,7 +366,7 @@ function inv(w::Complex128)
     return Complex128(p*s,q*s) # undo scaling
 end
 
-function ssqs{T<:AbstractFloat}(x::T, y::T)
+function ssqs(x::T, y::T) where T<:AbstractFloat
     k::Int = 0
     ρ = x*x + y*y
     if !isfinite(ρ) && (isinf(x) || isinf(y))
@@ -536,7 +536,7 @@ function expm1(z::Complex)
     end
 end
 
-function log1p{T}(z::Complex{T})
+function log1p(z::Complex{T}) where T
     zr,zi = reim(z)
     if isfinite(zr)
         isinf(zi) && return log(z)

base/dates/ranges.jl

@@ -31,10 +31,10 @@ Base.length(r::StepRange{<:Period}) = length(StepRange(value(r.start), value(r.s
 
 # Used to calculate the last valid date in the range given the start, stop, and step
 # last = stop - steprem(start, stop, step)
-Base.steprem{T<:TimeType}(a::T, b::T, c) = b - (a + c * len(a, b, c))
+Base.steprem(a::T, b::T, c) where {T<:TimeType} = b - (a + c * len(a, b, c))
 
 import Base.in
-function in{T<:TimeType}(x::T, r::StepRange{T})
+function in(x::T, r::StepRange{T}) where T<:TimeType
     n = len(first(r), x, step(r)) + 1
     n >= 1 && n <= length(r) && r[n] == x
 end

base/dates/types.jl

@@ -311,5 +311,5 @@ sleep(time::Period) = sleep(toms(time) / 1000)
 Timer(time::Period, repeat::Period=Second(0)) = Timer(toms(time) / 1000, toms(repeat) / 1000)
 timedwait(testcb::Function, time::Period) = timedwait(testcb, toms(time) / 1000)
 
-(::Type{Base.TypeOrder})(::Type{<:AbstractTime}) = Base.HasOrder()
-(::Type{Base.TypeArithmetic})(::Type{<:AbstractTime}) = Base.ArithmeticOverflows()
+Base.TypeOrder(::Type{<:AbstractTime}) = Base.HasOrder()
+Base.TypeArithmetic(::Type{<:AbstractTime}) = Base.ArithmeticOverflows()

base/generator.jl

@@ -35,7 +35,7 @@ end
 
 Generator(f, I1, I2, Is...) = Generator(a->f(a...), zip(I1, I2, Is...))
 
-Generator{T,I}(::Type{T}, iter::I) = Generator{I,Type{T}}(T, iter)
+Generator(::Type{T}, iter::I) where {T,I} = Generator{I,Type{T}}(T, iter)
 
 start(g::Generator) = (@_inline_meta; start(g.iter))
 done(g::Generator, s) = (@_inline_meta; done(g.iter, s))

base/libgit2/repository.jl

@@ -217,7 +217,7 @@ then `obj` will be peeled until the type changes.
 - A `GitTag` will be peeled to the object it references.
 - A `GitCommit` will be peeled to a `GitTree`.
 """
-function peel{T<:GitObject}(::Type{T}, obj::GitObject)
+function peel(::Type{T}, obj::GitObject) where T<:GitObject
     new_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
 
     @check ccall((:git_object_peel, :libgit2), Cint,

base/mpfr.jl

@@ -168,10 +168,10 @@ function unsafe_cast(::Type{UInt64}, x::BigFloat, ri::Cint)
           (Ptr{BigFloat}, Cint), &x, ri)
 end
 
-function unsafe_cast{T<:Signed}(::Type{T}, x::BigFloat, ri::Cint)
+function unsafe_cast(::Type{T}, x::BigFloat, ri::Cint) where T<:Signed
     unsafe_cast(Int64, x, ri) % T
 end
-function unsafe_cast{T<:Unsigned}(::Type{T}, x::BigFloat, ri::Cint)
+function unsafe_cast(::Type{T}, x::BigFloat, ri::Cint) where T<:Unsigned
     unsafe_cast(UInt64, x, ri) % T
 end
 
@@ -184,19 +184,19 @@ function unsafe_cast(::Type{BigInt}, x::BigFloat, ri::Cint)
 end
 unsafe_cast(::Type{Int128}, x::BigFloat, ri::Cint) = Int128(unsafe_cast(BigInt,x,ri))
 unsafe_cast(::Type{UInt128}, x::BigFloat, ri::Cint) = UInt128(unsafe_cast(BigInt,x,ri))
-unsafe_cast{T<:Integer}(::Type{T}, x::BigFloat, r::RoundingMode) = unsafe_cast(T,x,to_mpfr(r))
+unsafe_cast(::Type{T}, x::BigFloat, r::RoundingMode) where {T<:Integer} = unsafe_cast(T,x,to_mpfr(r))
 
-unsafe_trunc{T<:Integer}(::Type{T}, x::BigFloat) = unsafe_cast(T,x,RoundToZero)
+unsafe_trunc(::Type{T}, x::BigFloat) where {T<:Integer} = unsafe_cast(T,x,RoundToZero)
 
 function trunc{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
     (typemin(T) <= x <= typemax(T)) || throw(InexactError())
     unsafe_cast(T,x,RoundToZero)
 end
-function floor{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
+function floor(::Type{T}, x::BigFloat) where T<:Union{Signed,Unsigned}
     (typemin(T) <= x <= typemax(T)) || throw(InexactError())
     unsafe_cast(T,x,RoundDown)
 end
-function ceil{T<:Union{Signed,Unsigned}}(::Type{T}, x::BigFloat)
+function ceil(::Type{T}, x::BigFloat) where T<:Union{Signed,Unsigned}
     (typemin(T) <= x <= typemax(T)) || throw(InexactError())
     unsafe_cast(T,x,RoundUp)
 end
@@ -223,7 +223,7 @@ function convert(::Type{BigInt},x::BigFloat)
     trunc(BigInt,x)
 end
 
-function convert(::Type{Integer},x::BigFloat)
+function convert(::Type{Integer}, x::BigFloat)
     isinteger(x) || throw(InexactError())
     trunc(Integer,x)
 end
@@ -234,23 +234,23 @@ end
 
 ## BigFloat -> AbstractFloat
 convert(::Type{Float64}, x::BigFloat) =
-    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat},Int32), &x, ROUNDING_MODE[])
+    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat}, Int32), &x, ROUNDING_MODE[])
 convert(::Type{Float32}, x::BigFloat) =
-    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat},Int32), &x, ROUNDING_MODE[])
+    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat}, Int32), &x, ROUNDING_MODE[])
 # TODO: avoid double rounding
 convert(::Type{Float16}, x::BigFloat) = convert(Float16, convert(Float32, x))
 
-(::Type{Float64})(x::BigFloat, r::RoundingMode) =
-    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat},Int32), &x, to_mpfr(r))
-(::Type{Float32})(x::BigFloat, r::RoundingMode) =
-    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat},Int32), &x, to_mpfr(r))
+Float64(x::BigFloat, r::RoundingMode) =
+    ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{BigFloat}, Int32), &x, to_mpfr(r))
+Float32(x::BigFloat, r::RoundingMode) =
+    ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{BigFloat}, Int32), &x, to_mpfr(r))
 # TODO: avoid double rounding
-(::Type{Float16})(x::BigFloat, r::RoundingMode) =
+Float16(x::BigFloat, r::RoundingMode) =
     convert(Float16, Float32(x, r))
 
 promote_rule(::Type{BigFloat}, ::Type{<:Real}) = BigFloat
-promote_rule(::Type{BigInt},::Type{<:AbstractFloat}) = BigFloat
-promote_rule(::Type{BigFloat},::Type{<:AbstractFloat}) = BigFloat
+promote_rule(::Type{BigInt}, ::Type{<:AbstractFloat}) = BigFloat
+promote_rule(::Type{BigFloat}, ::Type{<:AbstractFloat}) = BigFloat
 
 function convert(::Type{Rational{BigInt}}, x::AbstractFloat)
     if isnan(x); return zero(BigInt)//zero(BigInt); end
@@ -860,7 +860,7 @@ It is logically equivalent to:
 
 Often used as `setprecision(T, precision) do ... end`
 """
-function setprecision{T}(f::Function, ::Type{T}, prec::Integer)
+function setprecision(f::Function, ::Type{T}, prec::Integer) where T
     old_prec = precision(T)
     setprecision(T, prec)
     try

base/multidimensional.jl

@@ -446,8 +446,8 @@ end
 _maybe_reshape(::IndexLinear, A::AbstractArray, I...) = A
 _maybe_reshape(::IndexCartesian, A::AbstractVector, I...) = A
 @inline _maybe_reshape(::IndexCartesian, A::AbstractArray, I...) = __maybe_reshape(A, index_ndims(I...))
-@inline __maybe_reshape{T,N}(A::AbstractArray{T,N}, ::NTuple{N,Any}) = A
-@inline __maybe_reshape{N}(A::AbstractArray, ::NTuple{N,Any}) = reshape(A, Val{N})
+@inline __maybe_reshape(A::AbstractArray{T,N}, ::NTuple{N,Any}) where {T,N} = A
+@inline __maybe_reshape(A::AbstractArray, ::NTuple{N,Any}) where {N} = reshape(A, Val{N})
 
 @generated function _unsafe_getindex(::IndexStyle, A::AbstractArray, I::Union{Real, AbstractArray}...)
     N = length(I)

base/strings/types.jl

@@ -26,7 +26,7 @@ struct SubString{T<:AbstractString} <: AbstractString
         end
     end
 end
-SubString(s::T, i::Int, j::Int) where T<:AbstractString = SubString{T}(s, i, j)
+SubString(s::T, i::Int, j::Int) where {T<:AbstractString} = SubString{T}(s, i, j)
 SubString(s::SubString, i::Int, j::Int) = SubString(s.string, s.offset+i, s.offset+j)
 SubString(s::AbstractString, i::Integer, j::Integer) = SubString(s, Int(i), Int(j))
 SubString(s::AbstractString, i::Integer) = SubString(s, i, endof(s))

base/strings/util.jl

@@ -250,7 +250,7 @@ cpad(s, n::Integer, p=" ") = rpad(lpad(s,div(n+strwidth(s),2),p),n,p)
 
 # splitter can be a Char, Vector{Char}, AbstractString, Regex, ...
 # any splitter that provides search(s::AbstractString, splitter)
-split{T<:SubString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _split(str, splitter, limit, keep, T[])
+split(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:SubString} = _split(str, splitter, limit, keep, T[])
 
 """
     split(s::AbstractString, [chars]; limit::Integer=0, keep::Bool=true)
@@ -273,7 +273,7 @@ julia> split(a,".")
  "rch"
 ```
 """
-split{T<:AbstractString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _split(str, splitter, limit, keep, SubString{T}[])
+split(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:AbstractString} = _split(str, splitter, limit, keep, SubString{T}[])
 function _split(str::AbstractString, splitter, limit::Integer, keep_empty::Bool, strs::Array)
     i = start(str)
     n = endof(str)
@@ -299,7 +299,7 @@ end
 # a bit oddball, but standard behavior in Perl, Ruby & Python:
 split(str::AbstractString) = split(str, _default_delims; limit=0, keep=false)
 
-rsplit{T<:SubString}(str::T, splitter; limit::Integer=0, keep::Bool=true) = _rsplit(str, splitter, limit, keep, T[])
+rsplit(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:SubString} = _rsplit(str, splitter, limit, keep, T[])
 
 """
     rsplit(s::AbstractString, [chars]; limit::Integer=0, keep::Bool=true)
@@ -328,7 +328,7 @@ julia> rsplit(a,".";limit=2)
  "h"
 ```
 """
-rsplit{T<:AbstractString}(str::T, splitter   ; limit::Integer=0, keep::Bool=true) = _rsplit(str, splitter, limit, keep, SubString{T}[])
+rsplit(str::T, splitter   ; limit::Integer=0, keep::Bool=true) where {T<:AbstractString} = _rsplit(str, splitter, limit, keep, SubString{T}[])
 function _rsplit(str::AbstractString, splitter, limit::Integer, keep_empty::Bool, strs::Array)
     i = start(str)
     n = endof(str)

base/traits.jl

@@ -6,17 +6,17 @@ abstract type TypeOrder end
 struct HasOrder <: TypeOrder end
 struct Unordered <: TypeOrder end
 
-(::Type{TypeOrder})(instance) = TypeOrder(typeof(instance))
-(::Type{TypeOrder})(::Type{<:Real}) = HasOrder()
-(::Type{TypeOrder})(::Type{<:Any}) = Unordered()
+TypeOrder(instance) = TypeOrder(typeof(instance))
+TypeOrder(::Type{<:Real}) = HasOrder()
+TypeOrder(::Type{<:Any}) = Unordered()
 
 # trait for objects that support arithmetic
 abstract type TypeArithmetic end
 struct ArithmeticRounds <: TypeArithmetic end     # least significant bits can be lost
 struct ArithmeticOverflows <: TypeArithmetic end  #  most significant bits can be lost
 struct ArithmeticUnknown <: TypeArithmetic end
 
-(::Type{TypeArithmetic})(instance) = TypeArithmetic(typeof(instance))
-(::Type{TypeArithmetic})(::Type{<:AbstractFloat}) = ArithmeticRounds()
-(::Type{TypeArithmetic})(::Type{<:Integer}) = ArithmeticOverflows()
-(::Type{TypeArithmetic})(::Type{<:Any}) = ArithmeticUnknown()
+TypeArithmetic(instance) = TypeArithmetic(typeof(instance))
+TypeArithmetic(::Type{<:AbstractFloat}) = ArithmeticRounds()
+TypeArithmetic(::Type{<:Integer}) = ArithmeticOverflows()
+TypeArithmetic(::Type{<:Any}) = ArithmeticUnknown()