An instance of Seq where the element type is Element. This is the super-type
of all sequence data types.
| Operations | |
| append(s:Seq(Element)):Seq(Element) | Appe-nd two sequences. |
| asProperSeq():Seq(Element) | No Documentation Specified |
| asSeq():Seq(Element) | Turns a sequence into a sequence. |
| asSet():Set(Element) | Turn a sequence into a set. |
| asString():String | Turns a sequence of integers into a string. |
| asVector():Vector | Turns a sequence into a vector. |
| assoc(key:Element):Element | Receiver must be an a-list. Returns a-list headed by pair whose head is the key or null. |
| at(n:Integer):Element | Returns the nth element of a sequence starting from 0. |
| bind(key:Element,value:Element):Seq(Element) | Binds a key with a value and adds it to the head of the sequence. |
| binds(key:Element):Boolean | Returns true of a sequence contains a binding that matches the key. |
| butLast():Seq(Element) | Returns all elements but the last element. |
| collect(filter:Element):Seq(Element) | No Documentation Specified |
| contains(element:Element):Boolean | Returns true if the sequence contains the element. |
| default():Seq(Element) | Returns the default sequence: an empty sequence. |
| delete(element:Element,multiple:Boolean):Seq(Element) | Deletes the element by side effect from the receiver and returns the receiver. The second argument controls whether or not multiple occurrences are deleted. |
| delete(element:Element):Element | No Documentation Specified |
| dom():Set(Element) | Returns the keys in an environment |
| dot(name:String):Seq(Element) | Returns the result of iterating over a sequence and performing dot on each element. |
| drop(n:Integer):Seq(Element) | Drops the first n elements from a sequence. |
| dropWhile(pred:Operation):Seq(Element) | Drop elements until pred is not satisfied. |
| equals(other:Element):Boolean | Returns true if a sequence equals another sequence. To be equal they must both be sequences and their elements should be equal and in the same order. |
| excluding(element:Element):Element | No Documentation Specified |
| exists(pred:Element):Boolean | Returns true when one element of the sequence satisfies the predicate otherwise it returns false. |
| flatten():Seq(Element) | Turns a sequence of sequences of X into a sequence of X. |
| forAll(pred:Element):Boolean | Returns true if all elements of the sequence satisfy the predicate otherwise returns false. |
| get(name:String):Element | No Documentation Specified |
| hasPrefix(prefix:Seq(Element)):Boolean | Returns true if a sequence is prefixed by the sequence prefix. |
| hasSuffix(suffix:Seq(Element)):Boolean | Returns true if a sequence is suffixed by the sequence suffix |
| head():Element | Returns the head of a sequence. |
| includes(element:Element):Boolean | Returns true if a sequence contains element. |
| includesAll(c:Collection(Element)):Boolean | Returns true if a sequence includes all the elements in the collection c. |
| including(e:Element):Seq(Element) | Returns the result of including the element e in a sequence. The element is added to the head of the sequence. |
| indexOf(element:Element):Integer | Returns the first index of the element in a sequence. If it is not found, returns -1. |
| insertAt(e:Element,i:Integer):Seq(Element) | Inserts an element e at position i in a sequence. |
| intersection(s:Seq(Element)):Set(Element) | Returns common elements. |
| isEmpty():Boolean | Returns true if a sequence is empty. |
| isEnv():Boolean | An environment is implement by a sequence when the sequence is a proper sequence of pairs. |
| isKindOf(type:Classifier):Boolean | Returns true if all elements in a sequence are instances of type. |
| isProperSequence():Boolean | Returns true if the last tail is a valid sequence. |
| iter(iterator:Element,value:Element):Seq(Element) | Iterates through a sequence, returning a sequence. |
| last():Element | Returns the last element of a non-empty sequence. |
| linkAt(element:Element,index:Integer):Seq(Element) | Inserts an element into a sequence at the index. |
| lookup():Element | Lookup is a message which when sent to a sequence of strings will lookup the element at the path given by the strings in order. If no element exists then an error is raised. |
| lookup(key:Element):Element | Looks up a pair in a sequence using the key. Returns an error if the key cannot be found. |
| makeTree(children:Element):Element | No Documentation Specified |
| map(message:Element,args:Element):Element | No Documentation Specified |
| max():Integer | Returns the maximum valued element in the sequence. |
| mul(s:Seq(Element)):Seq(Element) | Generates a sequence containing all combinations of elements in the two sequences. |
| prefixes():Seq(Element) | Returns all possible prefixes of a sequence including the empty sequence. |
| prepend(e:Element):Seq(Element) | Prepe-nd adds an element to the head of a sequence and returns a new sequence. |
| qsort(pred:Operation):Seq(Element) | Quicksorts the elements in the sequence. Is supplied with an operation of the form @Operation(x,y) predicate en-d where x and y will be elements in the sequence. An example predicate might be x < y. |
| ref(nameSpaces:Element):Element | Looks up a namespace path represented as a sequence of strings to the element found at the path. The operation takes a sequence of namespaces as an argument; the namespace arguments are used as the basis for the lookup. |
| reject(pred:Element):Seq(Element) | No Documentation Specified |
| removeAt(index:Integer):Seq(Element) | Removes element at speicified index. |
| replaceAt(index:Integer,new:Element):Seq(Element) | Replace the element at the supplied index. |
| reverse():Seq(Element) | Reverses a sequence. |
| sel():Element | Returns one element from a sequence. |
| select(predicate:Element):Seq(Element) | Applies a filter to a sequence of elements. |
| separateWith(sep:String):String | Constructs a string by concatenating the elements of a sequence together, separated by sep. |
| set(key:Element,value:Element):Seq(Element) | Sets the value of a binding in a sequence indexed by key. Creates a binding if one does not exist. |
| setTail(newTail:Element):Element | Sets the tail of a non-empty sequence to be the supplied new tail. |
| size():Integer | Returns the size of a sequence. |
| sort(pred:Element):Seq(Element) | Sorts a sequence using a comparison predicate of the form @Operation(x,y) predicate en-d. The predicate must be a comparison expression, e.g. x < y. |
| sortNamedElements(caseDependent:Boolean):Seq(NamedElement) | Sorts a sequence of names. This operation is implemented in the kernel as is therefore very fast. |
| sortNamedElements():Seq(NamedElement) | Default case depen-dent use of sortNamedElements(arg) |
| sortNamedElements_CaseIndependent():Seq(Element) | No Documentation Specified |
| sortNames():Seq(String) | Sorts a sequence of names. |
| subSequence(starting:Element,terminating:Element):Element | Produces a subsequence given two indices. The first index is inclusive and is the starting index. The second index is exclusive and is the terminating index. |
| subst(new:Element,old:Element,all:Boolean):Seq(Element) | Substitutes old for new in a sequence. If all is true, it will replace all elements, otherwise it will replace the first element. |
| tail():Seq(Element) | Returns the tail of a sequence. |
| take(n:Integer):Element | Takes n elements from the tail of a sequence. |
| takeWhile(pred:Operation):Seq(Element) | No Documentation Specified |
| toString():String | Produces a printed representation of a sequence. |
| unbind(key:Element):Element | No Documentation Specified |
| zip(s:Seq(Element)):Seq(Element) | Produces a sequences of pairs by matching the first element of a sequence with the first element of s, and so on... |