ios - type - Pase un tipo a una extensión Swift genérica, o infórmelo idealmente

public extension swift

Question

Di que tienes

 class Fancy:UIView

Usted quiere encontrar todas las vistas de Fancy hermanos. No hay problema

 for v:UIView in superview!.subviews
{
if let f = v as? Fancy
{ f.hungry = false }
}

Entonces, intente una extensión,

public extension UIView
{
internal func fancySiblings()->([Fancy])
{
return (self.superview!
.subviews
.filter { $0 != self }
.flatMap { $0 as? Fancy }
)
}
}

Impresionante, ahora puedes

 for f:Fancy in self.fancySiblings()
{ f.hungry = false }

Fantástico.

Pero,

¿Cómo generalizar esa extensión para trabajar con cualquier subtipo UIView?

Idealmente, ¿puede la extensión inferir el tipo , incluso? ¿Así como tomar un tipo?

Entonces, algo como ...

public extension UIView
{
internal func siblings<T>( something T )->([T])
{
return (self.superview!
.subviews
.filter { $0 != self }
.flatMap { $0 as? T }
)
}

y entonces podrías llamarlo algo como esto ...

 for f in self.siblings(Fancy)
for p in self.siblings(Prancy)
for b in self.siblings(UIButton)

¿Cómo puedes "decirle" a una extensión genérica el tipo de uso, así?

Parece que puedes "inferirlo al revés",

public extension UIView
{
internal func incredible<T>()->([T])
{
return (self.superview!
.subviews
.filter { $0 != self }
.flatMap { $0 as? T }
)
}
for f:Fancy in self.incredible()
for p:Prancy in self.incredible()

Lo cual es asombroso pero no funciona de otra manera.

Usted puede incluso...

 self.siblings().forEach{
(f:Fancy) in
d.hasRingOn = false
}

Así que todavía me gustaría saber cómo "pasar" un tipo como for f in self.siblings(Fancy) e, idealmente, incluso inferirlo.

Answer 1

Respuesta similar a lo que se ha dicho anteriormente, pero un poco más simplificado y sin tener que pasar nada o iterar las subvistas más de una vez:

extension UIView {
internal func siblings<T: UIView>() -> [T] {
return superview?.subviews.flatMap {return ($0 == self) ? nil : ($0 as? T) } ?? []
}
}

o mi preferencia usando opcionales:

internal func siblings<T: UIView>() -> [T]? {
return superview?.subviews.flatMap {return ($0 == self) ? nil : $0 as? T }
}

Ejemplo de uso:

class ExampleView: UIView {
func getMatchingSiblings(){
let foundSiblings: [ExampleView] = siblings()
}
//or with the for loop in the question:
for item: ExampleView in siblings() {
}
}

Cuando se trata de genéricos, simplemente necesita una instancia del tipo genérico en la firma del método. Por lo tanto, si tiene un parámetro o un tipo de retorno que usa el genérico, no necesita pasar el tipo.

Answer 2

Simplemente use el .Type :

internal func siblings<T>( something : T.Type)->([T]) {
...
}

Luego for f in self.siblings(Fancy) debería funcionar exactamente como se esperaba.

Ejemplo completo de trabajo:

class Fancy : UIView {}
public extension UIView {
internal func siblings<T>( _ : T.Type)->([T]) {
return (self.superview!
.subviews
.filter { $0 != self }
.flatMap { $0 as? T }
)
}
}
let superView = UIView()
let view = UIView()
superView.addSubview(view)
superView.addSubview(UIView())
superView.addSubview(Fancy())
print(view.siblings(Fancy))

Salidas correctamente la una vista de Fancy !

Para abordar la adición solicitada para usar opcionalmente el parámetro de tipo explícito o hacer efecto la inferencia de tipo del compilador. Puedes crear un segundo método en la misma extensión.

internal func siblings<T>()->([T]) {
return siblings(T)
}

De esa manera, al proporcionar un tipo explícito, el parámetro llama al método uno, omitiéndolo requerirá que lo hagas inferable y llamará a la segunda función, que en términos de llamada llama a la primera internamente.

O bien , puede usar la forma mucho más rápida y hacer que el argumento de tipo explícito sea opcional con el valor predeterminado nil . Eso, notablemente, forzará la inferencia en caso de omitir el argumento de tipo:

// power extension, it provides both infered or stated typing
internal func siblings<T>(_ : T.Type? = nil) -> ([T]) {
return (self.superview!
.subviews
.filter { $0 != self }
.flatMap { $0 as? T }
)
}

Eso te permitirá llamar al método a través de

for f in self.siblings(Fancy)

o incluso

for f : Fancy in self.siblings()

Ambos funcionarán mientras que solo definen una función.