While optional, unwrap if contains something - swift

Question

The context : I have a generic stack of objects. The stack responds to pop() (returns an optional) and I have a function that needs to process the stack
If the stack is empty, throw an error
Otherwise, repeat repeat operation until next optional is not unwrappable
So far
guard var nextVar = myStack.pop() else {
throw MyError.EmptyStack
}
repeat {
// Process nextVar
} while nextVar = myStack.pop()
Problem : the first nextVar is NOT an Optional, therefore my while call fails. How can I rewrite so that the while checks whether the optional contains something AND if that succeeds, assign the content to the variable ? ()

Answer 1

You should modify your stack type to include an isEmpty property. Then you won't need to duplicate the pop call, and this will be a simple while-let loop.
guard !myStack.isEmpty else {
throw MyError.EmptyStack
}
while let nextVar = myStack.pop() {
// Process nextVar
}
You can also convert this into a SequenceType, but then iterating won't consume the stack. Then this would just be:
guard !myStack.isEmpty else {
throw MyError.EmptyStack
}
for nextVar in myStack {
// Process nextVar
}
Since pop is exactly the needed implementation of GeneratorType.next(), it should be easy to turn this into a GeneratorType and a SequenceType (by returning self in generate()).
But since Stack is a value type, iterating over it with for-in will make a copy and then consume that copy, rather than consuming the original stack. That could be good or bad.
Here's a sketch of what I mean:
struct Stack<Element> {
private var stack: [Element] = []
mutating func push(element: Element) {
stack.append(element)
}
mutating func pop() -> Element? {
guard let result = stack.last else { return nil }
stack.removeLast()
return result
}
var isEmpty: Bool { return stack.isEmpty }
}
extension Stack: GeneratorType {
mutating func next() -> Element? {
return pop()
}
}
extension Stack: SequenceType {
func generate() -> Stack {
return self
}
}