LazyStreamAggregate S

stream.spad line 1 [edit on github]

• S: Type

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. Elements of LazyStreamAggregate are computed only when strictly needed. Lazy computation means that potential errors are delayed, so errors are detected later than in case of normal (eager) evaluation used by other aggregates. In some cases computation that would signal error when using eager evaluation can succeed when using lazy evaluation.

#: % -> 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 S has BasicType and % has finiteAggregate or S has Hashable and % has finiteAggregate

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 S has BasicType and % has finiteAggregate or S has Hashable and % has finiteAggregate

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 finiteAggregate and % has shallowlyMutable

from LinearAggregate S

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

from HomogeneousAggregate S

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

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 S has BasicType and % has finiteAggregate

from IndexedAggregate(Integer, S)

eq?: (%, %) -> Boolean

from Aggregate

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

from Evalable S

eval: (%, List 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: (%, S, S) -> % if S has Evalable S and S has SetCategory

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 Hashable and % has finiteAggregate

from Hashable

hashUpdate!: (HashState, %) -> HashState if S has Hashable and % has finiteAggregate

from Hashable

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 S has BasicType and % has finiteAggregate

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 S has BasicType and % has finiteAggregate

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 S has BasicType and % has finiteAggregate

from LinearAggregate S

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

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 S has BasicType and % has finiteAggregate

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 S has BasicType and % has finiteAggregate

from Collection S

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

from Collection S

rest: % -> %

from UnaryRecursiveAggregate S

rest: (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate S

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

from LinearAggregate S

reverse: % -> % if % has finiteAggregate

from LinearAggregate S

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

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 S has OrderedSet and % has finiteAggregate or % has finiteAggregate and S has Comparable

from Comparable

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

from LinearAggregate S

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

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 S has BasicType and % has finiteAggregate

from LinearAggregate S

value: % -> S

from RecursiveAggregate S

Aggregate

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

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 Evalable S and S has SetCategory

Hashable if S has Hashable and % has finiteAggregate

HomogeneousAggregate S

IndexedAggregate(Integer, S)

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

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