¿Cómo se hace un cierre opcional en Swift?

Estoy tratando de declarar un argumento en Swift que tiene un cierre opcional. La función que he declarado se ve así:

class Promise {

 func then(onFulfilled: ()->(), onReject: ()->()?){       
    if let callableRjector = onReject {
      // do stuff! 
    }
 }

}

Pero Swift se queja de que "el valor enlazado en un condicional debe ser un tipo opcional" donde se declara el "if let".

Debe incluir el cierre opcional entre paréntesis. Esto analizará adecuadamente al ?operador.

func then(onFulfilled: ()->(), onReject: (()->())?){       
    if let callableRjector = onReject {
      // do stuff! 
    }
 }

Para hacer el código aún más corto, podemos usar nilcomo valor predeterminado para el onRejectparámetro y el encadenamiento opcional ?()al llamarlo:

func then(onFulfilled: ()->(), onReject: (()->())? = nil) {
  onReject?()
}

De esta forma podemos omitir el onRejectparámetro cuando llamamos a la thenfunción.

then({ /* on fulfilled */ })

También podemos usar la sintaxis de cierre final para pasar el onRejectparámetro a la thenfunción:

then({ /* on fulfilled */ }) {
  // ... on reject
}

Aquí hay una publicación de blog al respecto.

Dado que supongo que este cierre "opcional" simplemente no debería hacer nada, podría usar un parámetro con un cierre vacío como valor predeterminado:

func then(onFulfilled: ()->(), onReject: ()->() = {}){       
    // now you can call your closures
    onFulfilled()
    onReject()
}

esta función ahora se puede llamar con o sin la onRejectdevolución de llamada

then({ ... })
then({ ... }, onReject: { ... })

¡No es necesario que Swift sea increíble Optionals?aquí!

Quizás sea una forma más limpia. Especialmente cuando el cierre tiene parámetros complicados.

typealias SimpleCallBack = () -> ()

class Promise {

func then(onFulfilled: SimpleCallBack, onReject: SimpleCallBack?){       
    if let callableRjector = onReject {
        // do stuff! 
    }
}

}