Is ... OrIs

[VBAndCs]

I propose to add a new OrIs Keyword. It will help to rewrite this:

If TypeOf item Is XmlSchemaElement OrElse TypeOf item Is XmlSchemaComplexType Then

as:

If TypeOf item Is XmlSchemaElement OrIs  XmlSchemaComplexType Then

This will imply adding AndIsNot keyword to work with IsNot.

[tverweij]

My syntax would be:

If TypeOf item In {XmlSchemaElement, XmlSchemaComplexType} Then

[Happypig375]

Pattern matching is a better solution than this. #337

[zspitz]

I would prefer composable types:

If item Is XmlSchemaElement Or XmlSchemaComplexType Then

because it's something that can be used generally, and not just in the context of type-checking.

[VBAndCs]

@tverweij
Yours contains {} which annoys some VBers (me included) as more C# symbolic style, and it will be a bit difficult to parse where other {} in the scope are involved.
So, this makes mine more Vbish, more readable and easier to parse.

[zspitz]

@Happypig375 There's still a problem, even with pattern matching: how can you refer to the item in question:

Select item
    Case XmlSchemaElement, XmlSchemaComplexType
        ' What should the programmer do here?
        ' Cast item to XmlSchemaElement? to XmlSchemaComplexType? It might be the other one.
End Select

Without composable types, VB has no way of describing something that "might be either XmlSchemaElement or XmlSchemaComplexType".

[VBAndCs]

@Happypig375
I don't need casting here, at least in this stage (as in passing the object to a function).
So, no confliction.

[VBAndCs]

If item Is XmlSchemaElement Or XmlSchemaComplexType Then

Or already has two functions (logical and bitwise), and adding a third one will complicate things if the three ORs appeared in the same context, which will need some {} and more complication and less readability.

[tverweij]

I compare this proposal to string handling:

If aString = "abc" orelse aString = "bcd" Then

I normally write this as:

If {"abc", "bcd"}.Contains(aString) Then

But it could also be written as:

Select aString
    Case "abc", "def"

Composable types require some magic Boolean operations as far as I can see.
The OrIs solution has no other comparable VB Syntax (as far as I know)

[Padanian]

If {"abc", "bcd"}.Contains(aString) Then

This is an abomination and wrong, if for some reason aString = "ab".
Subsets and equality don't match

[tverweij]

Explain I am willing to learn.
(Ps: I learned this trick from Lucian)

[AdamSpeight2008]

There is a prototype of #481 TypeOf expr Is (Of T0 ..., Tn), in the pull requests.

[zspitz]

@VBAndCs

Or already has two functions (logical and bitwise)

Using Or for composing types would have a similar meaning to its current usage as a bitwise operator.

[AdamSpeight2008]

@zspitz I also implemented a version that used operators like TypeOf expr Is T0 Or T1, but it involved change a lot more code that then TypeOf expr Is (Of T0 ..., Tn)

Note: T0 ... , Tn are just representing placeholders for a type, don't think that is just restricted to generic types. Itsn't.

[tverweij]

but it involved change a lot more code that then TypeOf expr Is (Of T0 ..., Tn)

I like this solution.

[VBAndCs]

Is (Of) is OK. It doesn't need new keywords, but have more symbols than using OrIs, which will be more readable when splitting long lines.
So, I like both evevn.