UnaryRecursiveAggregate(S)

aggcat.spad line 1296 [edit on github]

A unary-recursive aggregate is an aggregate where nodes may have either 0 or 1 children. This aggregate models, though not precisely, a linked list possibly with a single cycle. A node with one children models a non-empty list, with the value of the list designating the head, or first, of the list, and the child designating the tail, or rest, of the list. Since these aggregates are recursive aggregates, they may be cyclic.

# : % -> NonNegativeInteger if % has finiteAggregate
from Aggregate
= : (%, %) -> Boolean if S has BasicType and % has finiteAggregate or S has SetCategory
from BasicType
any? : (Mapping(Boolean, S), %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate(S)
child? : (%, %) -> Boolean if S has BasicType
from RecursiveAggregate(S)
children : % -> List(%)
from RecursiveAggregate(S)
coerce : % -> OutputForm if S has CoercibleTo(OutputForm)
from CoercibleTo(OutputForm)
concat : (%, %) -> %

concat(u, v) returns an aggregate w consisting of the elements of u followed by the elements of v. Note: v = rest(w, #u).

concat : (S, %) -> %

concat(x, u) returns aggregate consisting of x followed by the elements of u. Note: if v = concat(x, u) then x = first v and u = rest v.

concat! : (%, %) -> % if % has shallowlyMutable

concat!(u, v) destructively concatenates v to the end of u.

concat! : (%, S) -> % if % has shallowlyMutable

concat!(u, x) destructively adds element x to the end of u. Note: concat!(a, x) = concat!(a, [x]).

concat! : List(%) -> % if % has shallowlyMutable

concat!(lu), where lu is a list of aggregates [a, b, ..., c], returns a single aggregate consisting of the elements of a followed by those of b followed ... by the elements of c. This function may destructively modify the aggregates in lu.

copy : % -> %
from Aggregate
count : (S, %) -> NonNegativeInteger if S has BasicType and % has finiteAggregate
from HomogeneousAggregate(S)
count : (Mapping(Boolean, S), %) -> NonNegativeInteger if % has finiteAggregate
from HomogeneousAggregate(S)
cycleEntry : % -> %

cycleEntry(u) returns the head of a top-level cycle contained in aggregate u, or empty() if none exists.

cycleLength : % -> NonNegativeInteger

cycleLength(u) returns the length of a top-level cycle contained in aggregate u, or 0 if u has no such cycle.

cycleSplit! : % -> % if % has shallowlyMutable

cycleSplit!(u) splits the aggregate by dropping off the cycle. The value returned is the cycle entry, or empty() if none exists. For example, if w = concat(u, v) is the cyclic list where v is the head of the cycle, cycleSplit!(w) will drop v off w thus destructively changing w to u, and returning v.

cycleTail : % -> %

cycleTail(u) returns the last node in the cycle, or empty() if none exists.

cyclic? : % -> Boolean
from RecursiveAggregate(S)
distance : (%, %) -> Integer
from RecursiveAggregate(S)
elt : (%, "rest") -> %

elt(%, "rest") (also written: u.rest) is equivalent to rest u.

elt : (%, "first") -> S

elt(u, "first") (also written: u.first) is equivalent to first(u).

elt : (%, "last") -> S

elt(u, "last") (also written: u.last) is equivalent to last(u).

elt : (%, "value") -> S
from RecursiveAggregate(S)
empty : () -> %
from Aggregate
empty? : % -> Boolean
from Aggregate
eq? : (%, %) -> Boolean
from Aggregate
eval : (%, S, S) -> % if S has Evalable(S) and S has SetCategory
from InnerEvalable(S, S)
eval : (%, Equation(S)) -> % if S has Evalable(S) and S has SetCategory
from Evalable(S)
eval : (%, List(S), List(S)) -> % if S has Evalable(S) and S has SetCategory
from InnerEvalable(S, S)
eval : (%, List(Equation(S))) -> % if S has Evalable(S) and S has SetCategory
from Evalable(S)
every? : (Mapping(Boolean, S), %) -> Boolean if % has finiteAggregate
from HomogeneousAggregate(S)
first : (%, NonNegativeInteger) -> %

first(u, n) returns a copy of the first n elements of u.

first : % -> S

first(u) returns the first element of u (equivalently, the value at the current node).

last : (%, NonNegativeInteger) -> %

last(u, n) returns a copy of the last n nodes of u. Note: last(u, n) is a list of n elements.

last : % -> S

last(u) returns the last element of u. Note: for lists, last(u) = u.(maxIndex u).

latex : % -> String if S has SetCategory
from SetCategory
leaf? : % -> Boolean
from RecursiveAggregate(S)
leaves : % -> List(S)
from RecursiveAggregate(S)
less? : (%, NonNegativeInteger) -> Boolean
from Aggregate
map : (Mapping(S, S), %) -> %
from HomogeneousAggregate(S)
map! : (Mapping(S, S), %) -> % if % has shallowlyMutable
from HomogeneousAggregate(S)
max : % -> S if S has OrderedSet and % has finiteAggregate
from HomogeneousAggregate(S)
max : (Mapping(Boolean, S, S), %) -> S if % has finiteAggregate
from HomogeneousAggregate(S)
member? : (S, %) -> Boolean if S has BasicType and % has finiteAggregate
from HomogeneousAggregate(S)
members : % -> List(S) if % has finiteAggregate
from HomogeneousAggregate(S)
min : % -> S if S has OrderedSet and % has finiteAggregate
from HomogeneousAggregate(S)
more? : (%, NonNegativeInteger) -> Boolean
from Aggregate
node? : (%, %) -> Boolean if S has BasicType
from RecursiveAggregate(S)
nodes : % -> List(%)
from RecursiveAggregate(S)
parts : % -> List(S) if % has finiteAggregate
from HomogeneousAggregate(S)
qsetfirst! : (%, S) -> S if % has shallowlyMutable

qsetfirst!(u, x) destructively changes the first element of u to x without checking for errors.

qsetrest! : (%, %) -> % if % has shallowlyMutable

qsetrest!(u, v) destructively changes the rest of u to v without checking for errors.

rest : % -> %

rest(u) returns an aggregate consisting of all but the first element of u (equivalently, the next node of u).

rest : (%, NonNegativeInteger) -> %

rest(u, n) returns the nth node of u. Note: rest(u, 0) = u.

sample : () -> %
from Aggregate
second : % -> S

second(u) returns the second element of u. Note: second(u) = first(rest(u)).

setchildren! : (%, List(%)) -> % if % has shallowlyMutable
from RecursiveAggregate(S)
setelt! : (%, "rest", %) -> % if % has shallowlyMutable

setelt!(u, "rest", v) (also written: u.rest := v) is equivalent to setrest!(u, v).

setelt! : (%, "first", S) -> S if % has shallowlyMutable

setelt!(u, "first", x) (also written: u.first := x) is equivalent to setfirst!(u, x).

setelt! : (%, "last", S) -> S if % has shallowlyMutable

setelt!(u, "last", x) (also written: u.last := x) is equivalent to setlast!(u, x).

setelt! : (%, "value", S) -> S if % has shallowlyMutable
from RecursiveAggregate(S)
setfirst! : (%, S) -> S if % has shallowlyMutable

setfirst!(u, x) destructively changes the first element of u to x. Error if u is empty.

setlast! : (%, S) -> S if % has shallowlyMutable

setlast!(u, x) destructively changes the last element of u to x. Error if u is empty.

setrest! : (%, %) -> % if % has shallowlyMutable

setrest!(u, v) destructively changes the rest of u to v. Error if u is empty.

setvalue! : (%, S) -> S if % has shallowlyMutable
from RecursiveAggregate(S)
size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
split! : (%, NonNegativeInteger) -> % if % has shallowlyMutable

split!(u, n) splits u into two aggregates: v = rest(u, n) and w = first(u, n), returning v and setting u to w. If n is 0, split! currently only works for Stream and gives error for List. Note: afterwards rest(u, n) returns empty().

tail : % -> %

tail(u) returns the last node of u. Error if u is empty.

third : % -> S

third(u) returns the third element of u. Note: third(u) = first(rest(rest(u))).

value : % -> S
from RecursiveAggregate(S)
~= : (%, %) -> Boolean if S has BasicType and % has finiteAggregate or S has SetCategory
from BasicType

InnerEvalable(S, S)

RecursiveAggregate(S)

SetCategory

HomogeneousAggregate(S)

Evalable(S)

CoercibleTo(OutputForm)

Aggregate

BasicType