StreamAggregate(S)

aggcat.spad line 1623 [edit on github]

• S : Type

A stream aggregate is a linear aggregate which possibly has an infinite number of elements. A basic domain constructor which builds stream aggregates is Stream. From streams, a number of infinite structures such as power series can be built.

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

from BasicType

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

from PartialOrder

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

from PartialOrder

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 : (%, %) -> %

from LinearAggregate(S)

concat : (%, S) -> %

from LinearAggregate(S)

concat : (S, %) -> %

from LinearAggregate(S)

concat : List(%) -> %

from LinearAggregate(S)

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

from UnaryRecursiveAggregate(S)

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

from UnaryRecursiveAggregate(S)

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

from UnaryRecursiveAggregate(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, %) -> NonNegativeInteger if S has BasicType and % has finiteAggregate

from HomogeneousAggregate(S)

count : (Mapping(Boolean, S), %) -> NonNegativeInteger if % 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 : (%, "rest") -> %

from UnaryRecursiveAggregate(S)

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

from Eltable(UniversalSegment(Integer), %)

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

from UnaryRecursiveAggregate(S)

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

from UnaryRecursiveAggregate(S)

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

from RecursiveAggregate(S)

elt : (%, Integer) -> S

from Eltable(Integer, S)

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

from EltableAggregate(Integer, S)

empty : () -> %

from Aggregate

empty? : % -> Boolean

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 : (%, 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)

explicitlyFinite? : % -> Boolean

explicitlyFinite?(s) tests if the stream has a finite number of elements, and false otherwise. Note: for many datatypes, explicitlyFinite?(s) = not possiblyInfinite?(s).

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

from IndexedAggregate(Integer, S)

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

from Collection(S)

first : (%, NonNegativeInteger) -> %

from LinearAggregate(S)

first : % -> S

from IndexedAggregate(Integer, S)

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 : (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate(S)

last : % -> S

from UnaryRecursiveAggregate(S)

latex : % -> String if S has SetCategory

from SetCategory

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 : (Mapping(S, S), %) -> %

from HomogeneousAggregate(S)

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

from LinearAggregate(S)

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

from HomogeneousAggregate(S)

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

from OrderedSet

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

from HomogeneousAggregate(S)

max : (Mapping(Boolean, S, S), %) -> 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 : (Mapping(Boolean, S, S), %, %) -> % if % has finiteAggregate

from LinearAggregate(S)

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

from OrderedSet

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

from HomogeneousAggregate(S)

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)

parts : % -> List(S) if % has finiteAggregate

from HomogeneousAggregate(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)

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

from LinearAggregate(S)

possiblyInfinite? : % -> Boolean

possiblyInfinite?(s) tests if the stream s could possibly have an infinite number of elements. Note: for many datatypes, possiblyInfinite?(s) = not explictlyFinite?(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 : (Mapping(S, S, S), %) -> S if % has finiteAggregate

from Collection(S)

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

from Collection(S)

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

from Collection(S)

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

from Collection(S)

remove : (Mapping(Boolean, S), %) -> % if % 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

from LinearAggregate(S)

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

from LinearAggregate(S)

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

from LinearAggregate(S)

sample : () -> %

from Aggregate

second : % -> S

from UnaryRecursiveAggregate(S)

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

from Collection(S)

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

from RecursiveAggregate(S)

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

from UnaryRecursiveAggregate(S)

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

from UnaryRecursiveAggregate(S)

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

from UnaryRecursiveAggregate(S)

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

from RecursiveAggregate(S)

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

from EltableAggregate(Integer, S)

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

from LinearAggregate(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 S has OrderedSet and % has finiteAggregate

from LinearAggregate(S)

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

from LinearAggregate(S)

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

from LinearAggregate(S)

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

from LinearAggregate(S)

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

from LinearAggregate(S)

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

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

from BasicType

Comparable

ConvertibleTo(InputForm)

InnerEvalable(S, S)

Aggregate

UnaryRecursiveAggregate(S)

LinearAggregate(S)

BasicType

RecursiveAggregate(S)

IndexedAggregate(Integer, S)

OrderedSet

SetCategory

Evalable(S)

HomogeneousAggregate(S)

PartialOrder

CoercibleTo(OutputForm)

Collection(S)

Eltable(UniversalSegment(Integer), %)

EltableAggregate(Integer, S)

Hashable

Eltable(Integer, S)