LazyStreamAggregate S

stream.spad line 1 [edit on github]

LazyStreamAggregate is the category of streams with lazy evaluation. It is understood that the function ‘empty?’ will cause lazy evaluation if necessary to determine if there are entries. Functions which call ‘empty?’, e.g. ‘first’ and ‘rest’, will also cause lazy evaluation if necessary.

#: % -> NonNegativeInteger if % has finiteAggregate

from Aggregate

<=: (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

<: (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

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

from BasicType

>=: (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

>: (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

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

from BasicType

any?: (S -> Boolean, %) -> 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

complete: % -> %

complete(st) causes all entries of ‘st’ to be computed. this function should only be called on streams which are known to be finite.

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

from UnaryRecursiveAggregate S

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

from UnaryRecursiveAggregate S

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

from UnaryRecursiveAggregate S

concat: (%, %) -> %

from LinearAggregate S

concat: (%, S) -> %

from LinearAggregate S

concat: (S, %) -> %

from LinearAggregate S

concat: List % -> %

from LinearAggregate S

construct: List S -> %

from Collection S

convert: % -> InputForm if S has ConvertibleTo InputForm

from ConvertibleTo InputForm

copy: % -> %

from Aggregate

copyInto!: (%, %, Integer) -> % if % has shallowlyMutable and % has finiteAggregate

from LinearAggregate S

count: (S -> Boolean, %) -> NonNegativeInteger if % has finiteAggregate

from HomogeneousAggregate S

count: (S, %) -> NonNegativeInteger if % has finiteAggregate and S has BasicType

from HomogeneousAggregate S

cycleEntry: % -> %

from UnaryRecursiveAggregate S

cycleLength: % -> NonNegativeInteger

from UnaryRecursiveAggregate S

cycleSplit!: % -> % if % has shallowlyMutable

from UnaryRecursiveAggregate S

cycleTail: % -> %

from UnaryRecursiveAggregate S

cyclic?: % -> Boolean

from RecursiveAggregate S

delete: (%, Integer) -> %

from LinearAggregate S

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate S

distance: (%, %) -> Integer

from RecursiveAggregate S

elt: (%, first) -> S

from UnaryRecursiveAggregate S

elt: (%, Integer) -> S

from Eltable(Integer, S)

elt: (%, Integer, S) -> S

from EltableAggregate(Integer, S)

elt: (%, last) -> S

from UnaryRecursiveAggregate S

elt: (%, rest) -> %

from UnaryRecursiveAggregate S

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

elt: (%, value) -> S

from RecursiveAggregate S

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List S

from IndexedAggregate(Integer, S)

entry?: (S, %) -> Boolean if % has finiteAggregate and S has BasicType

from IndexedAggregate(Integer, 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 if % has finiteAggregate

from HomogeneousAggregate S

explicitEntries?: % -> Boolean

explicitEntries?(s) returns true if the stream s has explicitly computed entries, and false otherwise.

explicitlyEmpty?: % -> Boolean

explicitlyEmpty?(s) returns true if the stream is an (explicitly) empty stream. Note: this is a null test which will not cause lazy evaluation.

explicitlyFinite?: % -> Boolean

from StreamAggregate S

extend: (%, Integer) -> %

extend(st, n) causes entries to be computed, if necessary, so that ‘st’ will have at least 'n' explicit entries or so that all entries of ‘st’ will be computed if ‘st’ is finite with length <= n.

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

from IndexedAggregate(Integer, S)

find: (S -> Boolean, %) -> Union(S, failed)

from Collection S

first: % -> S

from IndexedAggregate(Integer, S)

first: (%, NonNegativeInteger) -> %

from LinearAggregate S

frst: % -> S

frst(s) returns the first element of stream s. Caution: this function should only be called after a empty? test has been made since there is no error check.

hash: % -> SingleInteger if S has SetCategory

from SetCategory

hashUpdate!: (HashState, %) -> HashState if S has SetCategory

from SetCategory

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, S)

indices: % -> List Integer

from IndexedAggregate(Integer, S)

insert: (%, %, Integer) -> %

from LinearAggregate S

insert: (S, %, Integer) -> %

from LinearAggregate S

last: % -> S

from UnaryRecursiveAggregate S

last: (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate S

latex: % -> String if S has SetCategory

from SetCategory

lazy?: % -> Boolean

lazy?(s) returns true if the first node of the stream s is a lazy evaluation mechanism which could produce an additional entry to s.

lazyEvaluate: % -> %

lazyEvaluate(s) causes one lazy evaluation of stream s. Caution: the first node must be a lazy evaluation mechanism (satisfies lazy?(s) = true) as there is no error check. Note: a call to this function may or may not produce an explicit first entry

leaf?: % -> Boolean

from RecursiveAggregate S

leaves: % -> List S

from RecursiveAggregate S

leftTrim: (%, S) -> % if % has finiteAggregate and S has BasicType

from LinearAggregate S

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from HomogeneousAggregate S

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

from LinearAggregate S

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

from HomogeneousAggregate S

max: % -> S if S has OrderedSet and % has finiteAggregate

from HomogeneousAggregate S

max: (%, %) -> % if S has OrderedSet and % has finiteAggregate

from OrderedSet

max: ((S, S) -> Boolean, %) -> S if % has finiteAggregate

from HomogeneousAggregate S

maxIndex: % -> Integer

from IndexedAggregate(Integer, S)

member?: (S, %) -> Boolean if % has finiteAggregate and S has BasicType

from HomogeneousAggregate S

members: % -> List S if % has finiteAggregate

from HomogeneousAggregate S

merge: (%, %) -> % if S has OrderedSet and % has finiteAggregate

from LinearAggregate S

merge: ((S, S) -> Boolean, %, %) -> % if % has finiteAggregate

from LinearAggregate S

min: % -> S if S has OrderedSet and % has finiteAggregate

from HomogeneousAggregate S

min: (%, %) -> % if S has OrderedSet and % has finiteAggregate

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, S)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

new: (NonNegativeInteger, S) -> %

from LinearAggregate S

node?: (%, %) -> Boolean if S has BasicType

from RecursiveAggregate S

nodes: % -> List %

from RecursiveAggregate S

numberOfComputedEntries: % -> NonNegativeInteger

numberOfComputedEntries(st) returns the number of explicitly computed entries of stream st which exist immediately prior to the time this function is called.

parts: % -> List S if % has finiteAggregate

from HomogeneousAggregate S

position: (S -> Boolean, %) -> Integer if % has finiteAggregate

from LinearAggregate S

position: (S, %) -> Integer if % has finiteAggregate and S has BasicType

from LinearAggregate S

position: (S, %, Integer) -> Integer if % has finiteAggregate and S has BasicType

from LinearAggregate S

possiblyInfinite?: % -> Boolean

from StreamAggregate S

qelt: (%, Integer) -> S

from EltableAggregate(Integer, S)

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

from EltableAggregate(Integer, S)

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

from UnaryRecursiveAggregate S

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

from UnaryRecursiveAggregate S

reduce: ((S, S) -> S, %) -> S if % has finiteAggregate

from Collection S

reduce: ((S, S) -> S, %, S) -> S if % has finiteAggregate

from Collection S

reduce: ((S, S) -> S, %, S, S) -> S if % has finiteAggregate and S has BasicType

from Collection S

remove: (S -> Boolean, %) -> %

remove(f, st) returns a stream consisting of those elements of stream st which do not satisfy the predicate f. Note: remove(f, st) = [x for x in st | not f(x)].

remove: (S, %) -> % if % has finiteAggregate and S has BasicType

from Collection S

removeDuplicates: % -> % if % has finiteAggregate and S has BasicType

from Collection S

rest: % -> %

from UnaryRecursiveAggregate S

rest: (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate S

reverse!: % -> % if % has shallowlyMutable and % has finiteAggregate

from LinearAggregate S

reverse: % -> % if % has finiteAggregate

from LinearAggregate S

rightTrim: (%, S) -> % if % has finiteAggregate and S has BasicType

from LinearAggregate S

rst: % -> %

rst(s) returns a pointer to the next node of stream s. Caution: this function should only be called after a empty? test has been made since there is no error check.

sample: %

from Aggregate

second: % -> S

from UnaryRecursiveAggregate S

select: (S -> Boolean, %) -> %

select(f, st) returns a stream consisting of those elements of stream st satisfying the predicate f. Note: select(f, st) = [x for x in st | f(x)].

setchildren!: (%, List %) -> % if % has shallowlyMutable

from RecursiveAggregate S

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

from UnaryRecursiveAggregate S

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

from EltableAggregate(Integer, S)

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

from UnaryRecursiveAggregate S

setelt!: (%, rest, %) -> % if % has shallowlyMutable

from UnaryRecursiveAggregate S

setelt!: (%, UniversalSegment Integer, S) -> S if % has shallowlyMutable

from LinearAggregate S

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

from RecursiveAggregate S

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

from UnaryRecursiveAggregate S

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

from UnaryRecursiveAggregate S

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

from UnaryRecursiveAggregate S

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

from RecursiveAggregate S

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean if % has finiteAggregate and S has Comparable or S has OrderedSet and % has finiteAggregate

from Comparable

sort!: % -> % if % has shallowlyMutable and S has OrderedSet and % has finiteAggregate

from LinearAggregate S

sort!: ((S, S) -> Boolean, %) -> % if % has shallowlyMutable and % has finiteAggregate

from LinearAggregate S

sort: % -> % if S has OrderedSet and % has finiteAggregate

from LinearAggregate S

sort: ((S, S) -> Boolean, %) -> % if % has finiteAggregate

from LinearAggregate S

sorted?: % -> Boolean if S has OrderedSet and % has finiteAggregate

from LinearAggregate S

sorted?: ((S, S) -> Boolean, %) -> Boolean if % has finiteAggregate

from LinearAggregate S

split!: (%, NonNegativeInteger) -> % if % has shallowlyMutable

from UnaryRecursiveAggregate S

swap!: (%, Integer, Integer) -> Void if % has shallowlyMutable

from IndexedAggregate(Integer, S)

tail: % -> %

from UnaryRecursiveAggregate S

third: % -> S

from UnaryRecursiveAggregate S

trim: (%, S) -> % if % has finiteAggregate and S has BasicType

from LinearAggregate S

value: % -> S

from RecursiveAggregate S

Aggregate

BasicType if S has SetCategory or % has finiteAggregate and S has BasicType

CoercibleTo OutputForm if S has CoercibleTo OutputForm

Collection S

Comparable if S has OrderedSet and % has finiteAggregate or % has finiteAggregate and S has Comparable

ConvertibleTo InputForm if S has ConvertibleTo InputForm

Eltable(Integer, S)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, S)

Evalable S if S has SetCategory and S has Evalable S

HomogeneousAggregate S

IndexedAggregate(Integer, S)

InnerEvalable(S, S) if S has SetCategory and S has Evalable S

LinearAggregate S

OrderedSet if S has OrderedSet and % has finiteAggregate

PartialOrder if S has OrderedSet and % has finiteAggregate

RecursiveAggregate S

SetCategory if S has SetCategory

StreamAggregate S

UnaryRecursiveAggregate S