CODEWITHSUNDEEP
swift
fabian789
fabian789

Reputation: 8412

Can I specify that a class instance can be converted to some type?

Say I have a generic class

class Foo<T> { … }

Can I somehow specify that instances of this class can be converted to T in assignments? Example:

let foo = Foo<Int>()
func useAnInt(a: Int) {}

let getTheInt: Int = foo
useAnInt(foo)

Upvotes: 1

Views: 46

Answers (3)

Kametrixom
Kametrixom

Reputation: 14973

Why not just use the underlying type? (Similar to @MrBeardsley's answer)

class Foo<T> {
    var t : T

    init(t: T) {
        self.t = t
    }
}


let foo = Foo(t: 3)
func useAnInt(a: Int) {}

let getTheInt: Int = foo.t
useAnInt(foo.t)

Upvotes: 1

hennes
hennes

Reputation: 9342

One way of achieving what you want is to use a dedicated protocol for each of the target types that your class shall be convertible to. Here is very basic example:

protocol BoolAdaptable {
    func adaptToBool() -> Bool
}

protocol IntAdaptable {
    func adaptToInt() -> Int
}

protocol FloatAdaptable {
    func adaptToFloat() -> Float
}

class Foo: BoolAdaptable, IntAdaptable, FloatAdaptable {

    var v: NSNumber

    init(_ v: NSNumber) {
        self.v = v
    }

    func adaptToBool() -> Bool {
        return v.boolValue
    }

    func adaptToInt() -> Int {
        return v.integerValue
    }

    func adaptToFloat() -> Float {
        return v.floatValue
    }

}

let foo = Foo(NSNumber(double: 1.23))

let getTheBool = foo.adaptToBool() // true
let getTheInt = foo.adaptToInt() // 1
let getTheFloat = foo.adaptToFloat() // 1.23

This could easily be extended to support more complex conversions.

Upvotes: 1

Mr Beardsley
Mr Beardsley

Reputation: 3863

You are not able to do what you are asking. Even though Foo defines a generic type T, instances of Foo are still Foo and cannot be converted to the generic type. The reason you would declare a generic type at the class level is to use it multiple places throughout the class.

class Foo<T> {
    var value: T

    init(withValue: T) {
       self.value = withValue
    }

    func getSomeValue() -> T {
        return self.value
    }
}

Generics don't mean the class itself is generic and can be converted.

Upvotes: 1

Related Questions