// The context in which the tasks can execute. 
// `policy` describes what should be done if a task with an identical `taskId` is added to group.
// In this case we want to ignore subsequent tasks with the same `taskId` until the first is completed.
// Other options exist.
let taskGroup = TaskGroup(policy: .ignore)

self.isLoading = true
self.interactor
  .fetchIssues(request, itemLimit: 10, progressive: true) // API that exposes a Chop'esque interface.
  .onUpdate { [weak self] in
    // Can be executed multiple times (i.e. providing first cached items, then remote items).
    self?.items = $0
  }
  .onFailure { [weak self] in
    // Executed only once if error occurs.
    self?.handleError($0)  
  }
  .onCompletion { [weak self] in
    // Executed when the task has finished, regardless of result.
    self?.isLoading = false 
  }
  // `taskId` is optional - it will be 
  .registerIn(self.taskGroup, taskId: "itemFetch")

func fetchIssues(request: IssueRequest, itemLimit: UInt, progressive: Bool) -> Task<[Issue]> {
  return Task {
    let localItems = self.localDB.getItems(request)
    // Send local items through to the Task subscribers.
    $0(.update(localItems))
    
    // The following operation is asynchronous.
    var urlSessionTask = self.httpClient.getItems(request) { result in
      switch result {
        // Once again send data through to the Task subscribers.
        case .success(let issues): $0(.update(issues))
        // Or, otherwise, send error.
        case .failure(let error):  $0(.error(localResponse))
      }
      $0(.completion)
    }
    
    // In this closure we perform cleanup. It will be called if the task is finished or cancelled.
    return { urlSessionTask.cancel(); urlSessionTask = nil }
  }
}