StringAggregateΒΆ

aggcat.spad line 2487 [edit on github]

A string aggregate is a category for strings, that is, one dimensional arrays of characters.

#: % -> NonNegativeInteger

from Aggregate

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

~=: (%, %) -> Boolean

from BasicType

any?: (Character -> Boolean, %) -> Boolean

from HomogeneousAggregate Character

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Character -> %

coerce(c) returns c as a string s with the character c.

concat: (%, %) -> %

from LinearAggregate Character

concat: (%, Character) -> %

from LinearAggregate Character

concat: (Character, %) -> %

from LinearAggregate Character

concat: List % -> %

from LinearAggregate Character

construct: List Character -> %

from Collection Character

convert: % -> InputForm

from ConvertibleTo InputForm

copy: % -> %

from Aggregate

copyInto!: (%, %, Integer) -> %

from LinearAggregate Character

count: (Character -> Boolean, %) -> NonNegativeInteger

from HomogeneousAggregate Character

count: (Character, %) -> NonNegativeInteger

from HomogeneousAggregate Character

delete: (%, Integer) -> %

from LinearAggregate Character

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate Character

elt: (%, %) -> %

elt(s, t) returns the concatenation of s and t. It is provided to allow juxtaposition of strings to work as concatenation. For example, "smoo" "shed" returns "smooshed".

elt: (%, Integer) -> Character

from Eltable(Integer, Character)

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

from EltableAggregate(Integer, Character)

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List Character

from IndexedAggregate(Integer, Character)

entry?: (Character, %) -> Boolean

from IndexedAggregate(Integer, Character)

eq?: (%, %) -> Boolean

from Aggregate

eval: (%, Character, Character) -> % if Character has Evalable Character

from InnerEvalable(Character, Character)

eval: (%, Equation Character) -> % if Character has Evalable Character

from Evalable Character

eval: (%, List Character, List Character) -> % if Character has Evalable Character

from InnerEvalable(Character, Character)

eval: (%, List Equation Character) -> % if Character has Evalable Character

from Evalable Character

every?: (Character -> Boolean, %) -> Boolean

from HomogeneousAggregate Character

fill!: (%, Character) -> %

from IndexedAggregate(Integer, Character)

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

from Collection Character

first: % -> Character

from IndexedAggregate(Integer, Character)

first: (%, NonNegativeInteger) -> %

from LinearAggregate Character

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, Character)

indices: % -> List Integer

from IndexedAggregate(Integer, Character)

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

from LinearAggregate Character

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

from LinearAggregate Character

latex: % -> String

from SetCategory

leftTrim: (%, Character) -> %

from LinearAggregate Character

leftTrim: (%, CharacterClass) -> %

leftTrim(s, cc) returns s with all leading characters in cc deleted. For example, leftTrim("(abc)", charClass "()") returns "abc)".

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

lowerCase!: % -> %

lowerCase!(s) destructively replaces the alphabetic characters in s by lower case.

lowerCase: % -> %

lowerCase(s) returns the string with all characters in lower case.

map!: (Character -> Character, %) -> %

from HomogeneousAggregate Character

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

from LinearAggregate Character

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

from HomogeneousAggregate Character

match?: (%, %, Character) -> Boolean

match?(s, t, c) tests if s matches t except perhaps for multiple and consecutive occurrences of character c. Typically c is the blank character.

max: % -> Character

from HomogeneousAggregate Character

max: (%, %) -> %

from OrderedSet

max: ((Character, Character) -> Boolean, %) -> Character

from HomogeneousAggregate Character

maxIndex: % -> Integer

from IndexedAggregate(Integer, Character)

member?: (Character, %) -> Boolean

from HomogeneousAggregate Character

members: % -> List Character

from HomogeneousAggregate Character

merge: (%, %) -> %

from LinearAggregate Character

merge: ((Character, Character) -> Boolean, %, %) -> %

from LinearAggregate Character

min: % -> Character

from HomogeneousAggregate Character

min: (%, %) -> %

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, Character)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

new: (NonNegativeInteger, Character) -> %

from LinearAggregate Character

parts: % -> List Character

from HomogeneousAggregate Character

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

