Cuéntame sobre el mecanismo de optimización de copia…

El mecanismo de optimización de copia en iOS y macOS, a menudo asociado con el uso de la estructura Copy-on-Write (CoW) o la semántica de valor, permite evitar copias innecesarias de datos al pasar estructuras o clases con semántica de valor, como matrices, diccionarios, cadenas e incluso estructuras propias, si implementan el protocolo Equatable y Hashable (no estrictamente, pero en casos típicos).

La esencia de CoW:

Al crear una copia de una estructura (por ejemplo, asignar una variable a otra, pasar por valor a una función), no se realiza una copia real de los datos. Ambas variables apuntan a los mismos datos en memoria. El contador de referencias a los datos aumenta.
La copia se aplaza hasta que una de las copias intente modificar los datos.
Solo en el momento de la modificación, los datos se copian realmente, y la modificación se realiza en la nueva copia. La copia original sigue apuntando a los datos iniciales (si aún tiene al menos un propietario).

Ventajas:

Reducción de costos en operaciones de copia, especialmente para grandes volúmenes de datos (matrices, cadenas).
Disminución del uso de memoria, ya que varias entidades pueden compartir los mismos datos.
Mejora del rendimiento al pasar estructuras con semántica de valor.

Ejemplos donde CoW se usa activamente:

NSArray, NSDictionary, NSString: En Objective-C, estas clases usan CoW para optimización.
Array, Dictionary, String en Swift: Estos tipos básicos en Swift tienen semántica de valor y usan CoW.

var array1 = [1, 2, 3]
var array2 = array1 // No hay copia de datos, ambas variables apuntan a los mismos datos

array2.append(4) // Se realiza una copia real de los datos para array2, luego append
// Ahora array1 = [1, 2, 3] y array2 = [1, 2, 3, 4]

Desventajas:

Pequeños costos adicionales en la comprobación de la necesidad de copia en cada modificación.
Posibilidad de copias ocultas, que pueden afectar el rendimiento en lugares inesperados.

Es importante recordar que CoW funciona eficientemente para estructuras con semántica de valor (struct, enum). Las clases tienen semántica de referencia, y al asignar o pasar una instancia de clase, solo se copia la referencia, no los datos del objeto.

En Swift, la mayoría de las colecciones integradas y cadenas trabajan con semántica de valor y usan CoW internamente. Al crear estructuras propias que contienen tipos de referencia (por ejemplo, clases), CoW se aplicará a la estructura misma, pero no a su contenido de tipo de referencia. Modificar una propiedad de tipo de referencia dentro de una estructura no activará CoW para toda la estructura, pero puede requerir CoW para el tipo de referencia si lo soporta.

Para implementar manualmente CoW en tipos de datos propios en Swift, se puede usar una combinación de un tipo de referencia para almacenar datos (por ejemplo, una clase con una estructura interna) y verificar la unicidad de la referencia antes de modificar (por ejemplo, isKnownUniquelyReferenced).

class Container<T> {
    var value: T

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

struct CustomStruct {
    private var _container: Container<[Int]>

    var data: [Int] {
        get { return _container.value }
        set {
            // Verifica si el contenedor es referenciado de forma única
            // Si no, crea una copia del contenedor y los datos
            if !isKnownUniquelyReferenced(&_container) {
                _container = Container(newValue)
            } else {
                // Si sí, modifica los datos directamente en el contenedor actual
                _container.value = newValue
            }
        }
    }

    init(data: [Int]) {
        _container = Container(data)
    }
}

var s1 = CustomStruct(data: [1, 2, 3])
var s2 = s1 // CoW: _container en s1 y s2 apuntan al mismo contenedor

s2.data.append(4) // Se llama al setter de data.
                   // isKnownUniquelyReferenced para _container en s2 será false (porque s1 también lo referencia).
                   // Se crea un nuevo Container con copia de [1, 2, 3, 4], ahora s2._container apunta a él.
                   // s1._container todavía apunta al antiguo Container con [1, 2, 3].

print(s1.data) // Salida: [1, 2, 3]
print(s2.data) // Salida: [1, 2, 3, 4]

Cuéntame sobre el mecanismo de optimización de copia en iOS.