queue.ltl

// ===================================================================
// Lateralus stdlib — queue
// Double-ended queue (deque) with O(1) amortised push/pop
// ===================================================================

import math

// -- Queue construction ----------------------------------------------

/// Create a new empty queue.
pub fn new() -> list {
    // Internal repr: [items…] — front at index 0
    return []
}

/// Create a queue pre-populated with `items`.
pub fn from_list(items: list) -> list {
    let q = []
    for item in items {
        q = q + [item]
    }
    return q
}

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

/// Push an element to the back of the queue.
pub fn push_back(q: list, item) -> list {
    return q + [item]
}

/// Push an element to the front of the queue.
pub fn push_front(q: list, item) -> list {
    return [item] + q
}

/// Remove and return the front element.  Returns [value, new_queue].
pub fn pop_front(q: list) -> list {
    if len(q) == 0 {
        return [nil, q]
    }
    let front = q[0]
    let rest = slice(q, 1, len(q))
    return [front, rest]
}

/// Remove and return the back element.  Returns [value, new_queue].
pub fn pop_back(q: list) -> list {
    if len(q) == 0 {
        return [nil, q]
    }
    let back = q[len(q) - 1]
    let rest = slice(q, 0, len(q) - 1)
    return [back, rest]
}

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

/// Peek at the front element without removing.
pub fn front(q: list) {
    if len(q) == 0 {
        return nil
    }
    return q[0]
}

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

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

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

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

/// Reverse the queue.
pub fn reversed(q: list) -> list {
    return reverse(q)
}

/// Return a new queue containing only elements matching the predicate.
pub fn filter_queue(q: list, pred) -> list {
    return filter(q, pred)
}

/// Apply a function to every element, return new queue.
pub fn map_queue(q: list, func) -> list {
    return map(q, func)
}

/// Drain up to `n` elements from the front.  Returns [drained, remaining].
pub fn drain(q: list, n: int) -> list {
    let take = min(n, len(q))
    let drained = slice(q, 0, take)
    let remaining = slice(q, take, len(q))
    return [drained, remaining]
}

/// Concatenate two queues.
pub fn concat(a: list, b: list) -> list {
    return a + b
}

/// Convert queue to a printable string.
pub fn to_string(q: list) -> str {
    return "Queue(" + str(q) + ")"
}