WIP: Make sets indexable

 * All `AbstractSet`s can be indexed. They are containers with equal
   values and keys, much like `Base.OneTo(n)`. This will enable a
   certain semantic with `keys` and indexing common across arrays,
   associatives and sets.

NEWS.md

@@ -364,6 +364,9 @@ Library improvements
     This supersedes the old behavior of reinterpret on Arrays. As a result, reinterpreting
     arrays with different alignment requirements (removed in 0.6) is once again allowed ([#23750]).
 
+  * `AbstractSet`s are now indexable, such that `set[x] == x` and `keys(set) == set`
+    ([#24508]).
+
 Compiler/Runtime improvements
 -----------------------------
 

base/bitset.jl

@@ -15,15 +15,13 @@ very large integers), use [`Set`](@ref) instead.
 """
 BitSet(itr) = union!(BitSet(), itr)
 
-eltype(::Type{BitSet}) = Int
-similar(s::BitSet) = BitSet()
+empty(s::BitSet) = BitSet()
 copy(s1::BitSet) = copy!(BitSet(), s1)
 function copy!(dest::BitSet, src::BitSet)
     resize!(dest.bits, length(src.bits))
     copy!(dest.bits, src.bits)
     dest
 end
-eltype(s::BitSet) = Int
 sizehint!(s::BitSet, n::Integer) = (n > length(s.bits) && _resize0!(s.bits, n); s)
 
 # An internal function for setting the inclusion bit for a given integer n >= 0

base/set.jl

@@ -1,5 +1,19 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+# AbstractSet
+
+# AbstractSets are idempotent under indexing:
+keys(set::AbstractSet) = set
+@inline function getindex(set::AbstractSet, x)
+    @boundscheck if x ∉ set
+        throw(KeyError(x))
+    end
+    return x
+end
+eltype(set::Type{<:AbstractSet{T}}) where {T} = T
+
+# Set
+
 mutable struct Set{T} <: AbstractSet{T}
     dict::Dict{T,Void}
 
@@ -23,9 +37,8 @@ function Set(g::Generator)
     return Set{T}(g)
 end
 
-eltype(::Type{Set{T}}) where {T} = T
 similar(s::Set{T}) where {T} = Set{T}()
-similar(s::Set, T::Type) = Set{T}()
+similar(s::AbstractSet, T::Type) = Set{T}() # default empty set type
 
 function show(io::IO, s::Set)
     print(io, "Set")
@@ -64,7 +77,7 @@ rehash!(s::Set) = (rehash!(s.dict); s)
 start(s::Set)       = start(s.dict)
 done(s::Set, state) = done(s.dict, state)
 # NOTE: manually optimized to take advantage of Dict representation
-next(s::Set, i)     = (s.dict.keys[i], skip_deleted(s.dict, i+1))
+@propagate_inbounds next(s::Set, i) = (s.dict.keys[i], skip_deleted(s.dict, i+1))
 
 """
     union(s1,s2...)