Implementation of a stack in swift which performs push, pop and peek operations with O(1) complexity

Stack

class Stack {
    var lastNode: Node? = nil
    class Node {
        var data: Int!
        var prev: Node?

        init(data: Int, prev: Node?) {
            self.data = data
            self.prev = prev
        }
    }
    func peek() -> Int? {
        if let lastNode = lastNode {
            return lastNode.data
        } else {
            return nil
        }
    }
    func pop() -> Int? {
        if let lastNode = lastNode {
            let data = lastNode.data
            self.lastNode = nil
            self.lastNode = lastNode.prev
            return data
        } else {
            return nil
        }
    }
    func push(element: Int) {
        let node = Node(data:element, prev:lastNode)
        lastNode = node
    }
}

var stack = Stack()
stack.pop() // returns nil
stack.push(element: 24) // 24
stack.push(element: 35) // 24, 35
stack.push(element: 42) // 24, 35, 42

stack.pop() // 24, 35 -> 42
stack.pop() // 24 -> 35
stack.pop() // nil -> 24
stack.pop() // nil -> nil