List -- the class of all lists -- {...}

List -- the class of all lists -- {...}

The type List is a member of the class Type. Each object of class List is called a list. Each list is also a member of class VisibleList.

More general types (whose methods may also apply) :

VisibleList -- the class of all visible lists

BasicList -- the class of all basic lists

See also:

lists -- an overview

Common operations on lists:

append -- add to the end of a list

join -- join lists

prepend -- add to the beginning of a list

Common ways to apply functions to elements of lists:

apply(BasicList,Function) -- apply function to each element

scan(BasicList,Function) -- apply a function to each element of a list

Common ways to test elements of lists:

all(BasicList,Function) -- whether all elements satisfy a condition

any(BasicList,Function) -- whether an element satisfies a condition

Common ways to find things in lists:

position(VisibleList,Function) -- find first element of a list satisfying a condition

positions(VisibleList,Function) -- which elements of a list satisfy a condition

select(BasicList,Function) -- select elements from a list

select(ZZ,BasicList,Function) -- select a limited number of elements from a list

Common ways to extract elements from lists:

drop -- drop some elements

take -- take some elements from a list

{...} # ZZ -- get element from list

{...} #? ZZ -- check for element in list

{...} _ ZZ -- get element from list

VisibleList _ {...} -- get some entries of a list

Functions and methods returning a a list :

- {...} -- negation of a vector

{...} + {...} -- sum of two vectors

{...} - {...} -- sum of two vectors

List / Function

List / Thing

List << Thing

{...} | {...} -- join lists

apply(ZZ,Function) -- apply function to 0 .. n-1

ascii String -- ASCII character conversion

ass

ass Ideal -- find the associated primes of an ideal

ass MonomialIdeal

between(Thing,VisibleList)

characters String

degree Matrix

euler -- list the sectional Euler characteristics

genera -- list the sectional arithmetic genera

keys HashTable -- keys used in a hash table

pack(BasicList,ZZ)

pack(ZZ,BasicList)

pairs HashTable

primaryDecomposition

primaryDecomposition Ideal -- find a primary decomposition of an ideal

primaryDecomposition MonomialIdeal

separate(String,String)

Thing * List

toList BasicList -- list of elements

toList HashTable -- convert to list

toList Set -- list of elements

transpose List

unique -- eliminate duplicates from a list

values HashTable -- values in a hash table

Methods for using a list :

List .. List

List / MarkUpType

List / SelfInitializingType

List << Manipulator

List == List

{...} ==> Function -- attaching options to a function

{...} _ ZZ -- get element from list

ascii {...} -- ASCII character conversion

basis(List,Ideal)

basis({...},Module) -- basis of the part of a module of a certain degree

basis(List,Ring)

cacheFileName(List,Thing)

chainComplex List

code List

coefficients(List,Matrix)

coefficients(List,RingElement)

concatenate List

directSum List

document List

drop(BasicList,{...}) -- drop some elements

dual(MonomialIdeal,{...}) -- the Alexander dual

gcd List

hilbertFunction(List,CoherentSheaf)

hilbertFunction(List,Ideal)

hilbertFunction(List,Module)

hilbertFunction(List,ProjectiveVariety)

hilbertFunction(List,Ring)

homogenize(Matrix,RingElement,List)

homogenize(Module,RingElement,List)

homogenize(RingElement,RingElement,List)

homogenize(Vector,RingElement,List)

html List

Ideal _ {...} -- map from free module to some generators

ideal List

intersect List

isSubset(Sequence,List)

isSubset(List,Sequence)

isSubset(List,List)

isSubset(List,Set)

isSubset(Set,List)

map(Module,Module,{...}) -- make a map

map(Module,Nothing,{...}) -- make a map

map(Module,ZZ,{...}) -- make a map

map(Ring,Ring,{...}) -- make a ring map

MarkUpType \ List

MarkUpType List

Matrix ^ {...} -- select some rows of a matrix

Matrix _ {...} -- get some columns from a matrix

matrix {...} -- make a matrix

matrix(Ring,{...}) -- make a matrix

max List

memoize(Function,List)

min List

Module / List

Module ^ {...} -- projection map from a free module

Module _ {...} -- map from free module to some generators

Monoid _ List

monomialIdeal {...} -- make a monomial ideal

net List

new EngineRing from List

new HashTable from {...} -- make a hash table from a list

new SEQ from List

new Set from List

new Vector from List

oldCoefficients(List,Matrix)

oldCoefficients(List,RingElement)

peek2(List,ZZ)

PolynomialRing _ List

precedence List

product {...} -- product of elements

product(Sequence,List,Function)

product(List,Sequence,Function)

product({...},{...},Function) -- product of results of applying a function pairwise

product({...},Function) -- product of values of a function

random({...},Ring) -- a random ring element of a given degree

Ring / List

Ring ^ {...} -- make a free module

Ring _ {...} -- make a monomial from a list of exponents

RingElement _ {...}

SchurRing _ {...} -- make an element of a Schur ring

SelfInitializingType \ List

set List

SheafOfRings ^ List

standardPairs(MonomialIdeal,List)

submatrix(Matrix,Sequence,List)

submatrix(Matrix,List)

submatrix(Matrix,List,Sequence)

submatrix(Matrix,List,List)

submatrix(Matrix,List,Nothing)

submatrix(Matrix,Nothing,List)

subsets {...} -- produce all the subsets

subsets(List,ZZ)

substitute(Ideal,List)

substitute(Matrix,List)

substitute(Module,List)

substitute(RingElement,List)

substitute(Vector,List)

sum {...} -- sum the elements of a list

sum(Sequence,List,Function)

sum(List,Sequence,Function)

sum({...},{...},Function) -- sum results of applying a function pairwise

sum({...},Function) -- sum results of applying a function

take(BasicList,{...}) -- take some elements from a list

tex List

truncate(List,Module)

unique List

vars List

VisibleList _ {...} -- get some entries of a list

WrapperType List

Fixed objects of class List :

commandLine -- the command line arguments

environment -- the environment variables