HL666's questions

Estou brincando com a resposta desta questão: Como testar se uma variável genérica é do tipo AnyObject

Essa solução parece não funcionar mais. Tenho este código:

public struct ObjectHashable<T>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    
    let t1 = type(of: object)
    let b1 = t1 is AnyClass
    print(t1) // Plugin
    print(b1) // false
    
    let t2 = T.self
    let b2 = t2 is AnyClass
    print(t2) // Plugin 
    print(b2) // false
    
    let t3 = Mirror(reflecting: object).subjectType 
    let b3 = t3 is AnyClass 
    print(t3) // P
    print(b3) // true 

    self.object = object
    
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return true
  }
  
  public func hash(into hasher: inout Hasher) {
  }
}

protocol Plugin: AnyObject {}
class P: Plugin {}

typealias PluginHashable = ObjectHashable<Plugin>

PluginHashable(object: P())

Esse é um comportamento surpreendente.

1.

let t1 = type(of: object)

type(of:)deveria retornar o tipo dinâmico, que é P, não Plugin. Mas obtive "Plugin" impresso.

2.

let b1 = t1 is AnyClass

Não deveria ser verdade, já que t1 é um tipo de referência? (com base na resposta aqui: Como testar se uma variável genérica é do tipo AnyObject )

3.

let t2 = T.self

Isso imprime Plugin, o que faz sentido, porque eu Plugincoloquei<>

4.

let b2 = t2 is AnyClass

Isso é falso, mas acho que deveria ser verdade pelo mesmo motivo

5.

    let t3 = Mirror(reflecting: object).subjectType // P

Isso imprime P, o que faz sentido

6.

    let b3 = t3 is AnyClass // true

Isso é verdade, o que faz sentido. Mas por que é diferente dos outros dois casos?

Eu tenho esta estrutura Swift:

struct Foo {
  let i: Int
}
let f1 = Foo(i: 1)
let f2 = Foo(i: 2)

Então no LLDB, eu os lanço __SwiftValuee imprimo:

p (f1 as AnyObject)

(__SwiftValue) 0x00000001676332d0 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

p (f2 as AnyObject)


(__SwiftValue) 0x0000000167633300 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

Como você pode ver, os endereços dos dois são diferentes, o que faz sentido, pois são dados diferentes em locais de memória separados.

Porém, se eu tomar ObjectIdentifier, eles são iguais:

p ObjectIdentifier(f1 as AnyObject)
(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

p ObjectIdentifier(f2 as AnyObject)

(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

Esse comportamento estranho basicamente diz que "ObjectIdentifier igual" não significa "endereço igual" ( ===):

p (f1 as AnyObject === f2 as AnyObject)
(Bool)  (_value = 0)

p (ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject))
(Bool)  (_value = 1)

Por que é assim? Pelo que entendi, é __SwiftValueuma subclasse de NSObject, então deveriam ter ObjectIdentifiers diferentes. Isso é estranho.

Atualizar:

Adicionei código de exemplo fora do LLDB:

      let f1 = Foo(i: 1)
      let f2 = Foo(i: 2)
      
      let b1 = (f1 as AnyObject) === (f2 as AnyObject)
      let b2 = ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject)
      

E obteve b1 = falso e b2 = verdadeiro no depurador:

Tenho um protocolo que é restrito apenas a tipos de classe:

protocol Plugin: AnyObject {}

Agora, quero usar o plugin como chave do mapa de hash. Não quero que o Pluginprotocolo se estenda de Hashable, porque teria que escrever any Pluginem todos os lugares (já que ele herdaria "Auto-Requisito" do protocolo pai).

Então, para contornar isso, quero criar um wrapper genérico. Não quero usar AnyHashable, porque quero um tipo mais restrito em caso de erros.

public struct ObjectHashable<T: AnyObject>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    self.object = object
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(object))
  }
}

Agora eu quero fazer algo como

typealias PluginHashable = ObjectHashable<Plugin>

No entanto, isso me dá erro:

requisito especificado como 'T': 'AnyObject' [com T = qualquer plugin]

Então eu mudei para

typealias PluginHashable = ObjectHashable<any Plugin>

E recebi o mesmo erro:

requisito especificado como 'T': 'AnyObject' [com T = qualquer plugin]

Pelo que entendi, embora Plugino protocolo seja limitado a ser um tipo de classe, any Pluginele não é. No entanto, não sei o que fazer a seguir.

Atualizar:

Se eu não usar o genérico for ObjectHashable, funciona:

public struct PluginHashable: Hashable {
  
  public let plugin: Plugin
  
  public init(plugin: Plugin) {
    self.plugin = plugin
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.plugin) == ObjectIdentifier(rhs.plugin)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(plugin))
  }
}

No entanto, esta solução só é utilizável para Pluginprotocolo, portanto não é ideal. Prefiro ter uma solução que funcione para todos os casos semelhantes.