Swift泛型：类型声明中的位置

Question

I'm trying to make an API that allows a caller to pass a subclass of UIView and a block to a function, and later the receiver will call that block with the given UIView subclass instance and another argument. I've broken down the issue so that it runs in a playground:

import UIKit

struct SomeStruct<T where T: UIView> {

    let view: T
    let block: ((T, Int) -> Void)

    //some computed variables here that rely on T being a UIView
}

class SomeClass {

    var data: SomeStruct<UIView>? //Ideally, SomeStruct<? where ? : UIView>

    func doSomethingLater<V where V: UIView>(view: V, block: ((V, Int) -> Void)) {

        //Cannot convert value of type '(V, Int) -> Void' to expected argument type '(_, Int) -> Void'
        self.data = SomeStruct(view: view, block: block)
    }
}

The caller would then use SomeClass like this:

let c = SomeClass()

let label = UILabel()
c.doSomethingLater(b) { (label, idx) in
    //l is type UILabel
}   

let button = UIButton(type: .Custom)
c.doSomethingLater(b) { (button, idx) in
    //b is type UIButton
} 

My reasoning behind wanting to restrict to subclasses of UIView rather than a UIView itself is so that from within the block, the caller does not need to cast the argument to it's original type

So, my question is: is there a way to use the where clause when declaring a variable's type?

Answer 1

I can see multiple ways of achieving this. Which one to use is up to you, depending how you want your code to be organized.

1. Make SomeClass itself generic:

    class SomeClass<V: UIView> { var data: SomeStruct<V>? ... } 

2. Make SomeStruct conform to a protocol (with no associated type) which exposes only a UIView, so you can still write the computed properties:

    protocol SomeStructType { var view: UIView { get } } extension SomeStructType { // add computed properties based on self.view... } struct ConcreteStruct<V: UIView>: SomeStructType { let realView: V let block: (T, Int) -> Void var view: UIView { return realView } // satisfy the protocol } class SomeClass { var data: SomeStructType? ... func doSomethingLater<V: UIView>(view: V, block: (V, Int) -> Void) { data = ConcreteStruct(realView: view, block: block) } } 

3. Rather than a struct, use a generic subclass of a non-generic class (this is very similar to #2)

    class SomeData { var view: UIView { fatalError("abstract method") } ... } class ConcreteData<V: UIView>: SomeData { let realView: V let block: (V, Int) -> Void override var view: UIView { return realView } // override the getter init(view: V, block: (V, Int) -> Void) { ... } } class SomeClass { var data: SomeData? ... func doSomethingLater<V: UIView>(view: V, block: (V, Int) -> Void) { data = ConcreteData(realView: view, block: block) } } 

Answer 2

you don't need SomeClass at all

struct S<T> {
    let a: T
    let b: (T, Int) -> Void
}

let s = S(a: "a") { (i, j) in
    // see, that a is NOT accessible here!!!!
    print("1:",i,j)
}

s.b("b", 1) // compiler take care about types, so (String,Int) is the only option

// to be able change b later !!!!!
struct S1<T> {
    let a: T
    var b: (T, Int) -> Void
}

var s1 = S1(a: 100) { _ in }
s1.b = { label, index in
    print("2:",s1, label, index)
}

s1.b(200,2)

class C {
    var i: Int = 0
}
let c:C? = C()
var s2 = S1(a: c) { _ in } // so later i can modify c
s2.b = { label, index in
    s2.a?.i = index
}
print("3:",c, c?.i)
s2.b(nil, 100)
print("4:",c, c?.i)

it prints

 1: b 1
 2: S1<Int>(a: 100, b: (Function)) 200 2
 3: Optional(C) Optional(0)
 4: Optional(C) Optional(100)

or

let c2 = C()
c2.i = 200

// modify c.i to max of c2.i and some value
s2.b = { c, i in
    if let j = c?.i {
        s2.a?.i = max(j,i)
    }
}

s2.b(c2, 50) // s2 still modify c
print("5:",c, c?.i)

s2.b(c2, 250) // s2 still modify c
print("6:",c, c?.i)

prints

5: Optional(C) Optional(200)
6: Optional(C) Optional(250)