Merge pull request #668 from invenia/npr/using-not-import

Replace `import` with `using`

Author: oxinabox

src/DataStructures.jl

@@ -1,24 +1,14 @@
 module DataStructures
 
-    import Base: <, <=, ==, length, isempty, iterate,
-                 show, dump, empty!, getindex, setindex!, get, get!,
-                 in, haskey, keys, merge, copy, cat, collect,
-                 push!, pop!, pushfirst!, popfirst!, insert!, lastindex,
-                 union!, delete!, similar, sizehint!, empty, append!,
-                 isequal, hash, map, filter, reverse, peek,
-                 first, last, eltype, getkey, values, sum,
-                 merge, merge!, lt, Ordering, ForwardOrdering, Forward,
-                 ReverseOrdering, Reverse, Lt,
-                 isless, union, intersect, symdiff, setdiff, issubset,
-                 searchsortedfirst, searchsortedlast, in,
-                 eachindex, keytype, valtype, minimum, maximum, size,
-                 zero, checkbounds, filter!, isbitstype, isbitsunion, 
-                 isiterable, dict_with_eltype, KeySet, Callable, _tablesz
+    using Base: HasEltype, HasLength, IteratorEltype, IteratorSize, SizeUnknown,
+                lt, Ordering, ForwardOrdering, Forward, ReverseOrdering, Reverse, Lt,
+                isbitsunion, isiterable, dict_with_eltype, KeySet, Callable, _tablesz,
+                findnextnot, unsafe_getindex, unsafe_setindex!, peek
 
 
     using Compat # Provides Base.Order.ReverseOrdering(). May remove this line with julia 1.4
     using OrderedCollections
-    import OrderedCollections: filter, filter!, isordered
+    using OrderedCollections: isordered
     export OrderedDict, OrderedSet, LittleDict
     export DefaultDict, DefaultOrderedDict
 

src/accumulator.jl

@@ -38,32 +38,32 @@ function eltype_for_accumulator(seq::Base.Generator)
 end
 
 
-copy(ct::Accumulator) = Accumulator(copy(ct.map))
+Base.copy(ct::Accumulator) = Accumulator(copy(ct.map))
 
-length(a::Accumulator) = length(a.map)
+Base.length(a::Accumulator) = length(a.map)
 
 ## retrieval
 
-get(ct::Accumulator, x, default) = get(ct.map, x, default)
+Base.get(ct::Accumulator, x, default) = get(ct.map, x, default)
 # need to allow user specified default in order to
 # correctly implement "informal" AbstractDict interface
 
-getindex(ct::Accumulator{T,V}, x) where {T,V} = get(ct.map, x, zero(V))
+Base.getindex(ct::Accumulator{T,V}, x) where {T,V} = get(ct.map, x, zero(V))
 
-setindex!(ct::Accumulator, x, v) = setindex!(ct.map, x, v)
+Base.setindex!(ct::Accumulator, x, v) = setindex!(ct.map, x, v)
 
 
-haskey(ct::Accumulator, x) = haskey(ct.map, x)
+Base.haskey(ct::Accumulator, x) = haskey(ct.map, x)
 
-keys(ct::Accumulator) = keys(ct.map)
+Base.keys(ct::Accumulator) = keys(ct.map)
 
-values(ct::Accumulator) = values(ct.map)
+Base.values(ct::Accumulator) = values(ct.map)
 
-sum(ct::Accumulator) = sum(values(ct.map))
+Base.sum(ct::Accumulator) = sum(values(ct.map))
 
 ## iteration
 
-iterate(ct::Accumulator, s...) = iterate(ct.map, s...)
+Base.iterate(ct::Accumulator, s...) = iterate(ct.map, s...)
 
 # manipulation
 
@@ -77,12 +77,11 @@ inc!(ct::Accumulator{T, V}, x) where {T, V} = inc!(ct, x, one(V))
 
 # inc! is preferred over push!, but we need to provide push! for the Bag interpreation
 # which is used by classified_collections.jl
