This post is very much a case of me writing it down to try and get it all straight in my head, and to make sure it sticks. The other day I was reading about Swift's types and type-equality checks, and as I'd expect from plenty of other languages I've worked with, there's a way for checking that two types are the same, such that super/subclasses aren't taken into account, and a way where they are. So, given this silly code:
class Animal {}
class Cat : Animal {}
print( Cat.self == Animal.self ) // False
print( Cat.self is Animal.Type ) // True
print( type( of: Cat() ) is Animal.Type ) // True
it's made clear that == checks for strict equality and a super/subclass relationship isn't taken into account. On the other hand is does take it into account.
Only... what's with this whole .self sometimes and .Type other times business? That took a little bit of writing code and playing to get comfortable with. Here's how I understand it now (and do feel free to correct me below if I'm way off):
Given the above code, Animal.Type is the type of a value that expresses the type of Animal. On the other hand, Animal.self is a value that is the type of an Animal. Yeah, I know, that still reads oddly. But written as code:
let feline : Cat.Type = Cat.self
I think it makes a lot more sense. And having got there I felt I better understood it. I'm not 100% sure I'm 100% with it, but I'm getting there.