The combine triad

let publisher = URLSession.shared.dataTaskPublisher(for: someURLRequest)

let sub = publisher.sink(receiveCompletion: { completionEvent in
print("The request finished with result: (completionEvent)")
}, receiveValue: { result in
print("Received result: (result)")
})

- Returns: A cancellable instance; used when you end assignment of the received value.
Deallocation of the result will tear down the subscription stream.

publisher.sink(receiveCompletion:receiveValue:)
Your code

Your code
Sink
A Subscriber is created

Your code
Sink
A Subscriber is created Publisher.subscribe(_:)

Your code
Sink
Publisher
A Subscription is created

Your code
Sink
Publisher
A Subscription is created subscriber.receive(subscription)

Your code
Sink
Publisher
Subscriber Subscription
Request values from subscription

Your code
Sink
Publisher
Obtain valuesRequest values from subscription

Your code
Sink
Publisher
Obtain values
Send values

Your code
Sink
Publisher
Receive values and request more values
Obtain values
Send values

Your code
Sink
Publisher
Obtain values
Send values
Send completion

Your code
Sink
Publisher
Obtain values
Send values
Send completionReceive completion

Publishers
• Create subscriptions

• Link subscriptions to subscribers
Subscriptions
• Obtain values by generating them or receiving them.

• Relay obtained values to subscribers (if demand is high enough)

extension Publisher {
func dw_sink(receiveCompletion:
@escaping (Subscribers.Completion<Self.Failure>) -> Void,
receiveValue:
@escaping (Self.Output) -> Void) -> AnyCancellable {
}
}
dw_sink()

receiveValue:
let subscriber = DWSink(receiveValue: receiveValue,
receiveCompletion: receiveCompletion)
}
}
dw_sink()

receiveValue:
self.subscribe(subscriber)
}
}
dw_sink()

receiveValue:
self.subscribe(subscriber)
return AnyCancellable(subscriber)
}
}
dw_sink()

public protocol Subscriber : CustomCombineIdentifierConvertible {
associatedtype Input
associatedtype Failure : Error
func receive(subscription: Subscription)
func receive(_ input: Self.Input) -> Subscribers.Demand
func receive(completion: Subscribers.Completion<Self.Failure>)
}

class DWSink<Input, Failure: Error>: Subscriber, Cancellable {
let receiveValue: (Input) -> Void
let receiveCompletion: (Subscribers.Completion<Failure>) -> Void
func receive(subscription: Subscription) {
// todo: implement
}
func receive(_ input: Input) -> Subscribers.Demand {
// todo: implement
}
func receive(completion: Subscribers.Completion<Failure>) {
// todo: implement
}
func cancel() {
// todo: implement
}
}

var subscription: Subscription?
subscription.request(.unlimited)
self.subscription = subscription
}
DWSink.receive(subscription:)

var subscription: Subscription?
subscription.request(.unlimited)
self.subscription = subscription
}
DWSink.receive(subscription:)
.max(value:) .none

func receive(_ input: Input) -> Subscribers.Demand {
receiveValue(input)
return .none
}
DWSink.receive(_:)

receive(subscription:)
Request: .max(1)
Total demand: 1

Request: .max(1)
Total demand: 1
receive(_:)
Return: .max(5)
Total demand: 6

Request: .max(1)
Total demand: 1
receive(_:)
Return: .max(5)
Total demand: 6
receive(_:)
Return: .none
Total demand: 6

func receive(completion: Subscribers.Completion<Failure>) {
receiveCompletion(completion)
}
DWSink.receive(completion:)

func cancel() {
subscription = nil
}
DWSink.cancel()

let cancellable = publisher.dw_sink(receiveCompletion: { completion in
print("Custom chain completed: (completion)")
print("Custom chain got result: (result)")
})

public protocol Publisher {
associatedtype Output
associatedtype Failure : Error
func receive<S>(subscriber: S)
where S: Subscriber, Self.Failure == S.Failure, Self.Output == S.Input
}

struct DWDataTaskPublisher: Publisher {
typealias Failure = URLError
typealias Output = (data: Data, response: URLResponse)
let request: URLRequest
func receive<S: Subscriber>(subscriber: S)
where Failure == S.Failure, Output == S.Input {
}
}

let subscription = DWDataTaskSubscription<S>(request: request,
subscriber: subscriber)
}
}

let subscription = DWDataTaskSubscription<S>(request: request,
subscriber: subscriber)
subscriber.receive(subscription: subscription)
}
}

public protocol Subscription : Cancellable, CustomCombineIdentifierConvertible {
func request(_ demand: Subscribers.Demand)
}

class DWDataTaskSubscription<S: Subscriber>: Subscription
where S.Failure == URLError,
S.Input == (data: Data, response: URLResponse) {
var subscriber: S?
func request(_ demand: Subscribers.Demand) {
// todo: implement
}
func cancel() {
subscriber = nil
}
}

func request(_ demand: Subscribers.Demand) {
guard demand > 0 else { return }
URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error as? URLError {
self.subscriber?.receive(completion: .failure(error))
} else if let data = data, let response = response {
self.subscriber?.receive((data, response))
self.subscriber?.receive(completion: .finished)
}
self.cancel()
// if we don't have an error AND no data, we should maybe do something.
// but we'll ignore it for now.
}.resume()
}

let cancellable = publisher.dw_sink(receiveCompletion: { completion in
print("Custom chain completed: (completion)")
print("Custom chain got result: (result)")
})
let publisher = DWDataTaskPublisher(request: someURLRequest)

Some tips and advise
• I mentioned it a couple of times but Apple does not recommend that you
implement custom publishers and subscriptions

• That said, it’s good to explore and see how things work.

• Retain your AnyCancellable because a in correct implementation,
Subscription will cancel as soon as the AnyCancellable is released

The combine triad

More Related Content

Similar to The combine triad (20)

More from Donny Wals (15)

Recently uploaded (20)

The combine triad