¿Cuál es la diferencia entre func estática y func de clase en Swift?

Puedo ver estas definiciones en la biblioteca Swift:

extension Bool : BooleanLiteralConvertible {
    static func convertFromBooleanLiteral(value: Bool) -> Bool
}

protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    class func convertFromBooleanLiteral(value: BooleanLiteralType) -> Self
}

¿Cuál es la diferencia entre una función miembro definida como static funcy otra definida como class func? ¿Es simplemente staticpara funciones estáticas de estructuras y enumeraciones, y classpara clases y protocolos? ¿Hay alguna otra diferencia que uno debería saber? ¿Cuál es la razón para tener esta distinción en la sintaxis misma?

¿Es simplemente que static es para funciones estáticas de estructuras y enumeraciones, y class para clases y protocolos?

Esa es la principal diferencia. Algunas otras diferencias son que las funciones de clase se distribuyen dinámicamente y pueden ser anuladas por subclases.

Los protocolos usan la palabra clave class, pero no excluye las estructuras de implementar el protocolo, solo usan static en su lugar. Se eligió la clase para los protocolos, por lo que no tendría que haber una tercera palabra clave para representar estática o clase.

De Chris Lattner sobre este tema:

Consideramos unificar la sintaxis (p. Ej., Usar "tipo" como palabra clave), pero en realidad no se trata simplemente de cosas. Las palabras clave "clase" y "estática" son buenas para la familiaridad y son bastante descriptivas (una vez que comprenda cómo funcionan los métodos +), y abren la puerta para agregar métodos verdaderamente estáticos a las clases. La rareza principal de este modelo es que los protocolos tienen que elegir una palabra clave (y elegimos "clase"), pero en general es la compensación correcta.

Y aquí hay un fragmento que muestra algunos de los comportamientos de anulación de las funciones de clase:

class MyClass {
    class func myFunc() {
        println("myClass")
    }
}

class MyOtherClass: MyClass {
    override class func myFunc() {
        println("myOtherClass")
    }
}

var x: MyClass = MyOtherClass()
x.dynamicType.myFunc() //myOtherClass
x = MyClass()
x.dynamicType.myFunc() //myClass

Para ser más claro, hago un ejemplo aquí,

class ClassA {
  class func func1() -> String {
    return "func1"
  }

  static func func2() -> String {
    return "func2"
  }

  /* same as above
  final class func func2() -> String {
    return "func2"
  }
  */
}

static func es igual que final class func

Como es así final, no podemos anularlo en la subclase de la siguiente manera:

class ClassB : ClassA {
  override class func func1() -> String {
    return "func1 in ClassB"
  }

  // ERROR: Class method overrides a 'final` class method
  override static func func2() -> String {
    return "func2 in ClassB"
  }
}

Hice algunos experimentos en el patio y obtuve algunas conclusiones.

TL; DR

Como puede ver, en el caso de class, el uso de class funco static funces solo una cuestión de hábito.

Ejemplo de patio de recreo con explicación:

class Dog {
    final func identity() -> String {
        return "Once a woofer, forever a woofer!"
    }

    class func talk() -> String {
        return "Woof woof!"
    }

    static func eat() -> String {
        return "Miam miam"
    }

    func sleep() -> String {
        return "Zzz"
    }
}

class Bulldog: Dog {
    // Can not override a final function
//    override final func identity() -> String {
//        return "I'm once a dog but now I'm a cat"
//    }

    // Can not override a "class func", but redeclare is ok
    func talk() -> String {
        return "I'm a bulldog, and I don't woof."
    }

    // Same as "class func"
    func eat() -> String {
        return "I'm a bulldog, and I don't eat."
    }

    // Normal function can be overridden
    override func sleep() -> String {
        return "I'm a bulldog, and I don't sleep."
    }
}

let dog = Dog()
let bullDog = Bulldog()

// FINAL FUNC
//print(Dog.identity()) // compile error
print(dog.identity()) // print "Once a woofer, forever a woofer!"
//print(Bulldog.identity()) // compile error
print(bullDog.identity()) // print "Once a woofer, forever a woofer!"

// => "final func" is just a "normal" one but prevented to be overridden nor redeclared by subclasses.


// CLASS FUNC
print(Dog.talk()) // print "Woof woof!", called directly from class
//print(dog.talk()) // compile error cause "class func" is meant to be called directly from class, not an instance.
print(Bulldog.talk()) // print "Woof woof!" cause it's called from Bulldog class, not bullDog instance.
print(bullDog.talk()) // print "I'm a bulldog, and I don't woof." cause talk() is redeclared and it's called from bullDig instance

// => "class func" is like a "static" one, must be called directly from class or subclassed, can be redeclared but NOT meant to be overridden.

// STATIC FUNC
print(Dog.eat()) // print "Miam miam"
//print(dog.eat()) // compile error cause "static func" is type method
print(Bulldog.eat()) // print "Miam miam"
print(bullDog.eat()) // print "I'm a bulldog, and I don't eat."

