What are the operators for publishers in Swift Combine -

In Swift's Combine framework, operators are used to process and transform the values emitted by publishers. Here are some of the key operators you can use with publishers in Combine:

Basic Operators

sink(receiveCompletion:receiveValue:): Subscribes to a publisher and provides closures to handle completion and value events.

publisher.sink(receiveCompletion: { completion in
    // Handle completion
}, receiveValue: { value in
    // Handle new value
})

assign(to:on:): Assigns each value from a publisher to a property on an object.
```
publisher.assign(to: \.property, on: object)
```

Transforming Operators

map(_:): Transforms all elements from the upstream publisher with a provided closure.
```
publisher.map { value in
    // Transform value
}
```

compactMap(_:): Similar to map, but removes nil values.

publisher.compactMap { value in
    // Transform value, return nil if value should be removed
}

flatMap(maxPublishers:_: ): Transforms elements into a new publisher.

publisher.flatMap { value in
    // Return a new publisher based on the value
}

Filtering Operators

filter(_:): Emits only those elements that pass a given predicate.

publisher.filter { value in
    // Return true if value should be included
}

removeDuplicates(): Suppresses duplicate elements.
```
publisher.removeDuplicates()
```
first(where:): Publishes the first element that satisfies the predicate, then finishes.
```
publisher.first { value in
    // Return true if value satisfies the predicate
}
```

Combining Operators

combineLatest(_:): Combines the latest value from the publisher with another publisher.
```
publisher.combineLatest(otherPublisher)
```
merge(with:): Merges elements from multiple publishers into a single stream.
```
publisher.merge(with: otherPublisher)
```
zip(_:): Combines elements from this publisher with those from another publisher.
```
publisher.zip(otherPublisher)
```

Sequence Operators

collect(_:): Collects a specified number of elements, and then publishes them as an array.
```
publisher.collect(3)
```

reduce(_: _:): Applies a closure that accumulates each element of a publisher.

publisher.reduce(0) { accumulated, value in
    // Combine accumulated value and new value
}

Timing Operators

debounce(for:scheduler:): Publishes elements only after a specified time interval elapses between events.
```
publisher.debounce(for: .seconds(1), scheduler: RunLoop.main)
```
delay(for:tolerance:scheduler:): Delays delivery of all output to the downstream receiver by a specified amount of time.
```
publisher.delay(for: .seconds(1), scheduler: RunLoop.main)
```
throttle(for:scheduler:latest:): Publishes either the most-recent or the first element received during the specified interval.
```
publisher.throttle(for: .seconds(1), scheduler: RunLoop.main, latest: true)
```

Error Handling Operators

catch(_:): Replaces an error with another publisher.

publisher.catch { error in
    // Return a new publisher to replace the error
}

retry(_:): Attempts to recreate the subscription to the upstream publisher if an error occurs.
```
publisher.retry(3)
```

These operators allow you to manipulate and control the flow of data through your Combine pipelines, providing a powerful way to handle asynchronous events in Swift.