RFC: Deprecate several space insensitivities

base/abstractarray.jl

@@ -188,12 +188,12 @@ end
 
 # default arguments to similar()
 similar{T}(a::AbstractArray{T})               = similar(a, T, size(a))
-similar   (a::AbstractArray, T)               = similar(a, T, size(a))
+similar(   a::AbstractArray, T)               = similar(a, T, size(a))
 similar{T}(a::AbstractArray{T}, dims::Dims)   = similar(a, T, dims)
 similar{T}(a::AbstractArray{T}, dims::Int...) = similar(a, T, dims)
-similar   (a::AbstractArray, T, dims::Int...) = similar(a, T, dims)
+similar(   a::AbstractArray, T, dims::Int...) = similar(a, T, dims)
 # similar creates an Array by default
-similar   (a::AbstractArray, T, dims::Dims)   = Array(T, dims)
+similar(   a::AbstractArray, T, dims::Dims)   = Array(T, dims)
 
 function reshape(a::AbstractArray, dims::Dims)
     if prod(dims) != length(a)

base/dict.jl

@@ -414,18 +414,18 @@ Dict{K,V}(kv::Tuple{Vararg{Tuple{K,V}}})          = Dict{K,V}(kv)
 Dict{K  }(kv::Tuple{Vararg{Tuple{K,Any}}})        = Dict{K,Any}(kv)
 Dict{V  }(kv::Tuple{Vararg{Tuple{Any,V}}})        = Dict{Any,V}(kv)
 Dict{K,V}(kv::Tuple{Vararg{Pair{K,V}}})           = Dict{K,V}(kv)
-Dict{K}  (kv::Tuple{Vararg{Pair{K}}})             = Dict{K,Any}(kv)
-Dict{V}  (kv::Tuple{Vararg{Pair{TypeVar(:K),V}}}) = Dict{Any,V}(kv)
-Dict     (kv::Tuple{Vararg{Pair}})                = Dict{Any,Any}(kv)
+Dict{K  }(kv::Tuple{Vararg{Pair{K}}})             = Dict{K,Any}(kv)
+Dict{V  }(kv::Tuple{Vararg{Pair{TypeVar(:K),V}}}) = Dict{Any,V}(kv)
+Dict(     kv::Tuple{Vararg{Pair}})                = Dict{Any,Any}(kv)
 
 Dict{K,V}(kv::AbstractArray{Tuple{K,V}}) = Dict{K,V}(kv)
 Dict{K,V}(kv::AbstractArray{Pair{K,V}})  = Dict{K,V}(kv)
 Dict{K,V}(kv::Associative{K,V})          = Dict{K,V}(kv)
 
 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     (ps::Pair...)                 = Dict{Any,Any}(ps)
+Dict{K  }(ps::Pair{K}...,)             = Dict{K,Any}(ps)
+Dict{V  }(ps::Pair{TypeVar(:K),V}...,) = Dict{Any,V}(ps)
+Dict(     ps::Pair...)                 = Dict{Any,Any}(ps)
 
 Dict(kv) = dict_with_eltype(kv, eltype(kv))
 dict_with_eltype{K,V}(kv, ::Type{Tuple{K,V}}) = Dict{K,V}(kv)

base/docs/Docs.jl

@@ -12,7 +12,7 @@ const modules = Module[]
 
 meta() = current_module().META
 
-macro init ()
+macro init()
     META = esc(:META)
     quote
         if !isdefined(:META)
@@ -129,7 +129,7 @@ isdoc(x) = isexpr(x, :string, AbstractString) ||
 
 dict_expr(d) = :(Dict($([:($(Expr(:quote, f)) => $d) for (f, d) in d]...)))
 
-function field_meta (def)
+function field_meta(def)
     meta = Dict()
     doc = nothing
     for l in def.args[3].args
@@ -303,7 +303,7 @@ end
 
 # Not actually used; bootstrap version in bootstrap.jl
 
-macro doc (args...)
+macro doc(args...)
     docm(args...)
 end
 
