Merge pull request #152 from JuliaParallel/fbot/deps

Fix deprecations

Author: andreasnoack

src/darray.jl

@@ -22,7 +22,7 @@ For example, the `dfill` function that creates a distributed array and fills it
 dfill(v, args...) = DArray(I->fill(v, map(length,I)), args...)
 ```
 """
-type DArray{T,N,A} <: AbstractArray{T,N}
+mutable struct DArray{T,N,A} <: AbstractArray{T,N}
     id::Tuple
     dims::NTuple{N,Int}
     pids::Array{Int,N}                          # pids[i]==p ⇒ processor p has piece i
@@ -63,14 +63,14 @@ function d_from_weakref_or_d(id)
     return d
 end
 
-eltype{T}(::Type{DArray{T}}) = T
+eltype(::Type{DArray{T}}) where {T} = T
 empty_localpart(T,N,A) = A(Array{T}(ntuple(zero, N)))
 
 const SubDArray{T,N,D<:DArray} = SubArray{T,N,D}
 const SubOrDArray{T,N} = Union{DArray{T,N}, SubDArray{T,N}}
 
-localtype{T,N,S}(::Type{DArray{T,N,S}}) = S
-localtype{T,N,D}(::Type{SubDArray{T,N,D}}) = localtype(D)
+localtype(::Type{DArray{T,N,S}}) where {T,N,S} = S
+localtype(::Type{SubDArray{T,N,D}}) where {T,N,D} = localtype(D)
 localtype(A::SubOrDArray) = localtype(typeof(A))
 localtype(A::AbstractArray) = typeof(A)
 
@@ -153,7 +153,7 @@ function ddata(;T::Type=Any, init::Function=I->nothing, pids=workers(), data::Ve
     d
 end
 
-function gather{T}(d::DArray{T,1,T})
+function gather(d::DArray{T,1,T}) where T
     a=Array{T}(length(procs(d)))
     @sync for (i,p) in enumerate(procs(d))
         @async a[i] = remotecall_fetch(localpart, p, d)
@@ -245,12 +245,12 @@ sz_localpart_ref(ref, id) = size(fetch(ref))
 
 Base.similar(d::DArray, T::Type, dims::Dims) = DArray(I->Array{T}(map(length,I)), dims, procs(d))
 Base.similar(d::DArray, T::Type) = similar(d, T, size(d))
-Base.similar{T}(d::DArray{T}, dims::Dims) = similar(d, T, dims)
-Base.similar{T}(d::DArray{T}) = similar(d, T, size(d))
+Base.similar(d::DArray{T}, dims::Dims) where {T} = similar(d, T, dims)
+Base.similar(d::DArray{T}) where {T} = similar(d, T, size(d))
 
 Base.size(d::DArray) = d.dims
 
-chunktype{T,N,A}(d::DArray{T,N,A}) = A
+chunktype(d::DArray{T,N,A}) where {T,N,A} = A
 
 ## chunk index utilities ##
 
@@ -324,7 +324,7 @@ d[:L], d[:l], d[:LP], d[:lp] are an alternative means to get localparts.
 This syntaxt can also be used for assignment. For example,
 `d[:L]=v` will assign `v` to the localpart of `d`.
 """
-function localpart{T,N,A}(d::DArray{T,N,A})
+function localpart(d::DArray{T,N,A}) where {T,N,A}
     lpidx = localpartindex(d)
     if lpidx == 0
         return empty_localpart(T,N,A)::A
@@ -341,15 +341,15 @@ function Base.getindex(d::DArray, s::Symbol)
     return localpart(d)
 end
 
-function Base.setindex!{T,N,A}(d::DArray{T,N,A}, new_lp::A, s::Symbol)
+function Base.setindex!(d::DArray{T,N,A}, new_lp::A, s::Symbol) where {T,N,A}
     @assert s in [:L, :l, :LP, :lp]
     d.localpart = new_lp
     new_lp
 end
 
 
 # fetch localpart of d at pids[i]
-fetch{T,N,A}(d::DArray{T,N,A}, i) = remotecall_fetch(localpart, d.pids[i], d)
+fetch(d::DArray{T,N,A}, i) where {T,N,A} = remotecall_fetch(localpart, d.pids[i], d)
 
 """
     localindexes(d)
@@ -369,7 +369,7 @@ end
 locate(d::DArray, I::Int...) =
     ntuple(i -> searchsortedlast(d.cuts[i], I[i]), ndims(d))
 
-chunk{T,N,A}(d::DArray{T,N,A}, i...) = remotecall_fetch(localpart, d.pids[i...], d)::A
+chunk(d::DArray{T,N,A}, i...) where {T,N,A} = remotecall_fetch(localpart, d.pids[i...], d)::A
 
 ## convenience constructors ##
 
@@ -380,8 +380,8 @@ Construct a distributed array of zeros.
 Trailing arguments are the same as those accepted by `DArray`.
 """
 dzeros(dims::Dims, args...) = DArray(I->zeros(map(length,I)), dims, args...)
-dzeros{T}(::Type{T}, dims::Dims, args...) = DArray(I->zeros(T,map(length,I)), dims, args...)
-dzeros{T}(::Type{T}, d1::Integer, drest::Integer...) = dzeros(T, convert(Dims, tuple(d1, drest...)))
+dzeros(::Type{T}, dims::Dims, args...) where {T} = DArray(I->zeros(T,map(length,I)), dims, args...)
+dzeros(::Type{T}, d1::Integer, drest::Integer...) where {T} = dzeros(T, convert(Dims, tuple(d1, drest...)))
 dzeros(d1::Integer, drest::Integer...) = dzeros(Float64, convert(Dims, tuple(d1, drest...)))
 dzeros(d::Dims) = dzeros(Float64, d)
 
@@ -393,8 +393,8 @@ Construct a distributed array of ones.
 Trailing arguments are the same as those accepted by `DArray`.
 """
 dones(dims::Dims, args...) = DArray(I->ones(map(length,I)), dims, args...)
-dones{T}(::Type{T}, dims::Dims, args...) = DArray(I->ones(T,map(length,I)), dims, args...)
-dones{T}(::Type{T}, d1::Integer, drest::Integer...) = dones(T, convert(Dims, tuple(d1, drest...)))
+dones(::Type{T}, dims::Dims, args...) where {T} = DArray(I->ones(T,map(length,I)), dims, args...)
+dones(::Type{T}, d1::Integer, drest::Integer...) where {T} = dones(T, convert(Dims, tuple(d1, drest...)))
 dones(d1::Integer, drest::Integer...) = dones(Float64, convert(Dims, tuple(d1, drest...)))
 dones(d::Dims) = dones(Float64, d)
 
@@ -465,9 +465,9 @@ function distribute(A::AbstractArray, DA::DArray)
     return DArray(I->localpart(s), DA)
 end
 
-Base.convert{T,N,S<:AbstractArray}(::Type{DArray{T,N,S}}, A::S) = distribute(convert(AbstractArray{T,N}, A))
+Base.convert(::Type{DArray{T,N,S}}, A::S) where {T,N,S<:AbstractArray} = distribute(convert(AbstractArray{T,N}, A))
 
-Base.convert{S,T,N}(::Type{Array{S,N}}, d::DArray{T,N}) = begin
+Base.convert(::Type{Array{S,N}}, d::DArray{T,N}) where {S,T,N} = begin
     a = Array{S}(size(d))
     @sync begin
         for i = 1:length(d.pids)
@@ -477,7 +477,7 @@ Base.convert{S,T,N}(::Type{Array{S,N}}, d::DArray{T,N}) = begin
     return a
 end
 
-Base.convert{S,T,N}(::Type{Array{S,N}}, s::SubDArray{T,N}) = begin
+Base.convert(::Type{Array{S,N}}, s::SubDArray{T,N}) where {S,T,N} = begin
     I = s.indexes
     d = s.parent
     if isa(I,Tuple{Vararg{UnitRange{Int}}}) && S<:T && T<:S
@@ -492,7 +492,7 @@ Base.convert{S,T,N}(::Type{Array{S,N}}, s::SubDArray{T,N}) = begin
     return a
 end
 
-function Base.convert{T,N}(::Type{DArray}, SD::SubArray{T,N})
+function Base.convert(::Type{DArray}, SD::SubArray{T,N}) where {T,N}
     D = SD.parent
     DArray(size(SD), procs(D)) do I
         TR = typeof(SD.indexes[1])
@@ -511,7 +511,7 @@ function Base.convert{T,N}(::Type{DArray}, SD::SubArray{T,N})
     end
 end
 
-Base.reshape{T,S<:Array}(A::DArray{T,1,S}, d::Dims) = begin
+Base.reshape(A::DArray{T,1,S}, d::Dims) where {T,S<:Array} = begin
     if prod(d) != length(A)
         throw(DimensionMismatch("dimensions must be consistent with array size"))
     end
@@ -539,7 +539,7 @@ end
 ## indexing ##
 
 getlocalindex(d::DArray, idx...) = localpart(d)[idx...]
-function getindex_tuple{T}(d::DArray{T}, I::Tuple{Vararg{Int}})
+function getindex_tuple(d::DArray{T}, I::Tuple{Vararg{Int}}) where T
     chidx = locate(d, I...)
     idxs = d.indexes[chidx...]
     localidx = ntuple(i -> (I[i] - first(idxs[i]) + 1), ndims(d))
@@ -626,22 +626,22 @@ function restrict_indices(a::Tuple{Any, Any, Vararg{Any}}, b::Tuple{Any})
     end
 end
 
-immutable ProductIndices{I,N} <: AbstractArray{Bool, N}
+struct ProductIndices{I,N} <: AbstractArray{Bool, N}
     indices::I
     sz::NTuple{N,Int}
 end
 Base.size(P::ProductIndices) = P.sz
 # This gets passed to map to avoid breaking propagation of inbounds
 Base.@propagate_inbounds propagate_getindex(A, I...) = A[I...]
-Base.@propagate_inbounds Base.getindex{_,N}(P::ProductIndices{_,N}, I::Vararg{Int, N}) =
+Base.@propagate_inbounds Base.getindex(P::ProductIndices{_,N}, I::Vararg{Int, N}) where {_,N} =
     Bool((&)(map(propagate_getindex, P.indices, I)...))
 
-immutable MergedIndices{I,N} <: AbstractArray{CartesianIndex{N}, N}
+struct MergedIndices{I,N} <: AbstractArray{CartesianIndex{N}, N}
     indices::I
     sz::NTuple{N,Int}
 end
 Base.size(M::MergedIndices) = M.sz
-Base.@propagate_inbounds Base.getindex{_,N}(M::MergedIndices{_,N}, I::Vararg{Int, N}) =
+Base.@propagate_inbounds Base.getindex(M::MergedIndices{_,N}, I::Vararg{Int, N}) where {_,N} =
     CartesianIndex(map(propagate_getindex, M.indices, I))
 # Additionally, we optimize bounds checking when using MergedIndices as an
 # array index since checking, e.g., A[1:500, 1:500] is *way* faster than

src/linalg.jl

@@ -1,12 +1,12 @@
-function Base.ctranspose{T}(D::DArray{T,2})
+function Base.ctranspose(D::DArray{T,2}) where T
     DArray(reverse(size(D)), procs(D)) do I
         lp = Array{T}(map(length, I))
         rp = convert(Array, D[reverse(I)...])
         ctranspose!(lp, rp)
     end
 end
 
-function Base.transpose{T}(D::DArray{T,2})
+function Base.transpose(D::DArray{T,2}) where T
     DArray(reverse(size(D)), procs(D)) do I
         lp = Array{T}(map(length, I))
         rp = convert(Array, D[reverse(I)...])

src/mapreduce.jl

@@ -2,14 +2,14 @@
 
 Base.map(f, d::DArray) = DArray(I->map(f, localpart(d)), d)
 
-Base.map!{F}(f::F, dest::DArray, src::DArray) = begin
+Base.map!(f::F, dest::DArray, src::DArray) where {F} = begin
     @sync for p in procs(dest)
         @async remotecall_fetch(() -> (map!(f, localpart(dest), src[localindexes(dest)...]); nothing), p)
     end
     return dest
 end
 
-Base.Broadcast._containertype{D<:DArray}(::Type{D}) = DArray
+Base.Broadcast._containertype(::Type{D}) where {D<:DArray} = DArray
 
 Base.Broadcast.promote_containertype(::Type{DArray}, ::Type{DArray}) = DArray
 Base.Broadcast.promote_containertype(::Type{DArray}, ::Type{Array})  = DArray
@@ -61,7 +61,7 @@ Base.mapreduce(f, opt::Function, d::DArray) = _mapreduce(f, opt, d)
 Base.mapreduce(f, opt, d::DArray) = _mapreduce(f, opt, d)
 
 # mapreducedim
-Base.reducedim_initarray{R}(A::DArray, region, v0, ::Type{R}) = begin
+Base.reducedim_initarray(A::DArray, region, v0, ::Type{R}) where {R} = begin
     # Store reduction on lowest pids
     pids = A.pids[ntuple(i -> i in region ? (1:1) : (:), ndims(A))...]
     chunks = similar(pids, Future)
@@ -70,9 +70,9 @@ Base.reducedim_initarray{R}(A::DArray, region, v0, ::Type{R}) = begin
     end
     return DArray(chunks)
 end
-Base.reducedim_initarray{T}(A::DArray, region, v0::T) = Base.reducedim_initarray(A, region, v0, T)
+Base.reducedim_initarray(A::DArray, region, v0::T) where {T} = Base.reducedim_initarray(A, region, v0, T)
 
-Base.reducedim_initarray0{R}(A::DArray, region, v0, ::Type{R}) = begin
+Base.reducedim_initarray0(A::DArray, region, v0, ::Type{R}) where {R} = begin
     # Store reduction on lowest pids
     pids = A.pids[ntuple(i -> i in region ? (1:1) : (:), ndims(A))...]
     chunks = similar(pids, Future)
@@ -81,7 +81,7 @@ Base.reducedim_initarray0{R}(A::DArray, region, v0, ::Type{R}) = begin
     end
     return DArray(chunks)
 end
-Base.reducedim_initarray0{T}(A::DArray, region, v0::T) = Base.reducedim_initarray0(A, region, v0, T)
+Base.reducedim_initarray0(A::DArray, region, v0::T) where {T} = Base.reducedim_initarray0(A, region, v0, T)
 
 # Compute mapreducedim of each localpart and store the result in a new DArray
 mapreducedim_within(f, op, A::DArray, region) = begin
@@ -180,17 +180,6 @@ end
 # Unary vector functions
 (-)(D::DArray) = map(-, D)
 
-@static if VERSION < v"0.6.0-dev.1731"
-    # scalar ops
-    (+)(A::DArray{Bool}, x::Bool) = A .+ x
-    (+)(x::Bool, A::DArray{Bool}) = x .+ A
-    (-)(A::DArray{Bool}, x::Bool) = A .- x
-    (-)(x::Bool, A::DArray{Bool}) = x .- A
-    (+)(A::DArray, x::Number) = A .+ x
-    (+)(x::Number, A::DArray) = x .+ A
-    (-)(A::DArray, x::Number) = A .- x
-    (-)(x::Number, A::DArray) = x .- A
-end
 
 map_localparts(f::Callable, d::DArray) = DArray(i->f(localpart(d)), d)
 map_localparts(f::Callable, d1::DArray, d2::DArray) = DArray(d1) do I
@@ -226,14 +215,6 @@ end
 # the same size and distribution
 map_localparts(f::Callable, As::DArray...) = DArray(I->f(map(localpart, As)...), As[1])
 
-@static if VERSION < v"0.6.0-dev.1632"
-    for f in (:.+, :.-, :.*, :./, :.%, :.<<, :.>>, :div, :mod, :rem, :&, :|, :$)
-        @eval begin
-            ($f){T}(A::DArray{T}, B::Number) = map_localparts(r->($f)(r, B), A)
-            ($f){T}(A::Number, B::DArray{T}) = map_localparts(r->($f)(A, r), B)
-        end
-    end
-end
 
 function samedist(A::DArray, B::DArray)
     (size(A) == size(B)) || throw(DimensionMismatch())
@@ -245,27 +226,16 @@ end
 
 for f in (:+, :-, :div, :mod, :rem, :&, :|, :$)
     @eval begin
-        function ($f){T}(A::DArray{T}, B::DArray{T})
+        function ($f)(A::DArray{T}, B::DArray{T}) where T
             B = samedist(A, B)
             map_localparts($f, A, B)
         end
-        ($f){T}(A::DArray{T}, B::Array{T}) = map_localparts($f, A, B)
-        ($f){T}(A::Array{T}, B::DArray{T}) = map_localparts($f, A, B)
-    end
-end
-@static if VERSION < v"0.6.0-dev.1632"
-    for f in (:.+, :.-, :.*, :./, :.%, :.<<, :.>>)
-        @eval begin
-            function ($f){T}(A::DArray{T}, B::DArray{T})
-                map_localparts($f, A, B)
-            end
-            ($f){T}(A::DArray{T}, B::Array{T}) = map_localparts($f, A, B)
-            ($f){T}(A::Array{T}, B::DArray{T}) = map_localparts($f, A, B)
-        end
+        ($f)(A::DArray{T}, B::Array{T}) where {T} = map_localparts($f, A, B)
+        ($f)(A::Array{T}, B::DArray{T}) where {T} = map_localparts($f, A, B)
     end
 end
 
-function mapslices{T,N,A}(f::Function, D::DArray{T,N,A}, dims::AbstractVector)
+function mapslices(f::Function, D::DArray{T,N,A}, dims::AbstractVector) where {T,N,A}
     if !all(t -> t == 1, size(D.indexes)[dims])
         p = ones(Int, ndims(D))
         nondims = filter(t -> !(t in dims), 1:ndims(D))

src/serialize.jl

@@ -1,4 +1,4 @@
-function Base.serialize{T,N,A}(S::AbstractSerializer, d::DArray{T,N,A})
+function Base.serialize(S::AbstractSerializer, d::DArray{T,N,A}) where {T,N,A}
     # Only send the ident for participating workers - we expect the DArray to exist in the
     # remote registry. DO NOT send the localpart.
     destpid = Base.worker_id_from_socket(S.io)
@@ -14,7 +14,7 @@ function Base.serialize{T,N,A}(S::AbstractSerializer, d::DArray{T,N,A})
     end
 end
 
-function Base.deserialize{DT<:DArray}(S::AbstractSerializer, t::Type{DT})
+function Base.deserialize(S::AbstractSerializer, t::Type{DT}) where DT<:DArray
     what = deserialize(S)
     id_only = what[1]
     id = what[2]
@@ -42,7 +42,7 @@ function Base.deserialize{DT<:DArray}(S::AbstractSerializer, t::Type{DT})
 end
 
 # Serialize only those parts of the object as required by the destination worker.
-type DestinationSerializer
+mutable struct DestinationSerializer
     generate::Nullable{Function}     # Function to generate the part to be serialized
     pids::Nullable{Array}            # MUST have the same shape as the distribution
 
@@ -68,7 +68,7 @@ function Base.serialize(S::AbstractSerializer, s::DestinationSerializer)
     serialize(S, get(s.generate)(pididx))
 end
 
-function Base.deserialize{T<:DestinationSerializer}(S::AbstractSerializer, t::Type{T})
+function Base.deserialize(S::AbstractSerializer, t::Type{T}) where T<:DestinationSerializer
     lpart = deserialize(S)
     return DestinationSerializer(lpart)
 end

src/sort.jl

@@ -14,7 +14,7 @@ function sample_n_setup_ref(d::DVector, sample_size; kwargs...)
 end
 
 
-function scatter_n_sort_localparts{T}(d, myidx, refs, boundaries::Array{T}; by = identity, kwargs...)
+function scatter_n_sort_localparts(d, myidx, refs, boundaries::Array{T}; by = identity, kwargs...) where T
     if d==nothing
         sorted = take!(refs[myidx])  # First entry in the remote channel is sorted localpart
     else
@@ -59,7 +59,7 @@ function scatter_n_sort_localparts{T}(d, myidx, refs, boundaries::Array{T}; by =
     return (sorted_ref, length(lp_sorting))
 end
 
-function compute_boundaries{T}(d::DVector{T}; kwargs...)
+function compute_boundaries(d::DVector{T}; kwargs...) where T
     pids = procs(d)
     np = length(pids)
     sample_sz_on_wrkr = 512
@@ -100,7 +100,7 @@ Keyword argument `sample` can take values:
 
 Keyword argument `alg` takes the same options `Base.sort`
 """
-function Base.sort{T}(d::DVector{T}; sample=true, kwargs...)
+function Base.sort(d::DVector{T}; sample=true, kwargs...) where T
     pids = procs(d)
     np = length(pids)
 

src/spmd.jl

@@ -5,15 +5,15 @@ export sendto, recvfrom, recvfrom_any, barrier, bcast, scatter, gather
 export context_local_storage, context, spmd, close
 
 
-type WorkerDataChannel
+mutable struct WorkerDataChannel
     pid::Int
     rc::Nullable{RemoteChannel}
     lock::ReentrantLock
 
     WorkerDataChannel(pid) = new(pid, Nullable{RemoteChannel}(), ReentrantLock())
 end
 
-type SPMDContext
+mutable struct SPMDContext
     id::Tuple
     chnl::Channel
     store::Dict{Any,Any}