es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo crear un editor personalizado de futuros aplazados en Swift Combine?

15 Jul, 2023 Programación

Como dice el título, me gustaría crear un editor personalizado que funcione básicamente como un future aplazado. Normalmente, cuando quiero encapsular código en un Future, pero quiero que se ejecute al suscribirse, tendría que escribir algo como esto:

Deffered {
Future { promise in
}
}

Ahora estaba pensando en crear un editor personalizado, algo así como DefferedFuture, que tenga exactamente la misma funcionalidad que Future, pero que solo ejecute la promesa al suscribirse.

Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para crear un publicador personalizado que funcione como un futuro aplazado, puedes empezar por definir una estructura para tu publicador y hacerla conforme al protocolo Publisher. Dentro de esta estructura, puedes crear una Subscription que gestionará la lógica para tu futuro aplazado.

    Aquí tienes un ejemplo de cómo podría verse tu publicador DefferedFuture:

    struct DefferedFuture<output, failure:="" error="">: Publisher {
    typealias Promise = (Result<output, failure="">) -> Void

    let promise: (AnySubscriber<output, failure="">) -> Promise

    func receive<s>(subscriber: S) where S : Subscriber, Failure == S.Failure, Output == S.Input {
        let subscription = DefferedFutureSubscription(subscriber: AnySubscriber(subscriber))
        subscription.promise = promise(subscription)
        subscriber.receive(subscription: subscription)
    }

    class DefferedFutureSubscription: Subscription {
        private var subscriber: AnySubscriber<output, failure="">?
        var promise: Promise?

        init(subscriber: AnySubscriber<output, failure="">) {
            self.subscriber = subscriber
        }

        func request(_ demand: Subscribers.Demand) {
            guard let promise = promise else { return }
            let result: Result<output, failure=""> = // ejecutar aquí la lógica del futuro aplazado
            _ = subscriber?.receive(result)
            subscriber?.receive(completion: .finished)
        }

        func cancel() {
            subscriber = nil
        }
    }
}

    En este ejemplo, DefferedFuture recibe un cierre de promesa como parámetro en su inicializador. Este cierre de promesa recibe un AnySubscriber como entrada y devuelve un Promise, que es un cierre que eventualmente ejecutará la lógica de tu futuro aplazado y enviará su resultado al suscriptor.

    El método receive(subscriber:) conforma DefferedFuture al protocolo Publisher y crea una nueva DefferedFutureSubscription. Esta suscripción almacena el cierre de promesa que se pasó a DefferedFuture, y cuando recibe una llamada a request(_:), ejecuta la lógica del futuro aplazado y envía su resultado al suscriptor.

    En resumen, crear un publicador personalizado como DefferedFuture te permite encapsular tu lógica de futuro aplazado de manera reutilizable, facilitando su incorporación en tu código según sea necesario.</output,></output,></output,></output,></output,></output,>

Comments are closed.