There are many ways to write Queues in Swift, but wrapping an Array is about as easy a solution as you can get. You get all the push/pop behavior for free. (Yes, there are better solutions for complexity, but I really want to show off ArrayLiteralConvertible in this write-up.)

Wrapping an Array

Start with a basic struct to envelope your queue:

public struct Queue<T> {
    public private(set) var elements: Array<T> = []
}

Notice the private(set) modifier for elements. This restricts the read-write scope of the property. Your elements are visible but cannot be  set outside the file that declares them.  This “private” behavior can surprise you in playgrounds, where your timeline acts as a single file.  Consuming the queue in the same timeline means private elements can be overridden. This is an unusual use-case.

var q = Queue(elements: [1, 2, 3]) // 1, 2, 3
q.elements = [4, 5]
q.elements // 4, 5

Next, decide where you want your expensive operations to happen: on push or pop. Both removeLast() and append(value) are O(1) but insert(value, atIndex: n) and removeFirst() are O(`count`). Choose one cheap operation and one expensive operation.

public struct Queue<T> { 
    public private(set) var elements: Array<T> = []
    public mutating func push(value: T) { elements.append(value) } // O(1)
    public mutating func pop() -> T { return elements.removeFirst() } // O(`count`)
}

Guarding against Fatal Errors

At this point, you’ve now got a working queue. Unfortunately, there’s a major problem with this implementation. Calling `removeFirst` on an empty collection raises a fatal error. Oops.

You can resolve this in several ways:

1. Stick with the status quo and live dangerously (The “Russian Roulette queue”)
2. You can make the queue throwing (ugh)
3. You can make the return type optional (you have to test and unwrap)
4. You can introduce an isEmpty property so you can test before popping.

I like option 4.

public struct Queue<T> { 
    public private(set) var elements: Array<T> = []
    public mutating func push(value: T) { elements.append(value) }
    public mutating func pop() -> T { return elements.removeFirst() }
    public var isEmpty: Bool { return elements.isEmpty }
}

Adding the property lets you guard your actions before applying any dangerous calls.

while !q.isEmpty { print(q.pop(), q.elements) }

Better Initialization

Structs offer free memberwise initialization, so you get an initializer for free that looks something like this:

var q = Queue(elements: [4, 5])

I find it more aesthetically pleasing to initialize using a standard array with inferred types:

var q: Queue<String> = [] // Queue<String>
var p: Queue = [1, 2, 3] // Queue<Int>

This behavior is courtesy of ArrayLiteralConvertible, and it’s really simple to implement. Just declare conformance and add an extra initializer:

/// A first-in/first-out queue of unconstrained size
/// - Complexity: push is O(1), pop is O(`count`)
public struct Queue<T>: ArrayLiteralConvertible {
    /// backing array store
    public private(set) var elements: Array<T> = []
 
    /// introduce a new element to the queue in O(1) time
    public mutating func push(value: T) { elements.append(value) }
 
    /// remove the front of the queue in O(`count` time
    public mutating func pop() -> T { return elements.removeFirst() }
 
    /// test whether the queue is empty
    public var isEmpty: Bool { return elements.isEmpty }
 
    /// queue size, computed property
    public var count: Int { return elements.count }
 
    /// offer `ArrayLiteralConvertible` support
    public init(arrayLiteral elements: T...) { self.elements = elements }
}

And there you have it, a simple, easy-to-use queue. If you want to adapt this implementation to a Stack, you get O(1) complexity for both push and pop operations using native Swift arrays.