-push!(ct::Accumulator, x) = inc!(ct, x)
-push!(ct::Accumulator, x, a::Number) = inc!(ct, x, a)
+Base.push!(ct::Accumulator, x) = inc!(ct, x)
+Base.push!(ct::Accumulator, x, a::Number) = inc!(ct, x, a)
 
 # To remove ambiguities related to Accumulator now being a subtype of AbstractDict
-push!(ct::Accumulator, x::Pair)  = inc!(ct, x)
-
+Base.push!(ct::Accumulator, x::Pair)  = inc!(ct, x)
 
 
 """
@@ -101,15 +100,15 @@ dec!(ct::Accumulator{T,V}, x) where {T,V} = dec!(ct, x, one(V))
 Merges the other counters into `ctl`,
 summing the counts for all elements.
 """
-function merge!(ct::Accumulator, other::Accumulator)
+function Base.merge!(ct::Accumulator, other::Accumulator)
     for (x, v) in other
         inc!(ct, x, v)
     end
     return ct
 end
 
 
-function merge!(ct1::Accumulator, others::Accumulator...)
+function Base.merge!(ct1::Accumulator, others::Accumulator...)
     for ct in others
         merge!(ct1,ct)
     end
@@ -124,7 +123,7 @@ Creates a new counter with total counts equal to the sum of the counts in the co
 
 See also merge!
 """
-function merge(ct1::Accumulator, others::Accumulator...)
+function Base.merge(ct1::Accumulator, others::Accumulator...)
     ct = copy(ct1)
     merge!(ct,others...)
 end

src/balanced_tree.jl

@@ -145,8 +145,6 @@ mutable struct BalancedTree23{K, D, Ord <: Ordering}
 end
 
 
-
-
 ## Function cmp2 checks a tree node with two children
 ## against a given key, and returns 1 if the given key is
 ## less than the node's splitkey or 2 else.  Special case
@@ -160,7 +158,6 @@ end
 end
 
 
-
 @inline function cmp2_leaf(o::Ordering,
                            treenode::TreeNode,
                            k)
@@ -169,7 +166,6 @@ end
 end
 
 
-
 ## Function cmp3 checks a tree node with three children
 ## against a given key, and returns 1 if the given key is
 ## less than the node's splitkey1, 2 if the key is greater than or
@@ -193,7 +189,6 @@ end
 end
 
 
-
 ## Function cmp2le checks a tree node with two children
 ## against a given key, and returns 1 if the given key is
 ## less than or equal to the node's splitkey or 2 else.  Special case
@@ -214,8 +209,6 @@ end
 end
 
 
-
-
 ## Function cmp3le checks a tree node with three children
 ## against a given key, and returns 1 if the given key is
 ## less than or equal to the node's splitkey1, 2 if less than or equal
@@ -239,11 +232,10 @@ end
 end
 
 
-
 ## The empty! function deletes all data in the balanced tree.
 ## Therefore, it invalidates all indices.
 
-function empty!(t::BalancedTree23)
+function Base.empty!(t::BalancedTree23)
     resize!(t.data,2)
     initializeData!(t.data)
     resize!(t.tree,1)
@@ -293,7 +285,6 @@ function findkey(t::BalancedTree23, k)
 end
 
 
-
 ## The findkeyless function finds the index of a (key,data) pair in the tree that
 ## with the greatest key that is less than the given key.  If there is no
 ## key less than the given key, then it returns 1 (the before-start node).
@@ -318,7 +309,6 @@ function findkeyless(t::BalancedTree23, k)
 end
 
 
-
 ## The following are helper routines for the insert! and delete! functions.
 ## They replace the 'parent' field of either an internal tree node or
 ## a data node at the bottom tree level.
@@ -337,8 +327,6 @@ function replaceparent!(tree::Array{TreeNode{K},1}, whichind::Int, newparent::In
 end
 
 
-
-
 ## Helper function for either grabbing a brand new location in a
 ## array (if there are no free locations) or else grabbing a free
 ## location and marking it as used.  The return value is the
@@ -355,7 +343,6 @@ function push_or_reuse!(a::Vector, freelocs::Array{Int,1}, item)
 end
 
 
-
 ## Function insert! inserts a new data item into the tree.
 ## The arguments are the (K,D) pair to insert.
 ## The return values are a bool and an index.  The
@@ -367,7 +354,7 @@ end
 ## done whether the iterm
 ## is already in the tree, so insertion of a new item always succeeds.
 
-function insert!(t::BalancedTree23{K,D,Ord}, k, d, allowdups::Bool) where {K,D,Ord <: Ordering}
+function Base.insert!(t::BalancedTree23{K,D,Ord}, k, d, allowdups::Bool) where {K,D,Ord <: Ordering}
 
     ## First we find the greatest data node that is <= k.
     leafind, exactfound = findkey(t, k)
@@ -544,8 +531,6 @@ function insert!(t::BalancedTree23{K,D,Ord}, k, d, allowdups::Bool) where {K,D,O
 end
 
 
-
-
 ## nextloc0: returns the next item in the tree according to the
 ## sort order, given an index i (subscript of t.data) of a current
 ## item.
@@ -676,7 +661,7 @@ endloc(t::BalancedTree23) = prevloc0(t,2)
 
 ## delete! routine deletes an entry from the balanced tree.
 
-function delete!(t::BalancedTree23{K,D,Ord}, it::Int) where {K,D,Ord<:Ordering}
+function Base.delete!(t::BalancedTree23{K,D,Ord}, it::Int) where {K,D,Ord<:Ordering}
 
     ## Put the cell indexed by 'it' into the deletion list.
     ##

src/circ_deque.jl

@@ -37,7 +37,7 @@ Base.isempty(D::CircularDeque) = D.n == 0
 
 Get the item at the front of the queue.
 """
