stack.ltl

// ===================================================================
// Lateralus stdlib — stack
// LIFO stack with standard push/pop/peek operations
// ===================================================================

// -- Stack construction ----------------------------------------------

/// Create a new empty stack.
pub fn new() -> list {
    return []
}

/// Create a stack from a list (last element = top of stack).
pub fn from_list(items: list) -> list {
    let s = []
    for item in items {
        s = s + [item]
    }
    return s
}

// -- Core operations -------------------------------------------------

/// Push an element onto the top of the stack.
pub fn push(s: list, item) -> list {
    return s + [item]
}

/// Pop the top element.  Returns [value, new_stack].
pub fn pop(s: list) -> list {
    if len(s) == 0 {
        return [nil, s]
    }
    let top = s[len(s) - 1]
    let rest = slice(s, 0, len(s) - 1)
    return [top, rest]
}

/// Peek at the top element without removing.
pub fn peek(s: list) {
    if len(s) == 0 {
        return nil
    }
    return s[len(s) - 1]
}

// -- Inspection ------------------------------------------------------

/// Return the number of elements.
pub fn size(s: list) -> int {
    return len(s)
}

/// Check whether the stack is empty.
pub fn is_empty(s: list) -> bool {
    return len(s) == 0
}

/// Check whether `item` is in the stack.
pub fn contains(s: list, item) -> bool {
    for el in s {
        if el == item {
            return true
        }
    }
    return false
}

// -- Bulk operations -------------------------------------------------

/// Reverse the stack (bottom becomes top).
pub fn reversed(s: list) -> list {
    return reverse(s)
}

/// Swap the top two elements.  Returns new stack.
pub fn swap_top(s: list) -> list {
    if len(s) < 2 {
        return s
    }
    let a = s[len(s) - 1]
    let b = s[len(s) - 2]
    let base = slice(s, 0, len(s) - 2)
    return base + [a, b]
}

/// Duplicate the top element.
pub fn dup(s: list) -> list {
    if len(s) == 0 {
        return s
    }
    return s + [s[len(s) - 1]]
}

/// Drop the top `n` elements.
pub fn drop(s: list, n: int) -> list {
    let keep = max(0, len(s) - n)
    return slice(s, 0, keep)
}

/// Apply a function to every element, return new stack.
pub fn map_stack(s: list, func) -> list {
    return map(s, func)
}

/// Fold (reduce) from bottom to top.
pub fn fold(s: list, init, func) {
    let acc = init
    for el in s {
        acc = func(acc, el)
    }
    return acc
}

/// Clear the stack — return empty.
pub fn clear(s: list) -> list {
    return []
}

/// Convert stack to a printable string.
pub fn to_string(s: list) -> str {
    return "Stack(" + str(s) + ")"
}