make keys() and values() return view objects. closes JuliaLang#2347

contains() should now be used for all is-element-of checking
has(d,k), for now, just does contains(keys(d),k), but is likely
to be removed or renamed haskey()

base/array.jl

@@ -1331,9 +1331,9 @@ end
 
 function findin(a, b)
  ind = Array(Int, 0)
- bset = Set(b...)
+ bset = add_each!(Set(), b)
  for i = 1:length(a)
- if has(bset, a[i])
+ if contains(bset, a[i])
  push!(ind, i)
  end
  end
@@ -1486,14 +1486,17 @@ ctranspose{T<:Number}(x::StridedMatrix{T}) = [ conj(x[j,i]) for i=1:size(x,2), j
 # set-like operators for vectors
 # These are moderately efficient, preserve order, and remove dupes.
 
-# algorithm: do intersect on sets first, then iterate through the first
-# vector and produce only those in the set
 function intersect(vs...)
  args_type = promote_type([eltype(v) for v in vs]...)
  ret = Array(args_type,0)
- all_elems = intersect([Set(v...) for v in vs]...)
  for v_elem in vs[1]
- if has(all_elems, v_elem)
+ inall = true
+ for i = 2:length(vs)
+ if !contains(vs[i], v_elem)
+ inall=false; break
+ end
+ end
+ if inall
  push!(ret, v_elem)
  end
  end
@@ -1505,7 +1508,7 @@ function union(vs...)
  seen = Set()
  for v in vs
  for v_elem in v
- if !has(seen, v_elem)
+ if !contains(seen, v_elem)
  push!(ret, v_elem)
  add!(seen, v_elem)
  end
@@ -1520,7 +1523,7 @@ function setdiff(a, b)
  ret = Array(args_type,0)
  seen = Set()
  for a_elem in a
- if !has(seen, a_elem) && !has(bset, a_elem)
+ if !contains(seen, a_elem) && !contains(bset, a_elem)
  push!(ret, a_elem)
  add!(seen, a_elem)
  end

base/darray2.jl

@@ -60,7 +60,7 @@ function defaultdist(dims, procs)
  dims = [dims...]
  chunks = ones(Int, length(dims))
  np = length(procs)
- f = sort!(keys(factor(np)), Sort.Reverse)
+ f = sort!(collect(keys(factor(np))), Sort.Reverse)
  k = 1
  while np > 1
  # repeatedly allocate largest factor to largest dim

base/deprecated.jl

@@ -185,6 +185,8 @@ export PipeString
 @deprecate remote_call remotecall
 @deprecate remote_call_fetch remotecall_fetch
 @deprecate remote_call_wait remotecall_wait
+@deprecate has(s::Set, x) contains(s, x)
+@deprecate has(s::IntSet, x) contains(s, x)
 
 @deprecate expr(hd, a...) Expr(hd, a...)
 @deprecate expr(hd, a::Array{Any,1}) Expr(hd, a...)

base/dict.jl

@@ -4,8 +4,12 @@ abstract Associative{K,V}
 
 const secret_table_token = :__c782dbf1cf4d6a2e5e3865d7e95634f2e09b5902__
 
-has(t::Associative, key) = !is(get(t, key, secret_table_token),
- secret_table_token)
+has(d::Associative, k) = contains(keys(d),k)
+
+function contains(a::Associative, p::(Any,Any))
+ v = get(a,p[1],secret_table_token)
+ !is(v, secret_table_token) && isequal(v, p[2])
+end
 
 function show{K,V}(io::IO, t::Associative{K,V})
  if isempty(t)
@@ -29,25 +33,36 @@ function show{K,V}(io::IO, t::Associative{K,V})
  end
 end
 
-function keys(T, a::Associative)
- i = 0
- keyz = Array(T,length(a))
- for (k,v) in a
- keyz[i+=1] = k
- end
- return keyz
+immutable KeyIterator{T<:Associative}
+ dict::T
+end
+immutable ValueIterator{T<:Associative}
+ dict::T
 end
-keys{K,V}(a::Associative{K,V}) = keys(K,a)
 
-function values(T, a::Associative)
- i = 0
- vals = Array(T,length(a))
- for (k,v) in a
- vals[i+=1] = v
- end
- return vals
+length(v::Union(KeyIterator,ValueIterator)) = length(v.dict)
+isempty(v::Union(KeyIterator,ValueIterator)) = isempty(v.dict)
+eltype(v::KeyIterator) = eltype(v.dict)[1]
+eltype(v::ValueIterator) = eltype(v.dict)[2]
+
+start(v::Union(KeyIterator,ValueIterator)) = start(v.dict)
+done(v::Union(KeyIterator,ValueIterator), state) = done(v.dict, state)
+
+function next(v::KeyIterator, state)
+ n = next(v.dict, state)
+ n[1][1], n[2]
+end
+
+function next(v::ValueIterator, state)
+ n = next(v.dict, state)
+ n[1][2], n[2]
 end
-values{K,V}(a::Associative{K,V}) = values(V,a)
+
+contains(v::KeyIterator, k) = !is(get(v.dict, k, secret_table_token),
+ secret_table_token)
+
+keys(a::Associative) = KeyIterator(a)
+values(a::Associative) = ValueIterator(a)
 
 function copy(a::Associative)
  b = similar(a)
@@ -451,6 +466,7 @@ function get{K,V}(h::Dict{K,V}, key, deflt)
 end
 
 has(h::Dict, key) = (ht_keyindex(h, key) >= 0)
+contains{T<:Dict}(v::KeyIterator{T}, key) = (ht_keyindex(v.dict, key) >= 0)
 
 function getkey{K,V}(h::Dict{K,V}, key, deflt)
  index = ht_keyindex(h, key)
@@ -492,6 +508,9 @@ next(t::Dict, i) = ((t.keys[i],t.vals[i]), skip_deleted(t,i+1))
 isempty(t::Dict) = (t.count == 0)
 length(t::Dict) = t.count
 
+next{T<:Dict}(v::KeyIterator{T}, i) = (v.dict.keys[i], skip_deleted(v.dict,i+1))
+next{T<:Dict}(v::ValueIterator{T}, i) = (v.dict.vals[i], skip_deleted(v.dict,i+1))
+
 # weak key dictionaries
 
 function add_weak_key(t::Dict, k, v)

base/env.jl

@@ -72,7 +72,7 @@ const ENV = EnvHash()
 
 getindex(::EnvHash, k::String) = @accessEnv k throw(KeyError(k))
 get(::EnvHash, k::String, def) = @accessEnv k (return def)
-has(::EnvHash, k::String) = _hasenv(k)
+contains(::KeyIterator{EnvHash}, k::String) = _hasenv(k)
 delete!(::EnvHash, k::String) = (v = ENV[k]; _unsetenv(k); v)
 delete!(::EnvHash, k::String, def) = has(ENV,k) ? delete!(ENV,k) : def
 setindex!(::EnvHash, v, k::String) = _setenv(k,string(v))

base/git.jl

@@ -111,7 +111,7 @@ end
 
 function write_config(file::String, cfg::Dict)
  tmp = tempname()
- for key in sort!(keys(cfg))
+ for key in sort!(collect(keys(cfg)))
  val = cfg[key]
  if isa(val,Array)
  for x in val

base/intset.jl

@@ -106,7 +106,7 @@ function copy!(to::IntSet, from::IntSet)
  union!(to, from)
 end
 
-function has(s::IntSet, n::Integer)
+function contains(s::IntSet, n::Integer)
  if n >= s.limit
  s.fill1s && n >= 0
  else

base/meta.jl

@@ -10,7 +10,7 @@ export quot,
 quot(ex) = Expr(:quote, ex)
 
 isexpr(ex::Expr, head) = ex.head === head
-isexpr(ex::Expr, heads::Set) = has(heads,  ex.head)
+isexpr(ex::Expr, heads::Set) = contains(heads, ex.head)
 isexpr(ex::Expr, heads::Vector) = contains(heads, ex.head)
 isexpr(ex, head) = false
 

base/pkg.jl

@@ -310,7 +310,7 @@ function _resolve()
  end
  want = Resolve.resolve(reqs,vers,deps)
 
- pkgs = sort!(keys(merge(want,have)))
+ pkgs = sort!(collect(keys(merge(want,have))))
  for pkg in pkgs
  if has(have,pkg)
  managed = cd(pkg) do

base/set.jl

@@ -14,8 +14,7 @@ isempty(s::Set) = isempty(s.dict)
 length(s::Set) = length(s.dict)
 eltype{T}(s::Set{T}) = T
 
-has(s::Set, x) = has(s.dict, x)
-contains(s::Set, x) = has(s, x)
+contains(s::Set, x) = has(s.dict, x)
 
 add!(s::Set, x) = (s.dict[x] = nothing; s)
 delete!(s::Set, x) = (delete!(s.dict, x); x)
@@ -62,7 +61,7 @@ function intersect(s::Set, sets::Set...)
  i = copy(s)
  for x in s
  for t in sets
- if !has(t,x) & has(i,x)
+ if !contains(t,x) & contains(i,x)
  delete!(i,x)
  end
  end
@@ -73,7 +72,7 @@ end
 function setdiff(a::Set, b::Set)
  d = copy(a)
  for x in b
- if has(d, x)
+ if contains(d, x)
  delete!(d, x)
  end
  end
@@ -88,7 +87,7 @@ isequal(l::Set, r::Set) = (length(l) == length(r)) && (l <= r)
 isless(l::Set, r::Set) = (length(l) < length(r)) && (l <= r)
 function <=(l::Set, r::Set)
  for elt in l
- if !has(r, elt)
+ if !contains(r, elt)
  return false
  end
  end

base/show.jl

@@ -140,8 +140,8 @@ function show_indented(io::IO, ex::Expr, indent::Int)
 end
 const paren_quoted_syms = Set{Symbol}(:(:),:(::),:(:=),:(=),:(==),:(===),:(=>))
 function show_indented(io::IO, sym::Symbol, indent::Int)
- if has(paren_quoted_syms, sym); print(io, ":($sym)") 
- else print(io, ":$sym") 
+ if contains(paren_quoted_syms, sym); print(io, ":($sym)")
+ else  print(io, ":$sym")
  end
 end
 function default_show_quoted(io::IO, ex, indent::Int)
@@ -227,9 +227,9 @@ function show_unquoted(io::IO, ex::Expr, indent::Int)
  show_unquoted(io, args[2], indent + indent_width)
  print(io, ')')
  end 
- elseif (has(_expr_infix, head) && nargs==2) || (is(head,:(:)) && nargs==3)
+ elseif (contains(_expr_infix, head) && nargs==2) || (is(head,:(:)) && nargs==3)
  show_list(io, args, head, indent)
- elseif has(_expr_infix_wide, head) && nargs == 2
+ elseif contains(_expr_infix_wide, head) && nargs == 2
  show_list(io, args, " $head ", indent)
  elseif is(head, symbol("::")) && nargs == 1
  print(io, "::") 

base/sparse.jl

@@ -183,9 +183,9 @@ end
 
 # Construct a sparse vector
 
-sparsevec{K<:Integer,V}(d::Dict{K,V}, len::Int) = sparsevec(keys(d), values(d), len)
+sparsevec{K<:Integer,V}(d::Dict{K,V}, len::Int) = sparsevec(collect(keys(d)), collect(values(d)), len)
 
-sparsevec{K<:Integer,V}(d::Dict{K,V}) = sparsevec(keys(d), values(d))
+sparsevec{K<:Integer,V}(d::Dict{K,V}) = sparsevec(collect(keys(d)), collect(values(d)))
 
 sparsevec(I::AbstractVector, V, m::Integer) = sparsevec(I, V, m, +)
 

test/corelib.jl

@@ -118,7 +118,7 @@ let
 end
 
 _d = {"a"=>0}
-@test isa([k for k in filter(x->length(x)==1, keys(_d))], Vector{Any})
+@test isa([k for k in filter(x->length(x)==1, collect(keys(_d)))], Vector{Any})
 
 # issue #1821
 let
@@ -154,7 +154,7 @@ begin
  if id > 0
  x = xs[id]
  add!(s, x)
- @test has(s, x) # check that x can be found
+ @test contains(s, x) # check that x can be found
  else
  delete!(s, xs[-id])
  end
@@ -258,8 +258,6 @@ for i in 1:2:1000
  delete!(s, i)
 end
 for i in 1:2:1000
- @test !has(s, i)
- @test has(s, i+1)
  @test !contains(s, i)
  @test contains(s, i+1)
 end
@@ -351,8 +349,8 @@ c = copy(s)
 @test isequal(s,c)
 add!(s,100)
 add!(c,200)
-@test !has(c, 100)
-@test !has(s, 200)
+@test !contains(c, 100)
+@test !contains(s, 200)
 
 # start, done, next
 for data_in in ((7,8,4,5),
@@ -368,7 +366,7 @@ for data_in in ((7,8,4,5),
  t = tuple(s...)
  @test length(t) == length(s)
  for e in t
- @test has(s,e)
+ @test contains(s,e)
  end
 end
 
@@ -388,8 +386,8 @@ origs = Set(1,2,3,"apple")
 s = copy(origs)
 for i in 1:length(origs)
  el = pop!(s)
- @test !has(s, el)
- @test has(origs, el)
+ @test !contains(s, el)
+ @test contains(origs, el)
 end
 @test isempty(s)
 # isequal