@@ -444,7 +444,7 @@ print(io::IO, t::Text{Function}) = t.content(io)
 writemime(io::IO, ::MIME"text/plain", t::Text) = print(io, t)
 
 @doc "Create a `Text` object from a literal string." ->
-macro text_str (s)
+macro text_str(s)
     :(Text($s))
 end
 
@@ -481,7 +481,7 @@ end
 
 repl_corrections(s) = repl_corrections(STDOUT, s)
 
-macro repl (ex)
+macro repl(ex)
     quote
         # Fuzzy Searching
         $(isexpr(ex, Symbol)) && repl_search($(string(ex)))

base/docs/bootstrap.jl

@@ -8,7 +8,7 @@ _expand_ = nothing
 
 setexpand!(f) = global _expand_ = f
 
-macro doc (args...)
+macro doc(args...)
   _expand_(args...)
 end
 

base/float.jl

@@ -173,8 +173,8 @@ trunc(::Type{Integer}, x::Float64) = trunc(Int,x)
 
 # fallbacks
 floor{T<:Integer}(::Type{T}, x::FloatingPoint) = trunc(T,floor(x))
-ceil {T<:Integer}(::Type{T}, x::FloatingPoint) = trunc(T,ceil(x))
-round {T<:Integer}(::Type{T}, x::FloatingPoint) = trunc(T,round(x))
+ceil{ T<:Integer}(::Type{T}, x::FloatingPoint) = trunc(T,ceil(x))
+round{T<:Integer}(::Type{T}, x::FloatingPoint) = trunc(T,round(x))
 
 trunc(x::Float64) = box(Float64,trunc_llvm(unbox(Float64,x)))
 trunc(x::Float32) = box(Float32,trunc_llvm(unbox(Float32,x)))
@@ -236,15 +236,15 @@ end
 ==(x::Float64, y::Float64) = eq_float(unbox(Float64,x),unbox(Float64,y))
 !=(x::Float32, y::Float32) = ne_float(unbox(Float32,x),unbox(Float32,y))
 !=(x::Float64, y::Float64) = ne_float(unbox(Float64,x),unbox(Float64,y))
-< (x::Float32, y::Float32) = lt_float(unbox(Float32,x),unbox(Float32,y))
-< (x::Float64, y::Float64) = lt_float(unbox(Float64,x),unbox(Float64,y))
+<( x::Float32, y::Float32) = lt_float(unbox(Float32,x),unbox(Float32,y))
+<( x::Float64, y::Float64) = lt_float(unbox(Float64,x),unbox(Float64,y))
 <=(x::Float32, y::Float32) = le_float(unbox(Float32,x),unbox(Float32,y))
 <=(x::Float64, y::Float64) = le_float(unbox(Float64,x),unbox(Float64,y))
 
 isequal(x::Float32, y::Float32) = fpiseq(unbox(Float32,x),unbox(Float32,y))
 isequal(x::Float64, y::Float64) = fpiseq(unbox(Float64,x),unbox(Float64,y))
-isless (x::Float32, y::Float32) = fpislt(unbox(Float32,x),unbox(Float32,y))
-isless (x::Float64, y::Float64) = fpislt(unbox(Float64,x),unbox(Float64,y))
+isless( x::Float32, y::Float32) = fpislt(unbox(Float32,x),unbox(Float32,y))
+isless( x::Float64, y::Float64) = fpislt(unbox(Float64,x),unbox(Float64,y))
 
 function cmp(x::FloatingPoint, y::FloatingPoint)
     (isnan(x) || isnan(y)) && throw(DomainError())

base/float16.jl

@@ -107,7 +107,7 @@ convert{T<:Integer}(::Type{T}, x::Float16) = convert(T, Float32(x))
 round{T<:Integer}(::Type{T}, x::Float16) = round(T, Float32(x))
 trunc{T<:Integer}(::Type{T}, x::Float16) = trunc(T, Float32(x))
 floor{T<:Integer}(::Type{T}, x::Float16) = floor(T, Float32(x))
-ceil {T<:Integer}(::Type{T}, x::Float16) = ceil(T, Float32(x))
+ceil{ T<:Integer}(::Type{T}, x::Float16) = ceil(T, Float32(x))
 
 round(x::Float16) = Float16(round(Float32(x)))
 trunc(x::Float16) = Float16(trunc(Float32(x)))