// NORMAL FUNC
//print(Dog.sleep()) // compile error
print(dog.sleep()) // print "Zzz"
//print(Bulldog.sleep()) // compile error
print(bullDog.sleep()) // print "I'm a bulldog, and I don't sleep."

Para declarar una propiedad de variable de tipo, marque la declaración con el staticmodificador de declaración. Las clases pueden marcar propiedades calculadas de tipo con el classmodificador de declaración en su lugar para permitir que las subclases anulen la implementación de la superclase. Las propiedades de tipo se analizan en Propiedades de tipo.

NOTA
En una declaración de clase, la palabra clave statictiene el mismo efecto que marcar la declaración con los modificadores classy finaldeclaración.

Fuente: El lenguaje de programación Swift - Propiedades de tipo variable

De acuerdo con el libro Swift 2.2 publicado por apple:

“Indicas los métodos de escritura escribiendo la staticpalabra clave antes de la palabra clave func del método. Las clases también pueden usar la classpalabra clave para permitir que las subclases anulen la implementación de la superclase de ese método ".

De Swift2.0, Apple dice:

"Siempre prefija los requisitos de propiedad de tipo con la palabra clave estática cuando los defina en un protocolo. Esta regla se aplica a pesar de que los requisitos de propiedad de tipo pueden tener como prefijo la clase o la palabra clave estática cuando se implementa por una clase:"

¡Este ejemplo aclarará todos los aspectos!

import UIKit

class Parent {
    final func finalFunc() -> String { // Final Function, cannot be redeclared.
        return "Parent Final Function."
    }

    static func staticFunc() -> String { // Static Function, can be redeclared.
        return "Parent Static Function."
    }

    func staticFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Static Function, redeclared with same name but as non-static(normal) function."
    }

    class func classFunc() -> String { // Class Function, can be redeclared.
        return "Parent Class Function."
    }

    func classFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Class Function, redeclared with same name but as non-class(normal) function."
    }

    func normalFunc() -> String { // Normal function, obviously cannot be redeclared.
        return "Parent Normal Function."
    }
}

class Child:Parent {

    // Final functions cannot be overridden.

    override func staticFunc() -> String { // This override form is of the redeclared version i.e: "func staticFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Static Function redeclared and overridden, can simply be called Child Normal Function."
    }

    override class func classFunc() -> String { // Class function, can be overidden.
        return "Child Class Function."
    }

    override func classFunc() -> String { // This override form is of the redeclared version i.e: "func classFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Class Function, redeclared and overridden, can simply be called Child Normal Function."
    }

    override func normalFunc() -> String { // Normal function, can be overridden.
        return "Child Normal Function."
    }
}

let parent = Parent()
let child = Child()

// Final
print("1. " + parent.finalFunc())   // 1. Can be called by object.
print("2. " + child.finalFunc())    // 2. Can be called by object, parent(final) function will be called.
// Parent.finalFunc()               // Cannot be called by class name directly.
// Child.finalFunc()                // Cannot be called by class name directly.

// Static
print("3. " + parent.staticFunc())  // 3. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("4. " + child.staticFunc())   // 4. Cannot be called by object, this is override form redeclared version (normal function).
print("5. " + Parent.staticFunc())  // 5. Can be called by class name directly.
print("6. " + Child.staticFunc())   // 6. Can be called by class name direcly, parent(static) function will be called.

// Class
print("7. " + parent.classFunc())   // 7. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("8. " + child.classFunc())    // 8. Cannot be called by object, this is override form redeclared version (normal function).
print("9. " + Parent.classFunc())   // 9. Can be called by class name directly.
print("10. " + Child.classFunc())   // 10. Can be called by class name direcly, child(class) function will be called.

// Normal
print("11. " + parent.normalFunc())  // 11. Can be called by object.
print("12. " + child.normalFunc())   // 12. Can be called by object, child(normal) function will be called.
// Parent.normalFunc()               // Cannot be called by class name directly.
// Child.normalFunc()                // Cannot be called by class name directly.

/*
 Notes:
 ___________________________________________________________________________
 |Types------Redeclare------Override------Call by object------Call by Class|
 |Final----------0--------------0---------------1------------------0-------|
 |Static---------1--------------0---------------0------------------1-------|
 |Class----------1--------------1---------------0------------------1-------|
 |Normal---------0--------------1---------------1------------------0-------|
 ---------------------------------------------------------------------------

 Final vs Normal function: Both are same but normal methods can be overridden.
 Static vs Class function: Both are same but class methods can be overridden.
 */

Salida:

Esto se llama métodos de tipo y se llama con sintaxis de puntos, como los métodos de instancia. Sin embargo, llama a los métodos de tipo en el tipo, no en una instancia de ese tipo. Así es como se llama a un método de tipo en una clase llamada SomeClass: