# sequence(state:next:) Returns a sequence formed from repeated lazy applications of `next` to a mutable `state`. ``` func sequence(state: State, next: @escaping (inout State) -> T?) -> UnfoldSequence ``` ## Parameters `state` The initial state that will be passed to the closure. `next` A closure that accepts an `inout` state and returns the next element of the sequence. ## Return Value A sequence that yields each successive value from `next`. ## Discussion The elements of the sequence are obtained by invoking `next` with a mutable state. The same state is passed to all invocations of `next`, so subsequent calls will see any mutations made by previous calls. The sequence ends when `next` returns `nil`. If `next` never returns `nil`, the sequence is infinite. This function can be used to replace many instances of `AnyIterator` that wrap a closure. Example: ``` // Interleave two sequences that yield the same element type sequence(state: (false, seq1.makeIterator(), seq2.makeIterator()), next: { iters in iters.0 = !iters.0 return iters.0 ? iters.1.next() : iters.2.next() }) ``` --- Copyright © 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)