Merge remote-tracking branch 'origin/master'

Author: Shashi Gowda

Diff for: src/array/alloc.jl

@@ -1,7 +1,7 @@
 import Base: cat
 export partition
 
-type AllocateArray{T,N} <: ArrayOp{T,N}
+mutable struct AllocateArray{T,N} <: ArrayOp{T,N}
     eltype::Type{T}
     f::Function
     domain::ArrayDomain{N}

Diff for: src/array/darray.jl

@@ -4,15 +4,8 @@ using Compat
 
 ###### Array Domains ######
 
-if VERSION >= v"0.6.0-dev"
-    # TODO: Fix this better!
-    immutable ArrayDomain{N}
-        indexes::NTuple{N, Any}
-    end
-else
-    immutable ArrayDomain{N}
-        indexes::NTuple{N}
-    end
+struct ArrayDomain{N}
+    indexes::NTuple{N, Any}
 end
 
 include("../lib/domain-blocks.jl")
@@ -22,7 +15,7 @@ ArrayDomain(xs...) = ArrayDomain(xs)
 ArrayDomain(xs::Array) = ArrayDomain((xs...,))
 
 indexes(a::ArrayDomain) = a.indexes
-chunks{N}(a::ArrayDomain{N}) = DomainBlocks(
+chunks(a::ArrayDomain{N}) where {N} = DomainBlocks(
     ntuple(i->first(indexes(a)[i]), Val{N}), map(x->[length(x)], indexes(a)))
 
 (==)(a::ArrayDomain, b::ArrayDomain) = indexes(a) == indexes(b)
@@ -70,8 +63,8 @@ isempty(a::ArrayDomain) = length(a) == 0
 domain(x::AbstractArray) = ArrayDomain([1:l for l in size(x)])
 
 
-@compat abstract type ArrayOp{T, N} <: AbstractArray{T, N} end
-@compat Base.IndexStyle(::Type{<:ArrayOp}) = IndexCartesian()
+abstract type ArrayOp{T, N} <: AbstractArray{T, N} end
+Base.IndexStyle(::Type{<:ArrayOp}) = IndexCartesian()
 
 compute(ctx, x::ArrayOp) =
     compute(ctx, cached_stage(ctx, x)::DArray)
@@ -81,14 +74,14 @@ collect(ctx::Context, x::ArrayOp) =
 
 collect(x::ArrayOp) = collect(Context(), x)
 
-@compat function Base.show(io::IO, ::MIME"text/plain", x::ArrayOp)
+function Base.show(io::IO, ::MIME"text/plain", x::ArrayOp)
     write(io, string(typeof(x)))
     write(io, string(size(x)))
 end
 
 function Base.show(io::IO, x::ArrayOp)
     m = MIME"text/plain"()
-    @compat show(io, m, x)
+    show(io, m, x)
 end
 
 """
@@ -102,15 +95,15 @@ An N-dimensional distributed array of element type T.
 - `concat`: a function of type `F`. `concat(d, x, y)` takes two chunks `x` and `y`
             and concatenates them along dimension `d`. `cat` is used by default.
 """
-type DArray{T,N,F} <: ArrayOp{T, N}
+mutable struct DArray{T,N,F} <: ArrayOp{T, N}
     domain::ArrayDomain{N}
     subdomains::AbstractArray{ArrayDomain{N}, N}
     chunks::AbstractArray{Union{Chunk,Thunk}, N}
     concat::F
 end
 
 # mainly for backwards-compatibility
-(::Type{DArray{T, N}}){T,N}(domain, subdomains, chunks) = DArray(T, domain, subdomains, chunks)
+DArray{T, N}(domain, subdomains, chunks) where {T,N} = DArray(T, domain, subdomains, chunks)
 
 
 """
@@ -122,9 +115,9 @@ Creates a distributed array of element type T.
 
 rest of the arguments are the same as the DArray constructor.
 """
-function DArray{N}(T, domain::ArrayDomain{N},
-                subdomains::AbstractArray{ArrayDomain{N}, N},
-                chunks::AbstractArray{<:Any, N}, concat=cat)
+function DArray(T, domain::ArrayDomain{N},
+             subdomains::AbstractArray{ArrayDomain{N}, N},
+             chunks::AbstractArray{<:Any, N}, concat=cat) where N
     DArray{T, N, typeof(concat)}(domain, subdomains, chunks, concat)
 end
 
@@ -204,7 +197,7 @@ function group_indices(cumlength, idxs::Range)
 end
 
 _cumsum(x::AbstractArray) = length(x) == 0 ? Int[] : cumsum(x)
-function lookup_parts{N}(ps::AbstractArray, subdmns::DomainBlocks{N}, d::ArrayDomain{N})
+function lookup_parts(ps::AbstractArray, subdmns::DomainBlocks{N}, d::ArrayDomain{N}) where N
     groups = map(group_indices, subdmns.cumlength, indexes(d))
     sz = map(length, groups)
     pieces = Array{Union{Chunk,Thunk}}(sz)
@@ -285,7 +278,7 @@ Base.@deprecate_binding ComputedArray DArray
 
 export Distribute, distribute
 
-immutable Distribute{T, N} <: ArrayOp{T, N}
+struct Distribute{T, N} <: ArrayOp{T, N}
     domainchunks
     data::AbstractArray{T,N}
 end
@@ -294,7 +287,7 @@ size(x::Distribute) = size(domain(x.data))
 
 export BlockPartition, Blocks
 
-immutable Blocks{N}
+struct Blocks{N}
     blocksize::NTuple{N, Int}
 end
 Blocks(xs::Int...) = Blocks(xs)
@@ -318,7 +311,7 @@ function distribute(x::AbstractArray, dist)
     compute(Distribute(dist, x))
 end
 
-function distribute{T,N}(x::AbstractArray{T,N}, n::NTuple{N})
+function distribute(x::AbstractArray{T,N}, n::NTuple{N}) where {T,N}
     p = map((d, dn)->ceil(Int, d / dn), size(x), n)
     distribute(x, Blocks(p))
 end
@@ -331,10 +324,10 @@ function distribute(x::AbstractVector, n::Vector)
     distribute(x, DomainBlocks((1,), n))
 end
 
-function Base.:(==){T,S,N}(x::ArrayOp{T,N}, y::AbstractArray{S,N})
+function Base.:(==)(x::ArrayOp{T,N}, y::AbstractArray{S,N}) where {T,S,N}
     collect(x) == y
 end
 
-function Base.:(==){T,S,N}(x::AbstractArray{T,N}, y::ArrayOp{S,N})
+function Base.:(==)(x::AbstractArray{T,N}, y::ArrayOp{S,N}) where {T,S,N}
     return collect(x) == y
 end

Diff for: src/array/getindex.jl

@@ -1,6 +1,6 @@
 export getindex_async
 
-immutable GetIndex{T,N} <: ArrayOp{T,N}
+struct GetIndex{T,N} <: ArrayOp{T,N}
     input::ArrayOp
     idx::Tuple
 end
@@ -25,7 +25,7 @@ end
 
 size(x::GetIndex) = Base.index_shape(x.input, x.idx...)
 
-immutable GetIndexScalar <: Computation
+struct GetIndexScalar <: Computation
     input::ArrayOp
     idx::Tuple
 end

Diff for: src/array/map-reduce.jl

@@ -3,7 +3,7 @@ import Base: reduce, map, mapreduce, reducedim
 export reducebykey, reduce_async
 
 #### Map
-immutable Map{T,N} <: ArrayOp{T,N}
+struct Map{T,N} <: ArrayOp{T,N}
     f::Function
     inputs::Tuple
 end
@@ -30,7 +30,7 @@ map(f, x::ArrayOp, xs::ArrayOp...) = Map(f, (x, xs...))
 
 import Base: reduce, sum, prod, mean
 
-immutable ReduceBlock <: Computation
+struct ReduceBlock <: Computation
     op::Function
     op_master::Function
     input::ArrayOp
@@ -83,7 +83,7 @@ reducebykey_seq(op, itr,dict=Dict()) = mapreducebykey_seq(Base.IdFun(), op, itr,
 reducebykey(op, input) = reduceblock(itr->reducebykey_seq(op, itr), merge_reducebykey(op), input)
 
 
-immutable Reducedim{T,N} <: ArrayOp{T,N}
+struct Reducedim{T,N} <: ArrayOp{T,N}
     op::Function
     input::ArrayOp
     dims::Tuple

Diff for: src/array/matrix.jl

@@ -1,7 +1,7 @@
 
 import Base: ctranspose, transpose, A_mul_Bt, At_mul_B, Ac_mul_B, At_mul_Bt, Ac_mul_Bc, A_mul_Bc
 
-immutable Transpose{T,N} <: ArrayOp{T,N}
+struct Transpose{T,N} <: ArrayOp{T,N}
     f::Function
     input::ArrayOp
 end
@@ -46,7 +46,7 @@ end
 
 import Base: *, +
 
-immutable MatMul{T, N} <: ArrayOp{T, N}
+struct MatMul{T, N} <: ArrayOp{T, N}
     a::ArrayOp
     b::ArrayOp
 end
@@ -152,7 +152,7 @@ end
 """
 an operand which should be distributed as per convenience
 """
-function stage_operands{T}(ctx, ::MatMul, a::ArrayOp, b::PromotePartition{T,1})
+function stage_operands(ctx, ::MatMul, a::ArrayOp, b::PromotePartition{T,1}) where T
     stg_a = cached_stage(ctx, a)
     dmn_a = domain(stg_a)
     dchunks_a = domainchunks(stg_a)
@@ -188,11 +188,11 @@ end
 
 ### Scale
 
-immutable Scale{T,N} <: ArrayOp{T,N}
+struct Scale{T,N} <: ArrayOp{T,N}
     l::ArrayOp
     r::ArrayOp
 end
-Scale{Tl, Tr, N}(l::ArrayOp{Tl}, r::ArrayOp{Tr,N}) =
+Scale(l::ArrayOp{Tl}, r::ArrayOp{Tr,N}) where {Tl, Tr, N} =
   Scale{promote_type(Tl, Tr), N}(l,r)
 
 size(s::Scale) = size(s.l)
@@ -230,7 +230,7 @@ function stage(ctx, scal::Scale)
     DArray(Any, domain(r), domainchunks(r), scal_parts)
 end
 
-immutable Concat{T,N} <: ArrayOp{T,N}
+struct Concat{T,N} <: ArrayOp{T,N}
     axis::Int
     inputs::Tuple
 end

Diff for: src/array/operators.jl

@@ -27,18 +27,18 @@ broadcast_ops = [ :.*, :.+, :.-, :.%, :./, :.^,
 This is a way of suggesting that stage should call
 stage_operand with the operation and other arguments
 """
-immutable PromotePartition{T,N} <: ArrayOp{T,N}
+struct PromotePartition{T,N} <: ArrayOp{T,N}
     data::AbstractArray{T,N}
 end
 
 size(p::PromotePartition) = size(domain(p.data))
 
-immutable BCast{F, Ni, T, Nd} <: ArrayOp{T, Nd}
+struct BCast{F, Ni, T, Nd} <: ArrayOp{T, Nd}
     f::F
     input::NTuple{Ni, ArrayOp}
 end
 
-function BCast{F}(f::F, input::Tuple)
+function BCast(f::F, input::Tuple) where F
     T = promote_type(map(eltype, input)...)
     Nd = reduce(max, map(ndims, input))
     BCast{F, length(input), T, Nd}(f, input)
@@ -86,18 +86,6 @@ for fn in blockwise_binary
     end
 end
 
-if VERSION < v"0.6.0-dev"
-    eval(:((.^)(x::Irrational{:e}, y::ArrayOp) = BCast(z -> x.^z, (y,))))
-    for fn in broadcast_ops
-        @eval begin
-            $fn(x::ArrayOp, y::ArrayOp) = BCast($fn, (x, y))
-            $fn(x::AbstractArray, y::ArrayOp) = BCast($fn, (PromotePartition(x), y))
-            $fn(x::ArrayOp, y::AbstractArray) = BCast($fn, (x, PromotePartition(y)))
-            $fn(x::Number, y::ArrayOp) = BCast(z -> $fn(x, z), (y,))
-            $fn(x::ArrayOp, y::Number) = BCast(z -> $fn(z, y), (x,))
-        end
-    end
-end
 
 Base.broadcast(fn::Function, x::ArrayOp, xs::ArrayOp...) = BCast(fn, (x, xs...))
 Base.broadcast(fn::Function, x::AbstractArray, y::ArrayOp) = BCast(fn, (PromotePartition(x), y))
@@ -143,7 +131,7 @@ end
 
 export mappart, mapchunk
 
-immutable MapChunk{F, Ni, T, Nd} <: ArrayOp{T, Nd}
+struct MapChunk{F, Ni, T, Nd} <: ArrayOp{T, Nd}
     f::F
     input::NTuple{Ni, ArrayOp{T,Nd}}
 end

Diff for: src/array/setindex.jl

@@ -1,7 +1,7 @@
 
 export setindex
 
-immutable SetIndex{T,N} <: ArrayOp{T,N}
+struct SetIndex{T,N} <: ArrayOp{T,N}
     input::ArrayOp{T,N}
     idx::Tuple
     val

Diff for: src/array/sort.jl

@@ -3,7 +3,7 @@ import Compat: view
 
 import Base.Sort: Forward, Ordering, Algorithm, defalg, lt
 
-immutable Sort <: Computation
+struct Sort <: Computation
     input::ArrayOp
     alg::Algorithm
     order::Ordering
@@ -244,7 +244,7 @@ function shuffle_merge(A, ranks, splitter_indices, ord)
     DArray(eltype(A), dmn, dmnchunks, map(x->x[1], thunks))
 end
 
-function merge_sorted{T, S}(ord::Ordering, x::AbstractArray{T}, y::AbstractArray{S})
+function merge_sorted(ord::Ordering, x::AbstractArray{T}, y::AbstractArray{S}) where {T, S}
     n = length(x) + length(y)
     z = Array{promote_type(T,S)}(n)
     i = 1; j = 1; k = 1

Diff for: src/chunks.jl

@@ -20,7 +20,7 @@ function domain end
 """
 Default domain -- has no information about the value
 """
-immutable UnitDomain end
+struct UnitDomain end
 
 """
 If no `domain` method is defined on an object, then
@@ -33,7 +33,7 @@ domain(x::Any) = UnitDomain()
 """
 A chunk with some data
 """
-type Chunk{T, H}
+mutable struct Chunk{T, H}
     chunktype::Type{T}
     domain
     handle::H
@@ -45,7 +45,8 @@ chunktype(c::Chunk) = c.chunktype
 persist!(t::Chunk) = (t.persist=true; t)
 shouldpersist(p::Chunk) = t.persist
 affinity(c::Chunk) = affinity(c.handle)
-function unrelease{T}(c::Chunk{T,DRef})
+
+function unrelease(c::Chunk{T,DRef}) where T
     # set spilltodisk = true if data is still around
     try
         destroyonevict(c.handle, false)
@@ -83,7 +84,7 @@ tochunk(x::Union{Chunk, Thunk}) = x
 
 # Check to see if the node is set to persist
 # if it is foce can override it
-function free!{X}(s::Chunk{X, DRef}; force=true, cache=false)
+function free!(s::Chunk{X, DRef}; force=true, cache=false) where X
     if force || !s.persist
         if cache
             try

Diff for: src/compute.jl

@@ -7,7 +7,7 @@ compute(ctx, c::Chunk) = c
 collect(ctx::Context, c) = collect(ctx, compute(ctx, c))
 collect(d::Union{Chunk,Thunk}) = collect(Context(), d)
 
-@compat abstract type Computation end
+abstract type Computation end
 
 compute(ctx, c::Computation) = compute(ctx, stage(ctx, c))
 collect(c::Computation) = collect(Context(), c)