Collections Module

Import using: use collections

Stack

Last-in, First-out (LIFO). Methods: push, pop, peek, contains, clear, isEmpty, size, toArray, toString.

use collections
let s = new collections.Stack()
s.push(10)
s.push(20)
s.push(30)
print(str(s.pop()))     # 30
print(str(s.peek()))    # 20 (top without removing)
print(str(s.size()))    # 2
print(str(s.contains(10)))  # True
print(str(s.isEmpty()))     # False
print(str(s.toArray()))     # [10, 20]
s.clear()
print(str(s.isEmpty()))     # True

Queue

First-in, First-out (FIFO). Methods: enqueue, dequeue, front, rear, contains, clear, isEmpty, size, toArray, toString.

use collections
let q = new collections.Queue()
q.enqueue("a")
q.enqueue("b")
q.enqueue("c")
print(q.dequeue())      # a
print(q.front())        # b
print(q.rear())         # c
print(str(q.size()))    # 2

Deque

Double-ended queue. Methods: pushFront, pushBack, popFront, popBack, front, back, contains, clear, isEmpty, size, toArray, toString.

use collections
let d = new collections.Deque()
d.pushBack(1)
d.pushBack(2)
d.pushFront(0)
print(str(d.popFront()))  # 0
print(str(d.popBack()))   # 2
print(str(d.front()))     # 1
print(str(d.back()))      # 1

Map

Ordered key-value store. Methods: set, get, getOrDefault, has, delete, clear, size, isEmpty, keys, values, entries, mapValues, filterEntries, forEach, merge, toArray, toString.

use collections
let m = new collections.Map()
m.set("name", "Djazair")
m.set("version", 1.0)
print(m.get("name"))              # Djazair
print(m.getOrDefault("missing", "N/A"))  # N/A
print(str(m.has("name")))         # True
print(str(m.keys()))              # ["name", "version"]
print(str(m.values()))            # ["Djazair", 1.0]
m.delete("version")
print(str(m.size()))              # 1

Set

Unique values. Methods: add, has, delete, clear, size, isEmpty, toArray, values, union, intersection, difference, isSubset, equals, toString.

use collections
let setA = new collections.Set()
setA.add(1)
setA.add(2)
setA.add(3)
let setB = new collections.Set()
setB.add(2)
setB.add(3)
setB.add(4)
print(str(setA.union(setB)))        # [1, 2, 3, 4]
print(str(setA.intersection(setB))) # [2, 3]
print(str(setA.difference(setB)))   # [1]
print(str(setB.isSubset(setA)))     # False

LinkedList

Doubly linked list. Methods: append, prepend, popBack, popFront, front, back, contains, toArray, isEmpty, size, clear, toString.

use collections
let ll = new collections.LinkedList()
ll.append("first")
ll.append("second")
ll.prepend("zeroth")
print(ll.front())         # zeroth
print(ll.back())          # second
print(str(ll.toArray()))  # ["zeroth", "first", "second"]

PriorityQueue

Min-heap by priority number. Methods: enqueue(value, priority), dequeue, peek, isEmpty, size, clear, toArray, toString.

use collections
let pq = new collections.PriorityQueue()
pq.enqueue("low", 3)
pq.enqueue("high", 1)
pq.enqueue("mid", 2)
print(pq.dequeue())  # high (lowest priority number first)
print(pq.dequeue())  # mid
print(pq.peek())     # low