difference between `catMaybe as? Animal` and `catMaybe as Animal?` - swift

Question

Lets say I have these:
class Animal {
}
class Cat: Animal {
var meow = "meow"
}
Now I have a variable:
var catMaybe: Cat? = /* ... */
and at some point later I do this:
var obj1 = catMaybe as Animal? // ①
and it compiles fine but I could have wrote this other code too:
var obj2 = catMaybe as? Animal // ②
only this time I get a warning. Which confuses me since I thought both were doing the same.
warning: cast from 'Cat?' to unrelated type 'Animal' always fails
var obj4 = catMaybe as? Animal
~~~~~~~~ ^ ~~~~~~
What is the real difference between ① and ②?
Edit1
I am interested in what is really happening in the background. I would go and read the assembly code to find why ② always fails but unfortunately I am not very good at it :(
In ②, since Animal is not an optional, I thought the compiler would know that catMaybe must be unwrapped first and if the operation succeed try to cast it to Animal. In any case of error it would return nil (since I am using as?) Why the compiler does not apply this logic? What stops him?
Edit2
I am using swift 1.2

Answer 1

With as? you cast an optional,let say you do a if letif let object = catMaby as? Animal{
/do some code with object
}
You are not sure if catMaby has a value.as? are for if let
Explanation
The optional form, as?, returns an optional value of the type you are trying to downcast to. The forced form, as, attempts the downcast and force-unwraps the result as a single compound action.So if you are not sure that catMaby is a Animal,put as?.There in the code checked if catMaby is Animal and checked if catMaby is an optional
So as? is for optional values,as! is the same but gives an error if you try to unwrap it

Answer 2

You get the warning since catMaybe is an optional. Optionals are of an enum type and only after you unwrap catMaybe (with either ? or !) you will get the correct object (of type Cat).
Since catMaybe is an enum (which does not inherit Animal) you get that warning.
So this should work :
var obj2 = catMaybe! as? Animal // upcast the real unwrapped value
The first version works since you keep catMaybe as an optional (an optional to an Animal object when unwrapped)

Answer 3

This is made complicated by mixing together two things – optionals, and casts. It might be clearer to ditch the optionals, look at that, and then reintroduce the optionals. Note this is all Xcode 6.3/Swift 1.2.
Here’s the simplest case:
class Animal { }
class Cat: Animal { }
let c = Cat()
let a = c as Animal // fine
The compiler knows that every Cat reference can be guaranteed convertible to Animal, so it lets you use as without complaint. If you do it the other way around though:
let a: Animal = Cat()
let c = a as Cat // compiler error
The compiler complains that as cannot be used – an Animal might not be a Cat. You must use as?, which returns an optional value – either a successfully converted Cat, or nil:
let a: Animal = Cat()
if let c = a as? Cat // c will be a Cat?
Swift also lets you use as? when the conversion is guaranteed to work:
let c = Cat()
let a = c as? Animal // a will be an Animal?
though it sometimes give you a warning that you’re using a conditional cast on something that will always succeed. But its only a warning.
That’s pretty much it for as vs as?. as for when the compiler can know for certain the cast will work, as? that returns an optional for when it might not. This doesn’t just apply to super/subclasses, it also applies to other conversions guaranteed to work, such as Swift.Array to NSArray, Sometype to Sometype?.
OK now to add in the other optional. Suppose instead you have:
let c: Cat? = Cat()
let a = c as Animal? // this is fine
So an optional Cat will convert to an optional Animal using as. This is because optionals have support for covariance – Swift looks at the contents of the optional being converted from, and the contents of the optional being converted to, and if the conversion works on the contents, it will allow the conversion.
By the way, this also works with arrays:
let c: [Cat] = [Cat()]
let a = c as [Animal]
Since Cat as Animal is allowed, so is [Cat] as [Animal].
However, casting away the optional is not allowed:
let c: Cat? = Cat()
let a = c as Animal
because you cannot discard optionality using as, just like this isn’t allowed:
let i: Int? = 1
let j = i as Int
And replacing as with as? here doesn’t help – you still can’t do the cast, so while it might compile, the result will always be nil (the compiler may warn you about this).
Finally, you can also do conditional casting inside the optional:
let c: Animal? = Cat()
let a = c as? Cat?
but beware! Now a will be of type Animal??, because the optional now contains an optional. So if you ever have to do this, you’re better off doing like so:
let c: Animal? = Cat()
let a = c.flatMap { $0 as? Cat? }
Or, you would be if this didn’t crash the compiler :-(. But the code ought to be correct.