Variables de función estática en Swift

Estoy tratando de averiguar cómo declarar una variable estática con alcance solo localmente a una función en Swift.

En C, esto podría verse así:

int foo() {
    static int timesCalled = 0;
    ++timesCalled;
    return timesCalled;
}

En Objective-C, es básicamente lo mismo:

- (NSInteger)foo {
    static NSInteger timesCalled = 0;
    ++timesCalled;
    return timesCalled;
}

Pero parece que no puedo hacer nada como esto en Swift. Intenté declarar la variable de las siguientes maneras:

static var timesCalledA = 0
var static timesCalledB = 0
var timesCalledC: static Int = 0
var timesCalledD: Int static = 0

Pero todos estos resultan en errores.

• El primero se queja "Las propiedades estáticas solo se pueden declarar en un tipo".
• El segundo se queja "Declaración esperada" (donde staticestá) y "Patrón esperado" (donde timesCalledBestá)
• El tercero se queja "Las declaraciones consecutivas en una línea deben estar separadas por ';'" (en el espacio entre los dos puntos y static) y "Tipo esperado" (donde staticestá)
• El cuarto se queja "Las declaraciones consecutivas en una línea deben estar separadas por ';'" (en el espacio entre Inty static) y "Declaración esperada" (bajo el signo igual)

No creo que Swift admita una variable estática sin tenerla adjunta a una clase / estructura. Intente declarar una estructura privada con variable estática.

func foo() -> Int {
    struct Holder {
        static var timesCalled = 0
    }
    Holder.timesCalled += 1
    return Holder.timesCalled
}

  7> foo()
$R0: Int = 1
  8> foo()
$R1: Int = 2
  9> foo()
$R2: Int = 3

Otra solución

func makeIncrementerClosure() -> () -> Int {
    var timesCalled = 0
    func incrementer() -> Int {
        timesCalled += 1
        return timesCalled
    }
    return incrementer
}

let foo = makeIncrementerClosure()
foo()  // returns 1
foo()  // returns 2

Swift 1.2 con Xcode 6.3 ahora admite estática como se esperaba. De las notas de la versión beta de Xcode 6.3:

Los métodos y propiedades "estáticos" ahora están permitidos en las clases (como un alias para "clase final"). Ahora puede declarar propiedades almacenadas estáticas en clases, que tienen almacenamiento global y se inicializan lentamente en el primer acceso (como variables globales). Los protocolos ahora declaran los requisitos de tipo como requisitos "estáticos" en lugar de declararlos como requisitos de "clase". (17198298)

Parece que las funciones no pueden contener declaraciones estáticas (como se hace en la pregunta). En cambio, la declaración debe realizarse a nivel de clase.

Ejemplo simple que muestra una propiedad estática incrementada dentro de una función de clase (también conocida como estática), aunque no se requiere una función de clase:

class StaticThing
{
    static var timesCalled = 0

    class func doSomething()
    {
        timesCalled++

        println(timesCalled)
    }
}

StaticThing.doSomething()
StaticThing.doSomething()
StaticThing.doSomething()

Salida:

1
2
3

Otra solución

class Myclass {
    static var timesCalled = 0
    func foo() -> Int {
        Myclass.timesCalled += 1
        return Myclass.timesCalled
    }
}