Me resulta difícil entender el "antipatrón diferido". Creo que lo entiendo en principio, pero no he visto un ejemplo súper simple de lo que es un servicio, con una promesa diferente y una con antipatrón, así que pensé que trataría de hacer la mía, pero viendo que no súper al respecto, primero obtendría algunas aclaraciones.

Tengo lo siguiente en una fábrica (SomeFactory):

//url = 'data.json';

return {
    getData: function(){
        var deferred = $q.defer();

        $http.get(destinationFactory.url)
            .then(function (response) {

                if (typeof response.data === 'object') {
                    deferred.resolve(response.data);
                } else {
                    return deferred.reject(response.data);
                }
            })

            .catch(function (error) {
            deferred.reject(error);
        });

        return deferred.promise;
    }

La razón por la que estoy comprobando que es un objeto es solo para agregar una capa simple de validación en$http.get()

Y a continuación, en mi directiva:

this.var = SomeFactory.getData()
    .then(function(response) {
        //some variable = response;
    })
    .catch(function(response) {
        //Do error handling here
});

Ahora, para mi comprensión, este es un antipatrón. Porque la promesa diferida original capta el error y simplemente se lo traga. No devuelve el error, así que cuando se llama a este método "getData", tengo que hacer otra captura para obtener el error.

Si esto NO es un antipatrón, ¿alguien puede explicar por qué ambos requieren una especie de "devolución de llamada"? Cuando comencé a escribir esta fábrica / directiva, anticipé tener que hacer una promesa diferida en alguna parte, pero no anticipé tener que hacerlo..catch() en ambos lados (es decir, estaba pensando que podría hacer que la fábrica devolviera la respuesta o el error si hacía unSomeFactory.getData()