Enumerable#include? should receive any object

[HoneyryderChuck]

this checks only if an object exists in the collection, regardless of type. ruby does not raise an exception if the types don't match.

[soutaro]

This behavior is intentional. The goal is to detect more type errors arising from a commonly seen pattern like this:

hash = { foo: :bar } #: Hash[Symbol, Symbol]
hash["foo"]          # This is usually a mistake.

I'm open to discuss this issue here to have some conclusion. Do you have any practical examples or real-world scenarios where the proposed one worked better?

(From a type-theoretic perspective, the current implementation (using T) is inconsistent. Having top/untyped is better -- consistent and sound.)

[sampersand]

It'd be nice if we could have a signature like:

def []: (K) ->V?
      | (untyped) -> nil

And then that way whenever you use x = hash["foo"] or fail; x + 1 you might get an error because x would be bot

[ParadoxV5]

Oh, we do. I opened #1875 a year and a half ago, and that was suggested even before that.

[HoneyryderChuck]

@soutaro any place where you don't control where the argument comes from. I caught this while checking one of the many steep errors i still get on the httpx codename.

Fwiw there are other methods where I'd apply the same reasoning, like Hash#key?, and while I'd expect enforcing typing while make some code a bit more convoluted, I don't see the upside in this case.

[soutaro]

@sampersand

def []: (K) ->V?
      | (untyped) -> nil

This doesn't work well in static typing. Having top always returns nil, for example.

hash = { foo: 123 }
key = :foo #: top
hash[key]       # => nil

[ParadoxV5]

@sampersand meant this, @soutaro.

def []: ((K) -> V) & ((untyped) -> nil)

[soutaro]

@HoneyryderChuck

any place where you don't control where the argument comes from.

Like receiving network request or loading from files? I was assuming those values have untyped usually.
If you can share any part from httpx codebase, it should really help.

[HoneyryderChuck]

@soutaro I'm having a hard time finding the example that motivated me to open this PR. Most of the examples I find in the codebase are of values which are extracted from arrays/strings/via-regexps which may be smth or nil, and due to the "or nil", don't pass the check. One could argue that I could "skip if nil" before doing the include? call, but that results in rather tedious checks, specially if the include? calls are in the middle of if expressions.

Neverthesless, I'll leave you with this use case, that you may consider more "real world":

# @rbs
      SEMAPHORE_LIGHTS: Array[:red | :yellow | :green]

SEMAPHORE_LIGHTS = %i[red yellow green]
SEMAPHORE_LIGHTS.include?(:blue)

Output

Cannot pass a value of type `::Symbol` as an argument of type `(:red | :yellow | :green)`
  ::Symbol <: (:red | :yellow | :green)
    ::Symbol <: :red[Ruby::ArgumentTypeMismatch](https://github.com/soutaro/steep/tree/v1.10.0/manual/ruby-diagnostics.md#Ruby::ArgumentTypeMismatch)

I can't find of a sane way of skipping that.