Iteration over a symbol does not work

[dpsanders]

julia> setdiff([1,2], 1)
1-element Array{Int64,1}:
 2

but with symbols it doesn't work:

julia> setdiff([:a, :b], :a)
--------------------------------------------------------------------------------
MethodError                                   Stacktrace (most recent call last)
[#2] — setdiff(::Array{Symbol,1}, ::Symbol)
       ⌙ at array.jl:1466

[#1] — union!(::Set{Any}, ::Symbol)
       ⌙ at set.jl:63

MethodError: no method matching start(::Symbol)
Closest candidates are:
  start(::SimpleVector) at essentials.jl:170
  start(::Base.MethodList) at reflection.jl:258
  start(::IntSet) at intset.jl:184

As per the error message, this is apparently because

julia> start(1)
false

julia> start(:a)
MethodError: no method matching start(::Symbol)
Closest candidates are:
  start(::SimpleVector) at essentials.jl:170
  start(::Base.MethodList) at reflection.jl:258
  start(::IntSet) at intset.jl:184

Is there a rationale for this? Or can we add iteration to symbols?

Alternatively, is there a way to ensure something is an array for setdiff to work?
I guess using [v;], but this feels hacky.

[yuyichao]

I think the issue here is actually, why is number iterable. The usage here can't be expanded to other types anyway, e.g. for strings.

[yuyichao]

So I think this is a dup (well, opposite) of #7903

[dpsanders]

Yes, I see.

So maybe for my actual use case, the solution is to just add a method to setdiff that accepts a non-array as its second argument that does not need to be iterated over. Maybe this requires an Iterable trait, though.

[yuyichao]

I think that's not really a setdiff (if the second argument is not a set and we want to move away from implicitly treating scalar as single element set).

The case that makes this much more complicated is,

julia> setdiff(['a', 'b'], "a")
1-element Array{Char,1}:
 'b'

julia> setdiff(["a", "b"], "a")
2-element Array{Any,1}:
 "a"
 "b"

[eschnett]

@dpsanders That doesn't work because the elements of the set might be iterable as well. (And the element type might be Any.) If you want to avoid having to explicitly create a one-element tuple, we'll need to introduce a new function.

[TotalVerb]

@eschnett If we do that, we should call the new function delete. It parallels with delete! in the same way sort does with sort!. Also, "S delete x" is common in mathematics to denote "S ∖ {x}".

[TotalVerb]

However, for consistency with delete!, delete would have to be strict instead of idempotent, so it would not be identical to setdiff.

[dpsanders]

Closing as non-actionable.