Type casting in Swift 3

Question

I want to check whether a generic type conforms to a protocol. If it is, I need to cast the type itself and call a static method against it.

func log<T>(object: T) {
    if let C = T as? Loggable {    // this line doesn't compile
        print("\(C.description(of: object))")
    } else {
        print("\(object)")
    }
}

Anybody knows if it's doable?

UPDATE

I confused you with my first code snippet. Hopefully, second makes more sense. I've made some changes thanks to the @portella's answer, but it's still not enough.

func decodeObject<T>() -> T? {
    guard let object = objects.first else {
        return nil
    }
    objects.removeFirst()

    if object is NSNull {
        return nil
    }

    if T.self is Coding.Type {    // the condition is fixed, thanks to @Hiron
        if let data = object as? Data {
            return type(of: (T.self as! Coding)).from(data: data) as? T
        } else {
            return nil
        }
    }

    return object as? T
}

Why not just have two overloads of `log`? One for `Loggable` `T`, one for any `T`. — Hamish, Dec 27 '16 at 00:01
@Hamish this might be an option. I'll implement it this way if don't find an answer. Thanks — Artem Stepanenko, Dec 27 '16 at 00:02
I assume that somehow [this answer](http://stackoverflow.com/questions/41236021/how-do-i-check-if-an-object-is-a-collection-swift/41237381#41237381) should be useful to what are you trying to do. — Ahmad F, Dec 27 '16 at 00:11

portella · Answer 1 · 2016-12-27T10:01:03.030

Does this fit your needs:

protocol Loggable {
    func log()
    static func staticLog()
}

func log<L: Loggable>(object: L) {
    object.log()
    L.staticLog()
}

You ensure that all the objects sent into the function conforms to the protocol Loggable

For me, i don't like this, but hope the following solution can help (i strongly recommend the first one):

protocol Loggable {
    func log()
    static func staticLog()
}

func log<L>(object: L) {
    guard let loggableObject = object as? Loggable else {
        print(" Not a loggable object")

        return
    }

    loggableObject.log()
    type(of: loggableObject).staticLog()
}


final class NotLoggableClass {}

final class LoggableClass: Loggable {
    func log() {
        print("")
    }

    static func staticLog() {
        print("")
    }
}

log(object: NotLoggableClass())

log(object: LoggableClass())

The call log(object: NotLoggableClass()) will return: Not a loggable object

The call log(object: LoggableClass()) will return:

EDIT: regarding the update, do you want to check the argument type or the argument type? You are not sending any argument into your function, which seems odd. I think you would like to validate it, not the return, i guess. Is this what you are trying to achieve:

protocol Coding {
    associatedtype T

    static func decodeObject<T>(data: Data) -> T?
}

extension UIImage: Coding {
    typealias T = UIImage

    static func decodeObject<T>(data: Data) -> T? {
        return UIImage(data: data) as? T
    }
}

Regarding your solution, i don't understand the objects or where that came from. If you want the generic type to conform with the Coding protocol you can make that with a constraint in the function declaration.

Example:

protocol Coding {
    associatedtype T

    static func from(data: Data) -> T?
}

func decodeObject<T: Coding>(_ objects: [Data]) -> T? {
    guard let object = objects.first else {
        return nil
    }

    var objects = objects
    objects.removeFirst()

    return T.from(data: object) as? T
}

extension String: Coding {
    static func from(data: Data) -> String? {
        return String(data: data, encoding: .utf8)
    }
}

Although, i don't understand the objects, this should be something to be done by the type itself, not by a common helper or something, which seems to me what you are trying.

Try to avoid dynamic cast and type with Swift

Hope that helps

Thanks. I agree with all the points you mentioned. Anyway, could you please check the updated question? — Artem Stepanenko, Dec 27 '16 at 00:54

score 1 · Answer 2 · answered Dec 27 '16 at 02:58

1

Maybe you should write

if T.self is Coding.Type

instead of

if T.self is Coding

answered Dec 27 '16 at 02:58

Hiron

1,457
1
13
12

score 0 · Accepted Answer · answered Dec 29 '16 at 09:43

Let's say you have a protocol with a static method and a class which implements it:

protocol Something {
    static func doSomething()
}

class SomethingConcrete: Something {
    static func doSomething() {
        // does something concrete
    }
}

Also there's a generic function. If it gets the type Something it calls it's static method (there's no object involved).

There's two ways of doing this: overloading and casting.

Overloading (a credit to @portella)

func someFunction<T: Something>() {
    T.doSomething()
}

func someFunction<T>() {
    // does something else
}

Casting (uses a type check mentioned by @Hiron)

func someFunction<T>() {
    if T.self is Something.Type {
        (T.self as! Something.Type).doSomething()
    } else {
        // does something else
    }
}

Type casting in Swift 3

3 Answers3