BasicList -- the class of all basic lists

Description

For an overview of lists and sequences, see lists and sequences.

A basic list is a sequence of expressions indexed by a sequence of consecutive integers of the form 0, 1, ..., N-1. The number N is called the length of the list.

There are various types of basic lists, depending on the application, and they are displayed in different ways. The types first encountered are those of type VisibleList, but new types are easy to introduce. In the following example we introduce a new type of basic list called L.

i1 : L = new Type of BasicList

o1 = L

o1 : Type

i2 : x = new L from {a,b,c,d}

o2 = L{a, b, c, d}

o2 : L

i3 : join(x,x)

o3 = L{a, b, c, d, a, b, c, d}

o3 : L

Types of basic list :

Command -- the class of all commands
Constant
Eliminate -- elimination order
Expression -- the class of all expressions
FilePosition -- the class of all file positions
IndeterminateNumber -- the class of all indeterminate numbers
IndexedVariable -- the class of all indexed variables
InfiniteNumber -- the class of all infinite numbers
LowerBound -- the class of lower bound objects
Manipulator -- the class of all file manipulators
MutableList -- the class of all mutable lists
Option -- the class of all key-value pairs K => V
Partition -- a type of list representing a partition of a natural number
ProductOrder -- product ordering
RingElement -- the class of all ring elements handled by the engine
SumOfTwists -- the class of all sums of twists
Time -- the class of all timing results
URL -- a type representing a URL
Vector -- the class of all elements of free modules that are handled by the engine
VisibleList -- the class of all visible lists

Functions and methods returning a basic list :

"append(BasicList,Thing)" -- see append -- add an element to the end of a list
apply(BasicList,BasicList,Function) -- apply a function to pairs of elements, one from each list
apply(BasicList,Function) -- apply a function to each element of a list
"deepSplice(BasicList)" -- see deepSplice -- remove all levels of subsequences from a sequence or list
"drop(BasicList,List)" -- see drop -- drop some elements from a list or sequence.
"drop(BasicList,ZZ)" -- see drop -- drop some elements from a list or sequence.
"mergePairs(BasicList,BasicList,Function)" -- see mergePairs -- merge sorted lists of pairs
"prepend(Thing,BasicList)" -- see prepend -- add an element to the beginning of a list
"reverse(BasicList)" -- see reverse -- reverse a list, sequence, or string
select(BasicList,Function) -- select elements from a list
select(BasicList,Type) -- select elements of a given type in a list
select(ZZ,BasicList,Function) -- select a limited number of elements from a list
"splice(BasicList)" -- see splice -- remove subsequences from a sequence or list
"take(BasicList,List)" -- see take -- Take some elements from a list or sequence.
"take(BasicList,ZZ)" -- see take -- Take some elements from a list or sequence.

Methods that use a basic list :

# BasicList -- length or cardinality
"BasicList #? ZZ" -- see #? -- check existence of value in a list, hash table, database, or string
all(BasicList,BasicList,Function) -- whether all corresponding elements of a pair of lists satisfy a condition
all(BasicList,Function) -- whether all elements of a list satisfy a specified condition
any(BasicList,BasicList,Function) -- whether any corresponding elements of a pair of lists satisfy a condition
any(BasicList,Function) -- whether any elements of a list satisfy a specified condition
"apply(BasicList,String,Function)" -- see apply(BasicList,BasicList,Function) -- apply a function to pairs of elements, one from each list
"apply(String,BasicList,Function)" -- see apply(BasicList,BasicList,Function) -- apply a function to pairs of elements, one from each list
BasicList # ZZ -- get value from list, hash table, database, or string
"concatenate(BasicList)" -- see concatenate -- join strings
"delete(Thing,BasicList)" -- see delete -- delete some elements of a list
"horizontalJoin(BasicList)" -- see horizontalJoin -- join nets or strings horizontally
"maxPosition(BasicList)" -- see maxPosition -- position of the largest element
"mingle(BasicList)" -- see mingle -- mingle elements of several lists
"minPosition(BasicList)" -- see minPosition -- position of the smallest element
"pack(BasicList,ZZ)" -- see pack -- pack elements of a list or string into several shorter lists or strings
"pack(ZZ,BasicList)" -- see pack -- pack elements of a list or string into several shorter lists or strings
"pairs(BasicList)" -- see pairs -- list the pairs in a hash table, dictionary, or basic list
"scan(BasicList,BasicList,Function)" -- see scan -- apply a function to each element in a list or sequence
"scan(BasicList,Function)" -- see scan -- apply a function to each element in a list or sequence
"stack(BasicList)" -- see stack -- join nets or string vertically
"toList(BasicList)" -- see toList -- create a list
"toSequence(BasicList)" -- see toSequence -- convert to sequence

Fixed objects of class BasicList :

CatalanConstant -- Catalan's constant
clearAll -- forget everything
clearOutput -- forget output values
close -- close a file
closeIn -- close an input file
closeOut -- close an output file
commandLine -- the command line arguments
edit -- edit source code
endl -- end an output line
environment -- the environment variables
EulerConstant -- the Euler-Mascheroni constant
exit -- exit the program
flush -- flush output to file
help -- view documentation nodes
ii -- the square root of -1
indeterminate -- an indeterminate number
infinity -- infinity
infoHelp -- view documentation in Info format
listLocalSymbols -- display of local symbols and their values
listUserSymbols -- display the user's symbols
pi
profileSummary -- display profiling data
quit -- quit the program
restart -- restart Macaulay2
showClassStructure -- display class structure
showStructure -- display parent structure
showUserStructure -- show parent structure for those types defined by user
viewHelp -- view online documentation in a web browser

For the programmer

The object BasicList is a type, with ancestor class Thing.