StringAggregate

aggcat.spad line 2529 [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

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

from HomogeneousAggregate(Character)

coerce : Character -> %

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

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

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

from HomogeneousAggregate(Character)

count : (Mapping(Boolean, 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 : (%, UniversalSegment(Integer)) -> %

from Eltable(UniversalSegment(Integer), %)

elt : (%, Integer) -> Character

from Eltable(Integer, Character)

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

from EltableAggregate(Integer, Character)

empty : () -> %

from Aggregate

empty? : % -> Boolean

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

from HomogeneousAggregate(Character)

fill! : (%, Character) -> %

from IndexedAggregate(Integer, Character)

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

from Collection(Character)

first : (%, NonNegativeInteger) -> %

from LinearAggregate(Character)

first : % -> Character

from IndexedAggregate(Integer, Character)

hash : % -> SingleInteger

from Hashable

hashUpdate! : (HashState, %) -> HashState

from Hashable

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) returns the string with all characters in lower case.

lowerCase! : % -> %

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

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

from HomogeneousAggregate(Character)

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

from LinearAggregate(Character)

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

from OrderedSet

max : % -> Character

from HomogeneousAggregate(Character)

max : (Mapping(Boolean, Character, Character), %) -> 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 : (Mapping(Boolean, Character, Character), %, %) -> %

from LinearAggregate(Character)

min : (%, %) -> %

from OrderedSet

min : % -> Character

from HomogeneousAggregate(Character)

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, %) -> 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.

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

from LinearAggregate(Character)

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

from Collection(Character)

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

from Collection(Character)

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

from Collection(Character)

remove : (Character, %) -> %

from Collection(Character)

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

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

from LinearAggregate(Character)

sort! : % -> %

from LinearAggregate(Character)

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

from LinearAggregate(Character)

sorted? : % -> Boolean

from LinearAggregate(Character)

sorted? : (Mapping(Boolean, Character, Character), %) -> 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) returns the string with all characters in upper case.

upperCase! : % -> %

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

~= : (%, %) -> Boolean

from BasicType

Comparable

ConvertibleTo(InputForm)

HomogeneousAggregate(Character)

Aggregate

EltableAggregate(Integer, Character)

OrderedSet

OneDimensionalArrayAggregate(Character)

BasicType

InnerEvalable(Character, Character)

Evalable(Character)

Eltable(Integer, Character)

LinearAggregate(Character)

SetCategory

Collection(Character)

IndexedAggregate(Integer, Character)

PartialOrder

CoercibleTo(OutputForm)

Eltable(UniversalSegment(Integer), %)

shallowlyMutable

FiniteLinearAggregate(Character)

finiteAggregate

Hashable