Initializes an effect that immediately emits the action passed in.
static func send(_ action: Action) -> Effect<Action> The action that is immediately emitted by the effect.
static func send(Action, animation: Animation?) -> Effect<Action> Initializes an effect that immediately emits the action passed in.
import ComposableArchitectureThe Composable Architecture (TCA, for short) is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind. It can be used in SwiftUI, UIKit, and more, and on any Apple platform (iOS, macOS, tvOS, and watchOS).
struct Effect<Action>Learn how to improve the performance of features built in the Composable Architecture.
static func send(_ action: Action, animation: Animation? = nil) -> Effect<Action> Initializes an effect that immediately emits the action passed in.
static var none: Self { get }An effect that does nothing and completes immediately. Useful for situations where you must return an effect, but you don’t need to do anything.
static func run(priority: TaskPriority? = nil, operation: @escaping (_ send: Send<Action>) async throws -> Void, catch handler: ((_ error: any Error, _ send: Send<Action>) async -> Void)? = nil, fileID: StaticString = #fileID, filePath: StaticString = #filePath, line: UInt = #line, column: UInt = #column) -> Effect<Action> Wraps an asynchronous unit of work that can emit actions any number of times in an effect.
typealias EffectOf<R> = Effect<R.Action> where R : ReducerA convenience type alias for referring to an effect of a given reducer’s domain.
enum TaskResult<Success> where Success : SendableA value that represents either a success or a failure. This type differs from Swift’s Result type in that it uses only one generic for the success case, leaving the failure case as an untyped Error.
static func cancel(id: some Hashable & Sendable) -> Effect<Action> An effect that will cancel any currently in-flight effect with the given identifier.
static func concatenate(_ effects: Self...) -> Effect<Action> Concatenates a variadic list of effects together into a single effect, which runs the effects one after the other.
static func concatenate(_ effects: some Collection<Self>) -> Effect<Action> Concatenates a collection of effects together into a single effect, which runs the effects one after the other.
static func merge(_ effects: Self...) -> Effect<Action> Merges a variadic list of effects together into a single effect, which runs the effects at the same time.
static func merge(_ effects: some Sequence<Self>) -> Effect<Action> Merges a sequence of effects together into a single effect, which runs the effects at the same time.
static func publisher(_ createPublisher: () -> some Publisher<Action, Never>) -> Effect<Action> Creates an effect from a Combine publisher.
func animation(_ animation: Animation? = .default) -> Effect<Action> Wraps the emission of each element with SwiftUI’s withAnimation.
func cancellable(id: some Hashable & Sendable, cancelInFlight: Bool = false) -> Effect<Action> Turns an effect into one that is capable of being canceled.
func concatenate(with other: Self) -> Effect<Action> Concatenates this effect and another into a single effect that first runs this effect, and after it completes or is cancelled, runs the other.
func debounce<S>(id: some Hashable & Sendable, for dueTime: S.SchedulerTimeType.Stride, scheduler: S, options: S.SchedulerOptions? = nil) -> Effect<Action> where S : Scheduler Turns an effect into one that can be debounced.
func map<T>(_ transform: @escaping (Action) -> T) -> Effect<T> Transforms all elements from the upstream effect with a provided closure.
func merge(with other: Self) -> Effect<Action> Merges this effect and another into a single effect that runs both at the same time.
func transaction(_ transaction: Transaction) -> Effect<Action> Wraps the emission of each element with SwiftUI’s withTransaction.