Generic Class

Future

A publisher that eventually produces a single value and then finishes or fails.

Declaration

final class Future<Output, Failure> where Failure : Error

Topics

Creating a Future

init((@escaping Future<Output, Failure>.Promise) -> Void)

Creates a publisher that invokes a promise closure when the publisher emits an element.

typealias Future.Promise

A type that represents a closure to invoke in the future, when an element or error is available.

Instance Methods

func allSatisfy((Output) -> Bool) -> Publishers.AllSatisfy<Future<Output, Failure>>
func append(Output...) -> Publishers.Concatenate<Future<Output, Failure>, Publishers.Sequence<[Output], Failure>>
func assertNoFailure(String, file: StaticString, line: UInt) -> Publishers.AssertNoFailure<Future<Output, Failure>>
func assign<Root>(to: ReferenceWritableKeyPath<Root, Output>, on: Root) -> AnyCancellable
Available when Failure is Never.
func breakpoint(receiveSubscription: ((Subscription) -> Bool)?, receiveOutput: ((Output) -> Bool)?, receiveCompletion: ((Subscribers.Completion<Failure>) -> Bool)?) -> Publishers.Breakpoint<Future<Output, Failure>>
func breakpointOnError() -> Publishers.Breakpoint<Future<Output, Failure>>
func buffer(size: Int, prefetch: Publishers.PrefetchStrategy, whenFull: Publishers.BufferingStrategy<Failure>) -> Publishers.Buffer<Future<Output, Failure>>
func `catch`<P>((Failure) -> P) -> Publishers.Catch<Future<Output, Failure>, P>
func collect() -> Publishers.Collect<Future<Output, Failure>>
func collect(Int) -> Publishers.CollectByCount<Future<Output, Failure>>
func collect<S>(Publishers.TimeGroupingStrategy<S>, options: S.SchedulerOptions?) -> Publishers.CollectByTime<Future<Output, Failure>, S>
func combineLatest<P>(P) -> Publishers.CombineLatest<Future<Output, Failure>, P>
func combineLatest<P, Q>(P, Q) -> Publishers.CombineLatest3<Future<Output, Failure>, P, Q>
func combineLatest<P, T>(P, (Output, P.Output) -> T) -> Publishers.Map<Publishers.CombineLatest<Future<Output, Failure>, P>, T>
func combineLatest<P, Q, R>(P, Q, R) -> Publishers.CombineLatest4<Future<Output, Failure>, P, Q, R>
func combineLatest<P, Q, T>(P, Q, (Output, P.Output, Q.Output) -> T) -> Publishers.Map<Publishers.CombineLatest3<Future<Output, Failure>, P, Q>, T>
func combineLatest<P, Q, R, T>(P, Q, R, (Output, P.Output, Q.Output, R.Output) -> T) -> Publishers.Map<Publishers.CombineLatest4<Future<Output, Failure>, P, Q, R>, T>
func compactMap<T>((Output) -> T?) -> Publishers.CompactMap<Future<Output, Failure>, T>
func contains(Output) -> Publishers.Contains<Future<Output, Failure>>
Available when Output conforms to Equatable.
func contains(where: (Output) -> Bool) -> Publishers.ContainsWhere<Future<Output, Failure>>
func count() -> Publishers.Count<Future<Output, Failure>>
func debounce<S>(for: S.SchedulerTimeType.Stride, scheduler: S, options: S.SchedulerOptions?) -> Publishers.Debounce<Future<Output, Failure>, S>
func decode<Item, Coder>(type: Item.Type, decoder: Coder) -> Publishers.Decode<Future<Output, Failure>, Item, Coder>
func delay<S>(for: S.SchedulerTimeType.Stride, tolerance: S.SchedulerTimeType.Stride?, scheduler: S, options: S.SchedulerOptions?) -> Publishers.Delay<Future<Output, Failure>, S>
func drop<P>(untilOutputFrom: P) -> Publishers.DropUntilOutput<Future<Output, Failure>, P>
func drop(while: (Output) -> Bool) -> Publishers.DropWhile<Future<Output, Failure>>
func dropFirst(Int) -> Publishers.Drop<Future<Output, Failure>>
func encode<Coder>(encoder: Coder) -> Publishers.Encode<Future<Output, Failure>, Coder>
Available when Output conforms to Encodable.
func eraseToAnyPublisher() -> AnyPublisher<Output, Failure>
func filter((Output) -> Bool) -> Publishers.Filter<Future<Output, Failure>>
func first() -> Publishers.First<Future<Output, Failure>>
func first(where: (Output) -> Bool) -> Publishers.FirstWhere<Future<Output, Failure>>
func flatMap<T, P>(maxPublishers: Subscribers.Demand, (Output) -> P) -> Publishers.FlatMap<P, Future<Output, Failure>>
func handleEvents(receiveSubscription: ((Subscription) -> Void)?, receiveOutput: ((Output) -> Void)?, receiveCompletion: ((Subscribers.Completion<Failure>) -> Void)?, receiveCancel: (() -> Void)?, receiveRequest: ((Subscribers.Demand) -> Void)?) -> Publishers.HandleEvents<Future<Output, Failure>>
func ignoreOutput() -> Publishers.IgnoreOutput<Future<Output, Failure>>
func last() -> Publishers.Last<Future<Output, Failure>>
func last(where: (Output) -> Bool) -> Publishers.LastWhere<Future<Output, Failure>>
func makeConnectable() -> Publishers.MakeConnectable<Future<Output, Failure>>
Available when Failure is Never.
func map<T>((Output) -> T) -> Publishers.Map<Future<Output, Failure>, T>
func map<T>(KeyPath<Output, T>) -> Publishers.MapKeyPath<Future<Output, Failure>, T>
func map<T0, T1>(KeyPath<Output, T0>, KeyPath<Output, T1>) -> Publishers.MapKeyPath2<Future<Output, Failure>, T0, T1>
func map<T0, T1, T2>(KeyPath<Output, T0>, KeyPath<Output, T1>, KeyPath<Output, T2>) -> Publishers.MapKeyPath3<Future<Output, Failure>, T0, T1, T2>
func mapError<E>((Failure) -> E) -> Publishers.MapError<Future<Output, Failure>, E>
func max() -> Publishers.Comparison<Future<Output, Failure>>
Available when Output conforms to Comparable.
func max(by: (Output, Output) -> Bool) -> Publishers.Comparison<Future<Output, Failure>>
func measureInterval<S>(using: S, options: S.SchedulerOptions?) -> Publishers.MeasureInterval<Future<Output, Failure>, S>
func merge(with: Future<Output, Failure>) -> Publishers.MergeMany<Future<Output, Failure>>
func merge<B, C>(with: B, C) -> Publishers.Merge3<Future<Output, Failure>, B, C>
func merge<B, C, D>(with: B, C, D) -> Publishers.Merge4<Future<Output, Failure>, B, C, D>
func merge<B, C, D, E>(with: B, C, D, E) -> Publishers.Merge5<Future<Output, Failure>, B, C, D, E>
func merge<B, C, D, E, F>(with: B, C, D, E, F) -> Publishers.Merge6<Future<Output, Failure>, B, C, D, E, F>
func merge<B, C, D, E, F, G>(with: B, C, D, E, F, G) -> Publishers.Merge7<Future<Output, Failure>, B, C, D, E, F, G>
func merge<B, C, D, E, F, G, H>(with: B, C, D, E, F, G, H) -> Publishers.Merge8<Future<Output, Failure>, B, C, D, E, F, G, H>
func min() -> Publishers.Comparison<Future<Output, Failure>>
Available when Output conforms to Comparable.
func min(by: (Output, Output) -> Bool) -> Publishers.Comparison<Future<Output, Failure>>
func multicast<S>(() -> S) -> Publishers.Multicast<Future<Output, Failure>, S>
func multicast<S>(subject: S) -> Publishers.Multicast<Future<Output, Failure>, S>
func output(at: Int) -> Publishers.Output<Future<Output, Failure>>
func output<R>(in: R) -> Publishers.Output<Future<Output, Failure>>
func prefix(Int) -> Publishers.Output<Future<Output, Failure>>
func prefix<P>(untilOutputFrom: P) -> Publishers.PrefixUntilOutput<Future<Output, Failure>, P>
func prefix(while: (Output) -> Bool) -> Publishers.PrefixWhile<Future<Output, Failure>>
func prepend(Output...) -> Publishers.Concatenate<Publishers.Sequence<[Output], Failure>, Future<Output, Failure>>
func print(String, to: TextOutputStream?) -> Publishers.Print<Future<Output, Failure>>
func receive<S>(on: S, options: S.SchedulerOptions?) -> Publishers.ReceiveOn<Future<Output, Failure>, S>
func receive<S>(subscriber: S)
func reduce<T>(T, (T, Output) -> T) -> Publishers.Reduce<Future<Output, Failure>, T>
func removeDuplicates() -> Publishers.RemoveDuplicates<Future<Output, Failure>>
Available when Output conforms to Equatable.
func removeDuplicates(by: (Output, Output) -> Bool) -> Publishers.RemoveDuplicates<Future<Output, Failure>>
func replaceEmpty(with: Output) -> Publishers.ReplaceEmpty<Future<Output, Failure>>
func replaceError(with: Output) -> Publishers.ReplaceError<Future<Output, Failure>>
func replaceNil<T>(with: T) -> Publishers.Map<Future<Output, Failure>, T>
func retry(Int) -> Publishers.Retry<Future<Output, Failure>>
func scan<T>(T, (T, Output) -> T) -> Publishers.Scan<Future<Output, Failure>, T>
func setFailureType<E>(to: E.Type) -> Publishers.SetFailureType<Future<Output, Failure>, E>
Available when Failure is Never.
func share() -> Publishers.Share<Future<Output, Failure>>
func sink(receiveCompletion: ((Subscribers.Completion<Failure>) -> Void), receiveValue: ((Output) -> Void)) -> AnyCancellable
func sink(receiveValue: ((Output) -> Void)) -> AnyCancellable
Available when Failure is Never.
func subscribe<S>(S) -> AnyCancellable
func subscribe<S>(S)
func subscribe<S>(on: S, options: S.SchedulerOptions?) -> Publishers.SubscribeOn<Future<Output, Failure>, S>
func switchToLatest() -> Publishers.SwitchToLatest<Output, Future<Output, Failure>>
Available when Failure is Output.Failure and Output conforms to Publisher.
func throttle<S>(for: S.SchedulerTimeType.Stride, scheduler: S, latest: Bool) -> Publishers.Throttle<Future<Output, Failure>, S>
func timeout<S>(S.SchedulerTimeType.Stride, scheduler: S, options: S.SchedulerOptions?, customError: (() -> Failure)?) -> Publishers.Timeout<Future<Output, Failure>, S>
func tryAllSatisfy((Output) -> Bool) -> Publishers.TryAllSatisfy<Future<Output, Failure>>
func tryCatch<P>((Failure) -> P) -> Publishers.TryCatch<Future<Output, Failure>, P>
func tryCompactMap<T>((Output) -> T?) -> Publishers.TryCompactMap<Future<Output, Failure>, T>
func tryContains(where: (Output) -> Bool) -> Publishers.TryContainsWhere<Future<Output, Failure>>
func tryDrop(while: (Output) -> Bool) -> Publishers.TryDropWhile<Future<Output, Failure>>
func tryFilter((Output) -> Bool) -> Publishers.TryFilter<Future<Output, Failure>>
func tryFirst(where: (Output) -> Bool) -> Publishers.TryFirstWhere<Future<Output, Failure>>
func tryLast(where: (Output) -> Bool) -> Publishers.TryLastWhere<Future<Output, Failure>>
func tryMap<T>((Output) -> T) -> Publishers.TryMap<Future<Output, Failure>, T>
func tryMax(by: (Output, Output) -> Bool) -> Publishers.TryComparison<Future<Output, Failure>>
func tryMin(by: (Output, Output) -> Bool) -> Publishers.TryComparison<Future<Output, Failure>>
func tryPrefix(while: (Output) -> Bool) -> Publishers.TryPrefixWhile<Future<Output, Failure>>
func tryReduce<T>(T, (T, Output) -> T) -> Publishers.TryReduce<Future<Output, Failure>, T>
func tryRemoveDuplicates(by: (Output, Output) -> Bool) -> Publishers.TryRemoveDuplicates<Future<Output, Failure>>
func tryScan<T>(T, (T, Output) -> T) -> Publishers.TryScan<Future<Output, Failure>, T>
func zip<P>(P) -> Publishers.Zip<Future<Output, Failure>, P>
func zip<P, T>(P, (Output, P.Output) -> T) -> Publishers.Map<Publishers.Zip<Future<Output, Failure>, P>, T>
func zip<P, Q>(P, Q) -> Publishers.Zip3<Future<Output, Failure>, P, Q>
func zip<P, Q, T>(P, Q, (Output, P.Output, Q.Output) -> T) -> Publishers.Map<Publishers.Zip3<Future<Output, Failure>, P, Q>, T>
func zip<P, Q, R>(P, Q, R) -> Publishers.Zip4<Future<Output, Failure>, P, Q, R>
func zip<P, Q, R, T>(P, Q, R, (Output, P.Output, Q.Output, R.Output) -> T) -> Publishers.Map<Publishers.Zip4<Future<Output, Failure>, P, Q, R>, T>

Relationships

Conforms To

See Also

Convenience Publishers

struct Just

A publisher that emits an output to each subscriber just once, and then finishes.

struct Deferred

A publisher that awaits subscription before running the supplied closure to create a publisher for the new subscriber.

struct Empty

A publisher that never publishes any values, and optionally finishes immediately.

struct Fail

A publisher that immediately terminates with the specified error.

struct Record

A publisher that allows for recording a series of inputs and a completion, for later playback to each subscriber.