combine
Returns a read-only StateFlow derived from two source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from three source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from four source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from five source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from six source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from seven source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from eight source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from nine source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from ten source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from eleven source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.
See also
Returns a read-only StateFlow derived from twelve source state flows using transform.
Every access to StateFlow.value reads each source's current value separately and invokes transform once. Each individual read is thread-safe, but reading several independent state flows is not one atomic operation. If a source changes while the values are being read, transform can receive values observed at different moments that might not have existed together. The transformed result is not cached between property reads. Every access to StateFlow.replayCache performs the same fresh computation and returns the result as a singleton list.
Each collector independently invokes transform for combined source values observed by that collector. Collection follows StateFlow's strong equality-based conflation: a slow collector can skip intermediate transformed values, and a transformed value that is equal to the last emitted value is not emitted again. Property reads and collectors do not share transformed results. Updating a source invokes transform only when the returned state flow is being collected; otherwise transformation occurs only when StateFlow.value or StateFlow.replayCache is accessed.
transform can be invoked repeatedly and concurrently. To preserve StateFlow semantics, it must be deterministic, side-effect-free, safe for concurrent invocation, and must not throw. An exception from transform escapes the property access or fails the affected collection; it is not represented as a state value.
This operator is useful when a StateFlow result is required instead of the Flow returned by combine.