Swift 2：了解AnyObject和Self

Question

I couldn't find any good explanation to my questions so I'd like to ask you directly. First of all I'd like to refine my code in this post .

My problem is the protocol AnyObject and the Self type. I didn't implement AnyObject into my code because it is marked with @objc and I don't want any Objective-C stuff involved in my code (don't judge me for that). I also couldn't find any explanation about the Self type. It just worked as expected, but Xcode does not replace Self with the type the static function is called at.

Here is some example:

extension Int : Instance {}

Int.singleton { (customInstanceName) -> Self in 0 } // Self shall be replaced with Int

As you can see Xcode produces a Self instead an Int. Is there any chance I could fix this? Am I right that Self does return the dynamicType and my implementation is fine as it is in my post above? I would really appreciate any good explanation about the Self type.

As you have seen in my code. I am using a custom protocol to check whether my instance is a class or not. Is there any other shiny implementation to check my instances if they are classes or structure types, or am I forced to use AnyObject if I want to get rid of my ClassInstance protocol?

Thank you for your time.

UPDATE:

protocol Test {}

class A : Test {}

struct B : Test {}

let aClass : Test = A()
let aStruct : Test = B()

if let someClass = aClass as? AnyObject {
    print(someClass) // only this will print
}

if let someStruct = aStruct as? AnyObject {
    print(someStruct)
}

This will work, but AnyObject is still marked as an @objc protocol.

Answer 1

The Self type can be only used in protocols where it is a implicit typealias of the type which conforms to it:

protocol Testable {
    func test() -> Self
}

If you want to conform to this protocol you than have to replace Self with the name of the type. For instance:

struct Product: Testable {
    func test() -> Product {
        return Product()
    }
}

Important Edit:

As DevAndArtist pointed out in the comments there is a working class check in Swift 1.2 (without automatic bridging to Objective C) but not Swift 2 (Xcode 7 beta 3; probably a bug):

if instance.dynamicType is AnyClass {
    // instance is a class
} else {
    // instance is not a class
}

You can see workaround (mainly) for Swift 2 below.

End Edit

With respect to classes you should use AnyObject if you want to keep it simple but you can also use reflection which would be much more effort.

Below you can see some reflection results of string interpolations (only the first few characters):

"\(reflect(classType))"                  // Swift._ClassMirror
"\(reflect(0))"                          // Swift._LeafMirror
"\(reflect(enumType))"                   // Swift._EnumMirror
"\(reflect(structure))"                  // Swift._StructMirror
"\(reflect([0, 4]))"                     // Swift._ArrayTypeMirror
"\(reflect(NSDate()))"                   // Foundation._NSDateMirror
"\(reflect(NSURLRelationship.Contains))" // Swift._EnumMirror
"\(reflect(Int?(2)))"                    // Swift._OptionalMirror

As you can see enums are consistent if they are not defined in the Swift standard library (unfortunately also Optional...). So you can distinguish also structs and enums:

public enum Type {
    case Enum, Class, Struct
}

public func getType<T>(anything: T) -> Type {
    if anything is AnyObject {
        return .Class
    }
    if "\(reflect(anything))".hasPrefix("Swift._EnumMirror") {
        return .Enum
    }
    return .Struct
}

So for a better result you have to put some effort into it to differentiate between all the different cases.

But the easiest way to distinguish only between reference types and value types (aka classes and structs/enums) is still (unfortunately only works for own declared structs and not built in types because they can be bridged to Objective C; I'm working on it...):

if instance is AnyObject {}

// or: if instance is of type Any
if let classInstance = instance as? AnyObject {}