Swift implementations of enumerable bag, queue and stack using linked lists

Collections.swift

private class Node<T> {
    var item: T?
    var next: Node<T>?
    
    init(item: T?, next: Node<T>?) {
        self.item = item
        self.next = next
    }
}

private class QueueNode<T>: Node<T> {
    var previous: QueueNode<T>?
    
    init(item: T?, previous: QueueNode<T>?,next: QueueNode<T>?) {
        super.init(item: item, next: next)
        self.previous = previous
    }
}

public class Bag<T>: SequenceType {
    
    private var first: Node<T>? = nil
    private var listSize: Int = 0
    
    public func generate() -> GeneratorOf<T> {
        var currentNode = first
        return GeneratorOf<T> {
            var node = currentNode
            currentNode = node!.next
            return node!.item
        }
    }
    
    public func add(item: T) {
        var oldFirst = first
        first = Node(item: item, next: oldFirst)
        listSize++
    }
    
    public func isEmpty() -> Bool {
        return listSize == 0
    }
    
    public func size() -> Int {
        return listSize
    }
}

public class Queue<T>: SequenceType {
    
    private var first: QueueNode<T>? = nil
    private var last: QueueNode<T>? = nil
    private var listSize: Int = 0
    
    public func generate() -> GeneratorOf<T> {
        var currentNode = last
        return GeneratorOf<T> {
            var node = currentNode
            currentNode = node!.previous
            return node!.item
        }
    }
    
    public func enqueue(item: T) {
        if listSize == 0 {
            first = QueueNode(item: item, previous: nil, next: nil)
            last = first
        } else {
            let oldFirst = first
            first = QueueNode(item: item, previous: nil, next: oldFirst)
            oldFirst?.previous = first
        }
        
        listSize++
    }
    
    public func dequeue() -> T? {
        
        if listSize == 0 {
            return nil
        } else {
            var oldLast = last
            last = oldLast?.previous
            listSize--
            return oldLast!.item
        }
    }
    
    public func isEmpty() -> Bool {
        return listSize == 0
    }
    
    public func size() -> Int {
        return listSize
    }
    
}

public class Stack<T>: SequenceType {
    
    private var first: Node<T>? = nil
    private var listSize: Int = 0
    
    public func generate() -> GeneratorOf<T> {
        var current = first
        return GeneratorOf<T> {
            var item = current?.item
            current = current?.next
            return item
        }
    }
    
    public func push(item: T) {
        
        if listSize == 0 {
            first = Node(item: item, next: nil)
        } else {
            let oldFirst = first
            first = Node(item: item, next: oldFirst)
        }
        
        listSize++
    }
    
    public func pop() -> T? {
        
        if listSize == 0 {
            return nil
        } else {
            let oldFirst = first
            first = oldFirst!.next
            listSize--
            return oldFirst!.item
        }
    }
    
    public func isEmpty() -> Bool {
        return listSize == 0
    }
    
    public func size() -> Int {
        return listSize
    }
}