From ca4767260cf03f07983dc34acaa2cd22c5a9e1b9 Mon Sep 17 00:00:00 2001 From: Yichao Yu Date: Fri, 18 Sep 2015 17:01:16 -0400 Subject: [PATCH] Union() -> Union{} --- src/containerloops.jl | 40 ++++++++++++++++++++-------------------- src/hashdict.jl | 2 +- src/sortedMultiDict.jl | 6 +++--- src/tokens2.jl | 6 +++--- 4 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/containerloops.jl b/src/containerloops.jl index 168ab78dc..6309d4070 100644 --- a/src/containerloops.jl +++ b/src/containerloops.jl @@ -4,11 +4,11 @@ import Base.values ## These are the containers that can be looped over ## The prefix SDM is for SortedDict and SortedMultiDict ## The prefix SS is for SortedSet. The prefix SA -## is for all sorted containers. +## is for all sorted containers. ## The following two definitions now appear in tokens2.jl -#typealias SDMContainer Union(SortedDict, SortedMultiDict) -#typealias SAContainer Union(SDMContainer, SortedSet) +#typealias SDMContainer Union{SortedDict, SortedMultiDict} +#typealias SAContainer Union{SDMContainer, SortedSet} @inline extractcontainer(s::SAContainer) = s @@ -17,7 +17,7 @@ import Base.values abstract AbstractExcludeLast{ContainerType <: SAContainer} -immutable SDMExcludeLast{ContainerType <: SDMContainer} <: +immutable SDMExcludeLast{ContainerType <: SDMContainer} <: AbstractExcludeLast{ContainerType} m::ContainerType first::Int @@ -26,7 +26,7 @@ end -immutable SSExcludeLast{ContainerType <: SortedSet} <: +immutable SSExcludeLast{ContainerType <: SortedSet} <: AbstractExcludeLast{ContainerType} m::ContainerType first::Int @@ -65,18 +65,18 @@ eltype(s::AbstractIncludeLast) = eltype(s.m) ## The basic iterations are either over the whole sorted container, an ## exclude-last object or include-last object. -typealias SDMIterableTypesBase Union(SDMContainer, +@compat typealias SDMIterableTypesBase Union{SDMContainer, SDMExcludeLast, - SDMIncludeLast) + SDMIncludeLast} -typealias SSIterableTypesBase Union(SortedSet, +@compat typealias SSIterableTypesBase Union{SortedSet, SSExcludeLast, - SSIncludeLast) + SSIncludeLast} -typealias SAIterableTypesBase Union(SAContainer, +@compat typealias SAIterableTypesBase Union{SAContainer, AbstractExcludeLast, - AbstractIncludeLast) + AbstractIncludeLast} ## The compound iterations are obtained by applying keys(..) or values(..) @@ -111,7 +111,7 @@ immutable SSSemiTokenIteration{T <: SSIterableTypesBase} base::T end -eltype(s::SSSemiTokenIteration) = @compat Tuple{IntSemiToken, +eltype(s::SSSemiTokenIteration) = @compat Tuple{IntSemiToken, eltype(extractcontainer(s.base))} @@ -119,7 +119,7 @@ immutable SDMSemiTokenKeyIteration{T <: SDMIterableTypesBase} base::T end -eltype(s::SDMSemiTokenKeyIteration) = @compat Tuple{IntSemiToken, +eltype(s::SDMSemiTokenKeyIteration) = @compat Tuple{IntSemiToken, keytype(extractcontainer(s.base))} @@ -128,20 +128,20 @@ immutable SDMSemiTokenValIteration{T <: SDMIterableTypesBase} base::T end -eltype(s::SDMSemiTokenValIteration) = @compat Tuple{IntSemiToken, +eltype(s::SDMSemiTokenValIteration) = @compat Tuple{IntSemiToken, datatype(extractcontainer(s.base))} -typealias SACompoundIterable Union(SDMKeyIteration, - SDMValIteration, +@compat typealias SACompoundIterable Union{SDMKeyIteration, + SDMValIteration, SDMSemiTokenIteration, SSSemiTokenIteration, - SDMSemiTokenKeyIteration, - SDMSemiTokenValIteration) + SDMSemiTokenKeyIteration, + SDMSemiTokenValIteration} @inline extractcontainer(s::SACompoundIterable) = extractcontainer(s.base) - -typealias SAIterable Union(SAIterableTypesBase, SACompoundIterable) + +@compat typealias SAIterable Union{SAIterableTypesBase, SACompoundIterable} ## All the loops maintain a state which is an object of the diff --git a/src/hashdict.jl b/src/hashdict.jl index 1fa7305c3..e50be5fb2 100644 --- a/src/hashdict.jl +++ b/src/hashdict.jl @@ -16,7 +16,7 @@ end @compat typealias Unordered Void typealias Ordered Int -type HashDict{K,V,O<:Union(Ordered,Unordered)} <: Associative{K,V} +@compat type HashDict{K,V,O<:Union{Ordered,Unordered}} <: Associative{K,V} slots::Array{UInt8,1} keys::Array{K,1} vals::Array{V,1} diff --git a/src/sortedMultiDict.jl b/src/sortedMultiDict.jl index 78186ee69..545001de8 100644 --- a/src/sortedMultiDict.jl +++ b/src/sortedMultiDict.jl @@ -22,7 +22,7 @@ typealias SMDToken @compat Tuple{SortedMultiDict, IntSemiToken} ## to Forward function SortedMultiDict{K,D, Ord <: Ordering}(kk::AbstractArray{K,1}, - dd::AbstractArray{D,1}, + dd::AbstractArray{D,1}, o::Ord=Forward) if length(kk) != length(dd) throw(ArgumentError("SortedMultiDict K and D constructor array arguments must be the same length")) @@ -194,9 +194,9 @@ function isequal(m1::SortedMultiDict, m2::SortedMultiDict) end end -typealias SDorAssociative Union(Associative, SortedMultiDict) +@compat typealias SDorAssociative Union{Associative,SortedMultiDict} -function mergetwo!{K,D,Ord <: Ordering}(m::SortedMultiDict{K,D,Ord}, +function mergetwo!{K,D,Ord <: Ordering}(m::SortedMultiDict{K,D,Ord}, m2::SDorAssociative) for (k,v) in m2 insert!(m.bt, convert(K,k), convert(D,v), true) diff --git a/src/tokens2.jl b/src/tokens2.jl index e41cdde7d..2ea805891 100644 --- a/src/tokens2.jl +++ b/src/tokens2.jl @@ -3,8 +3,8 @@ import Base.isequal import Base.colon import Base.endof -typealias SDMContainer Union(SortedDict, SortedMultiDict) -typealias SAContainer Union(SDMContainer, SortedSet) +@compat typealias SDMContainer Union{SortedDict, SortedMultiDict} +@compat typealias SAContainer Union{SDMContainer, SortedSet} typealias Token @compat Tuple{SAContainer, IntSemiToken} typealias SDMToken @compat Tuple{SDMContainer, IntSemiToken} @@ -38,7 +38,7 @@ typealias SetToken @compat Tuple{SortedSet, IntSemiToken} end ## Function advances takes a token and returns the -## next token in the sorted order. +## next token in the sorted order. @inline function advance(ii::Token) not_pastend(ii)