position(s, t, i) returns the position j of the substring s in string t, beginning at index i. Returns minIndex(s) - 1 if there is no such j.

position: (Character -> Boolean, %) -> Integer

from LinearAggregate Character

position: (Character, %) -> Integer

from LinearAggregate Character

position: (Character, %, Integer) -> Integer

from LinearAggregate Character

position: (CharacterClass, %, Integer) -> Integer

position(cc, t, i) returns the position j in string t of the first character belonging to cc, beginning at index i. Returns minIndex(t) - 1 if there is no such j.

prefix?: (%, %) -> Boolean

prefix?(s, t) tests if the string s is the initial substring of t. Note: prefix?(s, t) = reduce(and, [s.i = t.i for i in indices s]).

qelt: (%, Integer) -> Character

from EltableAggregate(Integer, Character)

qsetelt!: (%, Integer, Character) -> Character

from EltableAggregate(Integer, Character)

reduce: ((Character, Character) -> Character, %) -> Character

from Collection Character

reduce: ((Character, Character) -> Character, %, Character) -> Character

from Collection Character

reduce: ((Character, Character) -> Character, %, Character, Character) -> Character

from Collection Character

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

from Collection Character

remove: (Character, %) -> %

from Collection Character

removeDuplicates: % -> %

from Collection Character

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

replace(s, i..j, t) replaces the substring s(i..j) of s by string t.

reverse!: % -> %

from LinearAggregate Character

reverse: % -> %

from LinearAggregate Character

rightTrim: (%, Character) -> %

from LinearAggregate Character

rightTrim: (%, CharacterClass) -> %

rightTrim(s, cc) returns s with all trailing occurrences of characters in cc deleted. For example, rightTrim("(abc)", charClass "()") returns "(abc".

sample: %

from Aggregate

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

from Collection Character

setelt!: (%, Integer, Character) -> Character

from EltableAggregate(Integer, Character)

setelt!: (%, UniversalSegment Integer, Character) -> Character

from LinearAggregate Character

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean

from Comparable

sort!: % -> %

from LinearAggregate Character

sort!: ((Character, Character) -> Boolean, %) -> %

from LinearAggregate Character

sort: % -> %

from LinearAggregate Character

sort: ((Character, Character) -> Boolean, %) -> %

from LinearAggregate Character

sorted?: % -> Boolean

from LinearAggregate Character

sorted?: ((Character, Character) -> Boolean, %) -> Boolean

from LinearAggregate Character

split: (%, Character) -> List %

split(s, c) returns a list of substrings delimited by character c.

split: (%, CharacterClass) -> List %

split(s, cc) returns a list of substrings delimited by characters in cc.

substring?: (%, %, Integer) -> Boolean

substring?(s, t, i) tests if s is a substring of t beginning at index i. Note: substring?(s, t, 0) = prefix?(s, t).

suffix?: (%, %) -> Boolean

suffix?(s, t) tests if the string s is the final substring of t. Note: suffix?(s, t) = reduce(and, [s.i = t.(n - m + i) for i indices s]) where m and n denote the maxIndex of s and t respectively.

swap!: (%, Integer, Integer) -> Void

from IndexedAggregate(Integer, Character)

trim: (%, Character) -> %

from LinearAggregate Character

trim: (%, CharacterClass) -> %

trim(s, cc) returns s with all characters in cc deleted from right and left ends. For example, trim("(abc)", charClass "()") returns "abc".

upperCase!: % -> %

upperCase!(s) destructively replaces the alphabetic characters in s by corresponding upper case characters.

upperCase: % -> %

upperCase(s) returns the string with all characters in upper case.

Aggregate

BasicType

CoercibleTo OutputForm

Collection Character

Comparable

ConvertibleTo InputForm

Eltable(Integer, Character)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, Character)

Evalable Character if Character has Evalable Character

finiteAggregate

FiniteLinearAggregate Character

HomogeneousAggregate Character

IndexedAggregate(Integer, Character)

InnerEvalable(Character, Character) if Character has Evalable Character

LinearAggregate Character

OneDimensionalArrayAggregate Character

OrderedSet

PartialOrder

SetCategory

shallowlyMutable