base/int.jl

@@ -72,11 +72,11 @@ typealias Signed64 Union{Int8,Int16,Int32,Int64}
 typealias Unsigned64 Union{UInt8,UInt16,UInt32,UInt64}
 typealias Integer64 Union{Signed64,Unsigned64}
 
-div{T<:Signed64}  (x::T, y::T) = box(T,sdiv_int(unbox(T,x),unbox(T,y)))
+div{T<:Signed64  }(x::T, y::T) = box(T,sdiv_int(unbox(T,x),unbox(T,y)))
 div{T<:Unsigned64}(x::T, y::T) = box(T,udiv_int(unbox(T,x),unbox(T,y)))
-rem{T<:Signed64}  (x::T, y::T) = box(T,srem_int(unbox(T,x),unbox(T,y)))
+rem{T<:Signed64  }(x::T, y::T) = box(T,srem_int(unbox(T,x),unbox(T,y)))
 rem{T<:Unsigned64}(x::T, y::T) = box(T,urem_int(unbox(T,x),unbox(T,y)))
-mod{T<:Signed64}  (x::T, y::T) = box(T,smod_int(unbox(T,x),unbox(T,y)))
+mod{T<:Signed64  }(x::T, y::T) = box(T,smod_int(unbox(T,x),unbox(T,y)))
 
 mod{T<:Unsigned}(x::T, y::T) = rem(x,y)
 
@@ -136,8 +136,8 @@ for T in IntTypes
         trailing_zeros(x::$T) = Int(box($T,cttz_int(unbox($T,x))))
     end
 end
-count_zeros  (x::Integer) = count_ones(~x)
-leading_ones (x::Integer) = leading_zeros(~x)
+count_zeros(  x::Integer) = count_ones(~x)
+leading_ones( x::Integer) = leading_zeros(~x)
 trailing_ones(x::Integer) = trailing_zeros(~x)
 
 ## integer comparisons ##
@@ -154,8 +154,8 @@ end
 
 ==(x::Signed,   y::Unsigned) = (x >= 0) & (unsigned(x) == y)
 ==(x::Unsigned, y::Signed  ) = (y >= 0) & (x == unsigned(y))
-< (x::Signed,   y::Unsigned) = (x <  0) | (unsigned(x) <  y)
-< (x::Unsigned, y::Signed  ) = (y >  0) & (x <  unsigned(y))
+<( x::Signed,   y::Unsigned) = (x <  0) | (unsigned(x) <  y)
+<( x::Unsigned, y::Signed  ) = (y >  0) & (x <  unsigned(y))
 <=(x::Signed,   y::Unsigned) = (x <= 0) | (unsigned(x) <= y)
 <=(x::Unsigned, y::Signed  ) = (y >= 0) & (x <= unsigned(y))
 
@@ -446,10 +446,10 @@ if WORD_SIZE == 32
 
     mod(x::Int128, y::Int128) = Int128(mod(BigInt(x),BigInt(y)))
 
-    << (x::Int128,  y::Int) = y == 0 ? x : box(Int128,shl_int(unbox(Int128,x),unbox(Int,y)))
-    << (x::UInt128, y::Int) = y == 0 ? x : box(UInt128,shl_int(unbox(UInt128,x),unbox(Int,y)))
-    >> (x::Int128,  y::Int) = y == 0 ? x : box(Int128,ashr_int(unbox(Int128,x),unbox(Int,y)))
-    >> (x::UInt128, y::Int) = y == 0 ? x : box(UInt128,lshr_int(unbox(UInt128,x),unbox(Int,y)))
+    <<( x::Int128,  y::Int) = y == 0 ? x : box(Int128,shl_int(unbox(Int128,x),unbox(Int,y)))
+    <<( x::UInt128, y::Int) = y == 0 ? x : box(UInt128,shl_int(unbox(UInt128,x),unbox(Int,y)))
+    >>( x::Int128,  y::Int) = y == 0 ? x : box(Int128,ashr_int(unbox(Int128,x),unbox(Int,y)))
+    >>( x::UInt128, y::Int) = y == 0 ? x : box(UInt128,lshr_int(unbox(UInt128,x),unbox(Int,y)))
     >>>(x::Int128,  y::Int) = y == 0 ? x : box(Int128,lshr_int(unbox(Int128,x),unbox(Int,y)))
     >>>(x::UInt128, y::Int) = y == 0 ? x : box(UInt128,lshr_int(unbox(UInt128,x),unbox(Int,y)))
 else

