Swift 中函数的 type casting

class A {}
class B: A {}

func a2b(_ a: A) -> B { return B() }
func a2a(_ a: A) -> A { return A() }
func b2a(_ b: B) -> A { return A() }
func b2b(_ b: B) -> B { return B() }



var general2general: (A) -> A = a2b
var general2specific: (A) -> B = a2b
var specific2general: (B) -> A = a2b
var specific2specific: (B) -> B = a2b

a2b is (A) -> A // false
a2b is (A) -> B // true
a2b is (B) -> A // false
a2b is (B) -> B // false

general2general is (A) -> B // false
general2specific is (A) -> B // true
specific2general is (A) -> B // false
specific2specific is (A) -> B // false



general2general = a2a
// general2specific = a2a // error: cannot assign value of type '(A) -> A' to type '(A) -> B'
specific2general = a2a
// specific2specific = a2a // error: cannot assign value of type '(A) -> A' to type '(B) -> B'

a2a is (A) -> A // true
a2a is (A) -> B // false
a2a is (B) -> A // false
a2a is (B) -> B // false

general2general is (A) -> A // true
specific2general is (A) -> A // false



// general2general = b2a // error
// general2specific = b2a // error
specific2general = b2a
// specific2specific = b2a // error

b2a is (A) -> A // false
b2a is (A) -> B // false
b2a is (B) -> A // true
b2a is (B) -> B // false

specific2general is (B) -> A // true



// general2general = b2b // error
// general2specific = b2b // error
specific2general = b2b
specific2specific = b2b

b2b is (A) -> A // false
b2b is (A) -> B // false
b2b is (B) -> A // false
b2b is (B) -> B // true

specific2general is (B) -> B // false
specific2specific is (B) -> B // true

class A {}
class B: A {}

let b = B()
let a: A = b
b is A // true
a is B // true

a as? B // 返回非 nil 的值