Dequeue(S)

bags.spad line 143 [edit on github]

Linked list implementation of a Dequeue

# : % -> NonNegativeInteger
from Aggregate
= : (%, %) -> Boolean
from BasicType
any? : (Mapping(Boolean, S), %) -> Boolean
from HomogeneousAggregate(S)
back : % -> S
from QueueAggregate(S)
bottom : % -> S
from DequeueAggregate(S)
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
construct : List(S) -> %
from Collection(S)
convert : % -> InputForm if S has ConvertibleTo(InputForm)
from ConvertibleTo(InputForm)
copy : % -> %
from Aggregate
count : (S, %) -> NonNegativeInteger
from HomogeneousAggregate(S)
count : (Mapping(Boolean, S), %) -> NonNegativeInteger
from HomogeneousAggregate(S)
dequeue : List(S) -> %

dequeue([x, y, ..., z]) creates a dequeue with first (top or front) element x, second element y, ..., and last (bottom or back) element z.

dequeue! : % -> S
from QueueAggregate(S)
empty : () -> %
from Aggregate
empty? : % -> Boolean
from Aggregate
enqueue! : (S, %) -> S
from QueueAggregate(S)
eq? : (%, %) -> Boolean
from Aggregate
eval : (%, S, S) -> % if S has Evalable(S)
from InnerEvalable(S, S)
eval : (%, Equation(S)) -> % if S has Evalable(S)
from Evalable(S)
eval : (%, List(S), List(S)) -> % if S has Evalable(S)
from InnerEvalable(S, S)
eval : (%, List(Equation(S))) -> % if S has Evalable(S)
from Evalable(S)
every? : (Mapping(Boolean, S), %) -> Boolean
from HomogeneousAggregate(S)
extract! : % -> S
from BagAggregate(S)
extractBottom! : % -> S
from DequeueAggregate(S)
extractTop! : % -> S
from DequeueAggregate(S)
find : (Mapping(Boolean, S), %) -> Union(S, "failed")
from Collection(S)
front : % -> S
from QueueAggregate(S)
hash : % -> SingleInteger if S has Hashable
from Hashable
hashUpdate! : (HashState, %) -> HashState if S has Hashable
from Hashable
insert! : (S, %) -> %
from BagAggregate(S)
insertBottom! : (S, %) -> S
from DequeueAggregate(S)
insertTop! : (S, %) -> S
from DequeueAggregate(S)
inspect : % -> S
from BagAggregate(S)
latex : % -> String
from SetCategory
less? : (%, NonNegativeInteger) -> Boolean
from Aggregate
map : (Mapping(S, S), %) -> %
from HomogeneousAggregate(S)
map! : (Mapping(S, S), %) -> %
from HomogeneousAggregate(S)
max : % -> S if S has OrderedSet
from HomogeneousAggregate(S)
max : (Mapping(Boolean, S, S), %) -> S
from HomogeneousAggregate(S)
member? : (S, %) -> Boolean
from HomogeneousAggregate(S)
members : % -> List(S)
from HomogeneousAggregate(S)
min : % -> S if S has OrderedSet
from HomogeneousAggregate(S)
more? : (%, NonNegativeInteger) -> Boolean
from Aggregate
parts : % -> List(S)
from HomogeneousAggregate(S)
pop! : % -> S
from StackAggregate(S)
push! : (S, %) -> S
from StackAggregate(S)
reduce : (Mapping(S, S, S), %) -> S
from Collection(S)
reduce : (Mapping(S, S, S), %, S) -> S
from Collection(S)
reduce : (Mapping(S, S, S), %, S, S) -> S
from Collection(S)
remove : (S, %) -> %
from Collection(S)
remove : (Mapping(Boolean, S), %) -> %
from Collection(S)
removeDuplicates : % -> %
from Collection(S)
reverse! : % -> %
from DequeueAggregate(S)
rotate! : % -> %
from QueueAggregate(S)
sample : () -> %
from Aggregate
select : (Mapping(Boolean, S), %) -> %
from Collection(S)
size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
top : % -> S
from StackAggregate(S)
~= : (%, %) -> Boolean
from BasicType

BasicType

BagAggregate(S)

DequeueAggregate(S)

HomogeneousAggregate(S)

Collection(S)

QueueAggregate(S)

SetCategory

StackAggregate(S)

shallowlyMutable

Hashable

finiteAggregate

ConvertibleTo(InputForm)

CoercibleTo(OutputForm)

InnerEvalable(S, S)

Aggregate

Evalable(S)