Move to struct type syntax

Author: iamed2

src/categoricalvector.jl

@@ -39,7 +39,7 @@ A[(:a,:x), :]
 A[(:a,:x,:x), :]
 ```
 """
-immutable CategoricalVector{T, A<:AbstractVector{T}} <: AbstractVector{T}
+struct CategoricalVector{T, A<:AbstractVector{T}} <: AbstractVector{T}
     data::A
 end
 

src/core.jl

@@ -11,7 +11,7 @@ parametric type.
 ### Type parameters
 
 ```julia
-immutable Axis{name,T}
+struct Axis{name,T}
 ```
 * `name` : the name of the axis, a Symbol
 * `T` : the type of the axis
@@ -42,7 +42,7 @@ A[Axis{2}(2:5)] # grabs the second through 5th columns
 ```
 
 """
-immutable Axis{name,T}
+struct Axis{name,T}
     val::T
 end
 # Constructed exclusively through Axis{:symbol}(...) or Axis{1}(...)
@@ -75,7 +75,7 @@ dimension. Other advanced indexing along axis values are also provided.
 The AxisArray contains several type parameters:
 
 ```julia
-immutable AxisArray{T,N,D,Ax} <: AbstractArray{T,N}
+struct AxisArray{T,N,D,Ax} <: AbstractArray{T,N}
 ```
 * `T` : the elemental type of the AbstractArray
 * `N` : the number of dimensions
@@ -143,7 +143,7 @@ A[ClosedInterval(0.,.3), [:a, :c]]   # select an interval and two columns
 ```
 
 """
-immutable AxisArray{T,N,D,Ax} <: AbstractArray{T,N}
+struct AxisArray{T,N,D,Ax} <: AbstractArray{T,N}
     data::D  # D <:AbstractArray, enforced in constructor to avoid dispatch bugs (https://github.com/JuliaLang/julia/issues/6383)
     axes::Ax # Ax<:NTuple{N, Axis}, but with specialized Axis{...} types
     (::Type{AxisArray{T,N,D,Ax}})(data::AbstractArray{T,N}, axs::Tuple{Vararg{Axis,N}}) where {T,N,D,Ax} = new{T,N,D,Ax}(data, axs)
@@ -211,7 +211,7 @@ function AxisArray(A::AbstractArray{T,N}, names::NTuple{N,Symbol}, steps::NTuple
 end
 
 # Traits
-immutable HasAxes{B} end
+struct HasAxes{B} end
 HasAxes(::Type{<:AxisArray}) = HasAxes{true}()
 HasAxes(::Type{<:AbstractArray}) = HasAxes{false}()
 HasAxes(::A) where A<:AbstractArray = HasAxes(A)
@@ -502,9 +502,9 @@ axisparams(::Type{AxisArray{T,N,D,Ax}}) where {T,N,D,Ax} = (Ax.parameters...)
 
 ### Axis traits ###
 abstract type AxisTrait end
-immutable Dimensional <: AxisTrait end
-immutable Categorical <: AxisTrait end
-immutable Unsupported <: AxisTrait end
+struct Dimensional <: AxisTrait end
+struct Categorical <: AxisTrait end
+struct Unsupported <: AxisTrait end
 
 """
     axistrait(ax::Axis) -> Type{<:AxisTrait}

src/indexing.jl

@@ -2,7 +2,7 @@ const Idx = Union{Real,Colon,AbstractArray{Int}}
 
 using Base: ViewIndex, @propagate_inbounds, tail
 
-immutable Value{T}
+struct Value{T}
     val::T
     tol::T
 end

src/intervals.jl

@@ -55,7 +55,7 @@ end
 
 # And, finally, we have an Array-of-Structs to Struct-of-Arrays transform for
 # the common case where the interval is constant over many offsets:
-immutable RepeatedInterval{T,S,A} <: AbstractVector{T}
+struct RepeatedInterval{T,S,A} <: AbstractVector{T}
     window::ClosedInterval{S}
     offsets::A # A <: AbstractVector
 end
@@ -71,14 +71,14 @@ Base.getindex(r::RepeatedInterval, i::Int) = r.window + r.offsets[i]
 
 # As a special extension to intervals, we allow specifying Intervals about a
 # particular index, which is resolved by an axis upon indexing.
-immutable IntervalAtIndex{T}
+struct IntervalAtIndex{T}
     window::ClosedInterval{T}
     index::Int
 end
 atindex(window::ClosedInterval, index::Integer) = IntervalAtIndex(window, index)
 
 # And similarly, an AoS -> SoA transform:
-immutable RepeatedIntervalAtIndexes{T,A<:AbstractVector{Int}} <: AbstractVector{IntervalAtIndex{T}}
+struct RepeatedIntervalAtIndexes{T,A<:AbstractVector{Int}} <: AbstractVector{IntervalAtIndex{T}}
     window::ClosedInterval{T}
     indexes::A # A <: AbstractVector{Int}
 end

src/sortedvector.jl

@@ -49,7 +49,7 @@ A[ClosedInterval((:a,:x),(:b,:x)), :]
 ```
 
 """
-immutable SortedVector{T} <: AbstractVector{T}
+struct SortedVector{T} <: AbstractVector{T}
     data::AbstractVector{T}
 end
 

test/indexing.jl

@@ -107,7 +107,7 @@ v = AxisArray(collect(.1:.1:10.0), .1:.1:10.0)
 # create a number type from which we build a StepRange but which is
 # not an Int.
 module IL  # put in a module so this file can be re-run
-immutable IntLike <: Number
+struct IntLike <: Number
     val::Int
 end
 Base.one(x::IntLike) = IntLike(0)