!in

[bearophile]

Michel Fortin:

>You're suggesting that 'in' for arrays could search not only for elements but also for subarrays?<

I have suggested this probably two years ago or more. The main difference compared the Python situation is that D is statically typed, so the compiler can tell apart the case of searching of a single item from the case of searching a subsequence.

A similar case: in Python lists have the .append() and .extend() methods because Python is dynamically typed, so it can't tell apart the two cases. But the static type system of D allows you to just use ~= for both cases.


> The interesting part is that the syntax is very natural. The less 
> interesting part is that it's slower and slightly different from 'in' 
> in associative arrays. I'm on the fence.

I am for it, because the operation is the same, "in" is used to search inside a collection, then the collection uses the faster method it has to answer.
But D2 is now finalized, so this feature might need to wait after the phase of debugging and improvement of D2.

--------------

Andrei Alexandrescu:

>Generally I'd be hesitant to make it all too easy to do linear searches. Too much of that would encourage people to stick with linear searches because it's the path of least resistance.<

D programmers know the difference between linear search, hash search and search in an ordered search tree. They are O(n), O(1), and O(ln n). Do you want to use a different name for each of those searches (and maybe a (n log log n if you search with interpolated search, etc) just because their computational complexity is different, or do you want just a syntax that asks the collection to find something using the faster code it has?

Even in my Python programs I am well aware of the performance difference between a linear search in a list and an hash search in a set. If I know I will need to perform a search operation often, on in an important loop, I will use a set, otherwise using a list (that is an array) is often good enough. The syntax to search is the same so you can swap data structure in a moment, eventually.


>Searching a value in a literal should actually be allowed: x in [10, 20, 30, 0]<

This is very wrong. No special cases, please. If you don't want to support the linear search on all arrays, then please don't add this feature at all, I will keep using my isIn templated function (that digests AAs too, lazy iterables, etc too of course). I don't want more warts and special cases in D, thank you. As Python Zen says: "Special cases aren't special enough to break the rules." Such rules must be read and understood by D devs too, if you want to make a language that's not a mess as C++.

Bye,
bearophile