Réponse.

Historique de la question :

@autoclosure est un modificateur spécial en Swift qui permet de créer automatiquement une closure à partir d'une expression passée comme argument d'une fonction. Il a été introduit pour simplifier la syntaxe et améliorer la lisibilité lors de l'écriture d'expressions assert/guard et du calcul différé des valeurs.

Problème :

Les closures standard nécessitent une syntaxe explicite ({ ... }). Cela peut souvent être excessif lorsque la logique est simple (par exemple, lors de vérifications paresseuses). Mais si vous utilisez autoclosure, il est possible de modifier le moment d'exécution du code ou de perdre la valeur d'un effet secondaire de l'expression sans que le développeur ne s'en rende compte. De plus, autoclosure n'accepte pas de paramètres.

Solution :

@autoclosure permet d'écrire de manière concise :

Exemple de code :

func logIfTrue(_ predicate: @autoclosure () -> Bool) {
    if predicate() {
        print("Condition remplie")
    }
}

// Sans autoclosure :
logIfTrue({ 2 > 1 })
// Avec autoclosure :
logIfTrue(2 > 1)

Caractéristiques clés :

@autoclosure permet de différer le calcul de l'expression jusqu'au moment de l'appel dans la fonction.
@autoclosure peut être combiné avec @escaping pour les scénarios asynchrones.
Améliore la lisibilité des interfaces en cachant la syntaxe des closures de l'utilisateur API.

Questions pièges.

L'autoclosure peut-elle accepter des paramètres ?

Non. L'autoclosure est toujours sans contexte : elle n'accepte pas de paramètres et "enveloppe" simplement l'expression.

Quelle est la différence entre les types () -> T et @autoclosure () -> T ?

Une closure normale nécessite une syntaxe explicite - l'autoclosure permet de passer une expression sans l'entourer d'accolades, ce qui a un impact significatif sur l'interface des fonctions.

Que se passe-t-il si l'autoclosure a un effet secondaire ?

L'autoclosure n'est calculée qu'à l'appel - si l'expression produit un effet secondaire, celui-ci se produira strictement au moment de l'appel, et non lors du passage du paramètre à la fonction.

var x = 5
func change(_ value: @autoclosure () -> Int) {
    print(value())
}
change(x += 1) // x ne sera incrémenté QUE ici

Erreurs courantes et anti-patterns

Mal comprendre le fait que l'expression n'est pas exécutée immédiatement (comportement paresseux)
Utiliser l'autoclosure avec des expressions ayant des effets secondaires, où une exécution immédiate est attendue
Passer une autoclosure dans un contexte d'évasion sans indiquer explicitement @escaping

Exemple de la vie réelle

Cas négatif

Lors de la mise en œuvre de l'analyse des erreurs, des messages étaient écrits via une fonction utilisant autoclosure. Mais l'expression de message avait un effet secondaire (envoyait une requête réseau), donc l'exécution réelle ne se produisait pas dans l'ordre attendu par le développeur. Cela a conduit à une collecte incorrecte des statistiques.

Avantages :

Syntaxe courte et expressive

Inconvénients :

Point d'exécution des effets secondaires non évident
Difficultés lors du débogage

Cas positif

Utilisation de l'autoclosure dans des méthodes d'assertion, où il est nécessaire de calculer l'expression uniquement au besoin ou d'alléger la syntaxe pour l'utilisateur final de l'API. Le code devient plus court, l'effet secondaire est absent.