-@inline function first(D::CircularDeque)
+@inline function Base.first(D::CircularDeque)
     @boundscheck D.n > 0 || throw(BoundsError())
     return @inbounds D.buffer[D.first]
 end
@@ -47,7 +47,7 @@ end
 
 Get the item from the back of the queue.
 """
-@inline function last(D::CircularDeque)
+@inline function Base.last(D::CircularDeque)
     @boundscheck D.n > 0 || throw(BoundsError())
     return @inbounds D.buffer[D.last]
 end
@@ -74,7 +74,7 @@ end
 
 Add an element to the front.
 """
-@inline function pushfirst!(D::CircularDeque, v)
+@inline function Base.pushfirst!(D::CircularDeque, v)
     @boundscheck D.n < D.capacity || throw(BoundsError())
     D.n += 1
     tmp = D.first - 1
@@ -88,7 +88,7 @@ end
 
 Remove the element at the front.
 """
-@inline Base.@propagate_inbounds function popfirst!(D::CircularDeque)
+@inline Base.@propagate_inbounds function Base.popfirst!(D::CircularDeque)
     v = first(D)
     D.n -= 1
     tmp = D.first + 1
@@ -112,7 +112,7 @@ end
 end
 
 # Iteration via getindex
-@inline function iterate(d::CircularDeque, i = 1)
+@inline function Base.iterate(d::CircularDeque, i = 1)
     i == d.n + 1 ? nothing : (_unsafe_getindex(d, i), i+1)
 end
 

src/circular_buffer.jl

@@ -96,7 +96,7 @@ end
 
 Remove the element from the front of the `CircularBuffer`.
 """
-function popfirst!(cb::CircularBuffer)
+function Base.popfirst!(cb::CircularBuffer)
     @boundscheck (cb.length == 0) && throw(ArgumentError("array must be non-empty"))
     i = cb.first
     cb.first = (cb.first + 1 > cb.capacity ? 1 : cb.first + 1)
@@ -110,7 +110,7 @@ end
 Insert one or more items at the beginning of CircularBuffer
 and overwrite back if full.
 """
-function pushfirst!(cb::CircularBuffer, data)
+function Base.pushfirst!(cb::CircularBuffer, data)
     # if full, decrement and overwrite, otherwise pushfirst
     cb.first = (cb.first == 1 ? cb.capacity : cb.first - 1)
     if length(cb) < cb.capacity