DequeueAggregate S¶

S: Type

A dequeue is a doubly ended stack, that is, a bag where first items inserted are the first items extracted, at either the front or the back end of the data structure.

#: % -> NonNegativeInteger: from Aggregate

=: (%, %) -> Boolean if S has BasicType: from BasicType

~=: (%, %) -> Boolean if S has BasicType: from BasicType

any?: (S -> Boolean, %) -> Boolean: from HomogeneousAggregate S

back: % -> S: from QueueAggregate S

bottom: % -> S: bottom(d) returns the element at the bottom (back) of the dequeue.

coerce: % -> OutputForm if S has CoercibleTo 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 -> Boolean, %) -> NonNegativeInteger: from HomogeneousAggregate S
count: (S, %) -> NonNegativeInteger if S has BasicType: from HomogeneousAggregate S

dequeue!: % -> S: from QueueAggregate S

empty?: % -> Boolean: from Aggregate

empty: () -> %: from Aggregate

enqueue!: (S, %) -> S: from QueueAggregate S

eq?: (%, %) -> Boolean: from Aggregate

eval: (%, Equation S) -> % if S has SetCategory and S has Evalable S: from Evalable S
eval: (%, List Equation S) -> % if S has SetCategory and S has Evalable S: from Evalable S
eval: (%, List S, List S) -> % if S has SetCategory and S has Evalable S: from InnerEvalable(S, S)
eval: (%, S, S) -> % if S has SetCategory and S has Evalable S: from InnerEvalable(S, S)

every?: (S -> Boolean, %) -> Boolean: from HomogeneousAggregate S

extract!: % -> S: from BagAggregate S

extractBottom!: % -> S: extractBottom!(d) destructively extracts the bottom (back) element from the dequeue d. Error: if d is empty.

extractTop!: % -> S: extractTop!(d) destructively extracts the top (front) element from the dequeue d. Error: if d is empty.

find: (S -> Boolean, %) -> 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: insertBottom!(x, d) destructively inserts x into the dequeue d at the bottom (back) of the dequeue.

insertTop!: (S, %) -> S: insertTop!(x, d) destructively inserts x into the dequeue d, that is, at the top (front) of the dequeue. The element previously at the top of the dequeue becomes the second in the dequeue, and so on.

inspect: % -> S: from BagAggregate S

latex: % -> String if S has SetCategory: from SetCategory

less?: (%, NonNegativeInteger) -> Boolean: from Aggregate

map!: (S -> S, %) -> %: from HomogeneousAggregate S

map: (S -> S, %) -> %: from HomogeneousAggregate S

max: % -> S if S has OrderedSet: from HomogeneousAggregate S
max: ((S, S) -> Boolean, %) -> S: from HomogeneousAggregate S

member?: (S, %) -> Boolean if S has BasicType: 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: ((S, S) -> S, %) -> S: from Collection S
reduce: ((S, S) -> S, %, S) -> S: from Collection S
reduce: ((S, S) -> S, %, S, S) -> S if S has BasicType: from Collection S

remove: (S -> Boolean, %) -> %: from Collection S
remove: (S, %) -> % if S has BasicType: from Collection S

removeDuplicates: % -> % if S has BasicType: from Collection S

reverse!: % -> %: reverse!(d) destructively replaces d by its reverse dequeue, i.e. the top (front) element is now the bottom (back) element, and so on.