base/linalg/lapack.jl

@@ -3952,7 +3952,7 @@ for (trsen, tgsen, elty) in
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{Void}, Ptr{Void},
-                    Ptr{$elty}, Ptr  {BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt},
                     Ptr{BlasInt}),
                     &'N', &'V', select, &n,
                     T, &ldt, Q, &ldq,

base/linalg/tridiag.jl

@@ -135,7 +135,7 @@ eigvecs{T<:BlasFloat,Eigenvalue<:Real}(A::SymTridiagonal{T}, eigvals::Vector{Eig
 type ZeroOffsetVector
     data::Vector
 end
-getindex (a::ZeroOffsetVector, i) = a.data[i+1]
+getindex( a::ZeroOffsetVector, i) = a.data[i+1]
 setindex!(a::ZeroOffsetVector, x, i) = a.data[i+1]=x
 
 #Implements the inverse using the recurrence relation between principal minors

base/markdown/parse/config.jl

@@ -27,7 +27,7 @@ triggers(f) = get(meta(f), :triggers, Set{Char}())
 isexpr(x::Expr, ts...) = x.head in ts
 isexpr{T}(x::T, ts...) = T in ts
 
-macro breaking (ex)
+macro breaking(ex)
     isexpr(ex, :->) || error("invalid @breaking form, use ->")
     b, def = ex.args
     if b
@@ -41,7 +41,7 @@ macro breaking (ex)
     end
 end
 
-macro trigger (ex)
+macro trigger(ex)
     isexpr(ex, :->) || error("invalid @triggers form, use ->")
     ts, def = ex.args
     quote
@@ -74,7 +74,7 @@ end
 
 const flavors = Dict{Symbol, Config}()
 
-macro flavor (name, features)
+macro flavor(name, features)
     quote
         const $(esc(name)) = config($(map(esc,features.args)...))
         flavors[$(Expr(:quote, name))] = $(esc(name))

base/multi.jl

@@ -779,7 +779,7 @@ function deliver_result(sock::IO, msg, oid, value)
 end
 
 # notify waiters that a certain job has finished or RemoteRef has been emptied
-notify_full (rv::RemoteValue) = notify(rv.full, work_result(rv))
+notify_full( rv::RemoteValue) = notify(rv.full, work_result(rv))
 notify_empty(rv::RemoteValue) = notify(rv.empty)
 
 ## message event handlers ##

base/operators.jl

@@ -115,7 +115,7 @@ end
 
 .==(x::Number,y::Number) = x == y
 .!=(x::Number,y::Number) = x != y
-.< (x::Real,y::Real) = x < y
+.<( x::Real,y::Real) = x < y
 .<=(x::Real,y::Real) = x <= y
 const .≤ = .<=
 const .≠ = .!=
@@ -154,26 +154,26 @@ ctranspose(x) = conj(transpose(x))
 conj(x) = x
 
 # transposed multiply
-Ac_mul_B (a,b) = ctranspose(a)*b
-A_mul_Bc (a,b) = a*ctranspose(b)
+Ac_mul_B(a,b)  = ctranspose(a)*b
+A_mul_Bc(a,b)  = a*ctranspose(b)
 Ac_mul_Bc(a,b) = ctranspose(a)*ctranspose(b)
-At_mul_B (a,b) = transpose(a)*b
-A_mul_Bt (a,b) = a*transpose(b)
+At_mul_B(a,b)  = transpose(a)*b
+A_mul_Bt(a,b)  = a*transpose(b)
 At_mul_Bt(a,b) = transpose(a)*transpose(b)
 
 # transposed divide
-Ac_rdiv_B (a,b) = ctranspose(a)/b
-A_rdiv_Bc (a,b) = a/ctranspose(b)
+Ac_rdiv_B(a,b)  = ctranspose(a)/b
+A_rdiv_Bc(a,b)  = a/ctranspose(b)
 Ac_rdiv_Bc(a,b) = ctranspose(a)/ctranspose(b)
-At_rdiv_B (a,b) = transpose(a)/b
-A_rdiv_Bt (a,b) = a/transpose(b)
+At_rdiv_B(a,b)  = transpose(a)/b
+A_rdiv_Bt(a,b)  = a/transpose(b)
 At_rdiv_Bt(a,b) = transpose(a)/transpose(b)
 
-Ac_ldiv_B (a,b) = ctranspose(a)\b
-A_ldiv_Bc (a,b) = a\ctranspose(b)
+Ac_ldiv_B(a,b)  = ctranspose(a)\b
+A_ldiv_Bc(a,b)  = a\ctranspose(b)
 Ac_ldiv_Bc(a,b) = ctranspose(a)\ctranspose(b)
-At_ldiv_B (a,b) = transpose(a)\b
-A_ldiv_Bt (a,b) = a\transpose(b)
+At_ldiv_B(a,b)  = transpose(a)\b
+A_ldiv_Bt(a,b)  = a\transpose(b)
 At_ldiv_Bt(a,b) = At_ldiv_B(a,transpose(b))
 Ac_ldiv_Bt(a,b) = Ac_ldiv_B(a,transpose(b))
 

base/process.jl

@@ -564,10 +564,10 @@ process_signaled(s::Process) = (s.termsignal > 0)
 #process_stop_signal(s::Process) = false #not supported by libuv. Do we need this?
 
 function process_status(s::Process)
-    process_running (s) ? "ProcessRunning" :
+    process_running(s) ? "ProcessRunning" :
     process_signaled(s) ? "ProcessSignaled("*string(s.termsignal)*")" :
-    #process_stopped (s) ? "ProcessStopped("*string(process_stop_signal(s))*")" :
-    process_exited  (s) ? "ProcessExited("*string(s.exitcode)*")" :
+    #process_stopped(s) ? "ProcessStopped("*string(process_stop_signal(s))*")" :
+    process_exited(s) ? "ProcessExited("*string(s.exitcode)*")" :
     error("process status error")
 end
 

base/promotion.jl

@@ -178,7 +178,7 @@ muladd(x::Number, y::Number, z::Number) = muladd(promote(x,y,z)...)
 ($)(x::Integer, y::Integer) = ($)(promote(x,y)...)
 
 ==(x::Number, y::Number) = (==)(promote(x,y)...)
-< (x::Real, y::Real)     = (< )(promote(x,y)...)
+<( x::Real, y::Real)     = (< )(promote(x,y)...)
 <=(x::Real, y::Real)     = (<=)(promote(x,y)...)
 
 div(x::Real, y::Real) = div(promote(x,y)...)

base/random.jl

@@ -35,7 +35,7 @@ type Close1Open2 <: FloatInterval end
         RandomDevice(unlimited::Bool=true) = new(open(unlimited ? "/dev/urandom" : "/dev/random"))
     end
 
-    rand {T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice,  ::Type{T})  = read( rd.file, T)
+    rand{ T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice,  ::Type{T})  = read( rd.file, T)
     rand!{T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice, A::Array{T}) = read!(rd.file, A)
 end
 

base/rational.jl

@@ -184,16 +184,16 @@ end
 fma(x::Rational, y::Rational, z::Rational) = x*y+z
 
 ==(x::Rational, y::Rational) = (x.den == y.den) & (x.num == y.num)
-< (x::Rational, y::Rational) = x.den == y.den ? x.num < y.num :
+<( x::Rational, y::Rational) = x.den == y.den ? x.num < y.num :
                                widemul(x.num,y.den) < widemul(x.den,y.num)
 <=(x::Rational, y::Rational) = x.den == y.den ? x.num <= y.num :
                                widemul(x.num,y.den) <= widemul(x.den,y.num)
 
 
 ==(x::Rational, y::Integer ) = (x.den == 1) & (x.num == y)
 ==(x::Integer , y::Rational) = y == x
-< (x::Rational, y::Integer ) = x.num < widemul(x.den,y)
-< (x::Integer , y::Rational) = widemul(x,y.den) < y.num
+<( x::Rational, y::Integer ) = x.num < widemul(x.den,y)
+<( x::Integer , y::Rational) = widemul(x,y.den) < y.num
 <=(x::Rational, y::Integer ) = x.num <= widemul(x.den,y)
 <=(x::Integer , y::Rational) = widemul(x,y.den) <= y.num
 
@@ -277,7 +277,7 @@ end
 
 trunc{T}(::Type{T}, x::Rational) = convert(T,div(x.num,x.den))
 floor{T}(::Type{T}, x::Rational) = convert(T,fld(x.num,x.den))
-ceil {T}(::Type{T}, x::Rational) = convert(T,cld(x.num,x.den))
+ceil{ T}(::Type{T}, x::Rational) = convert(T,cld(x.num,x.den))
 
 function round{T}(::Type{T}, x::Rational, ::RoundingMode{:Nearest})
     q,r = divrem(x.num,x.den)
@@ -298,7 +298,7 @@ end
 
 trunc{T}(x::Rational{T}) = Rational(trunc(T,x))
 floor{T}(x::Rational{T}) = Rational(floor(T,x))
-ceil {T}(x::Rational{T}) = Rational(ceil(T,x))
+ceil{ T}(x::Rational{T}) = Rational(ceil(T,x))
 round{T}(x::Rational{T}) = Rational(round(T,x))
 
 function ^(x::Rational, n::Integer)

base/set.jl

@@ -88,7 +88,7 @@ end
 setdiff!(s::Set, xs) = (for x=xs; delete!(s,x); end; s)
 
 ==(l::Set, r::Set) = (length(l) == length(r)) && (l <= r)
-< (l::Set, r::Set) = (length(l) < length(r)) && (l <= r)
+<( l::Set, r::Set) = (length(l) < length(r)) && (l <= r)
 <=(l::Set, r::Set) = issubset(l, r)
 
 function issubset(l, r)

base/show.jl

@@ -257,8 +257,8 @@ typealias ExprNode Union{Expr, QuoteNode, SymbolNode, LineNumberNode,
 # Operators have precedence levels from 1-N, and show_unquoted defaults to a
 # precedence level of 0 (the fourth argument). The top-level print and show
 # methods use a precedence of -1 to specially allow space-separated macro syntax
-print        (io::IO, ex::ExprNode)    = (show_unquoted(io, ex, 0, -1); nothing)
-show         (io::IO, ex::ExprNode)    = show_unquoted_quote_expr(io, ex, 0, -1)
+print(        io::IO, ex::ExprNode)    = (show_unquoted(io, ex, 0, -1); nothing)
+show(         io::IO, ex::ExprNode)    = show_unquoted_quote_expr(io, ex, 0, -1)
 show_unquoted(io::IO, ex)              = show_unquoted(io, ex, 0, 0)
 show_unquoted(io::IO, ex, indent::Int) = show_unquoted(io, ex, indent, 0)
 show_unquoted(io::IO, ex, ::Int,::Int) = show(io, ex)

base/sparse/csparse.jl

@@ -71,7 +71,7 @@ function sparse{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
             j = Ri[p]
             pj = Wj[j]
             if pj >= p1
-                Rx[pj] = combine (Rx[pj], Rx[p])
+                Rx[pj] = combine(Rx[pj], Rx[p])
             else
                 Wj[j] = pdest
                 if pdest != p

examples/clustermanager/0mq/ZMQCM.jl

@@ -197,7 +197,7 @@ end
 function launch(manager::ZMQCMan, params::Dict, launched::Array, c::Condition)
     #println("launch $(params[:np])")
     for i in 1:params[:np]
-        io, pobj = open (`julia worker.jl $i`, "r")
+        io, pobj = open(`julia worker.jl $i`, "r")
 
         wconfig = WorkerConfig()
         wconfig.userdata = Dict(:zid=>i, :io=>io)