-- -*- M2-comint -*- {* hash: 1899920477 *}

i1 : x = {a,b,c,d,e}

o1 = {a, b, c, d, e}

o1 : List

i2 : #x

o2 = 5

i3 : length x

o3 = 5

i4 : x#2

o4 = c

o4 : Symbol

i5 : x#-2

o5 = d

o5 : Symbol

i6 : first x

o6 = a

o6 : Symbol

i7 : last x

o7 = e

o7 : Symbol

i8 : g = {3,4,,5}

o8 = {3, 4, , 5}

o8 : List

i9 : peek g

o9 = {3, 4, null, 5}

i10 : 10000*{3,4,5} + {1,2,3}

o10 = {30001, 40002, 50003}

o10 : List

i11 : y = {{a,b,c},{d,{e,f}}}

o11 = {{a, b, c}, {d, {e, f}}}

o11 : List

i12 : #y

o12 = 2

i13 : flatten y

o13 = {a, b, c, d, {e, f}}

o13 : List

i14 : z = {{a,1},{b,2},{c,3}}

o14 = {{a, 1}, {b, 2}, {c, 3}}

o14 : List

i15 : isTable z

o15 = true

i16 : MatrixExpression z

o16 = | a  1 |
      |      |
      | b  2 |
      |      |
      | c  3 |

o16 : Expression of class MatrixExpression

i17 : x = (a,b,c,d,e)

o17 = (a, b, c, d, e)

o17 : Sequence

i18 : #x

o18 = 5

i19 : x#2

o19 = c

o19 : Symbol

i20 : ()

o20 = ()

o20 : Sequence

i21 : (a)

o21 = a

o21 : Symbol

i22 : (a,b)

o22 = (a, b)

o22 : Sequence

i23 : append(x,f)

o23 = (a, b, c, d, e, f)

o23 : Sequence

i24 : toList x

o24 = {a, b, c, d, e}

o24 : List

i25 : toSequence oo

o25 = (a, b, c, d, e)

o25 : Sequence

i26 : v = [a,b,c]

o26 = [a, b, c]

o26 : Array

i27 : v#2

o27 = c

o27 : Symbol

i28 : ZZ[a,b,c]

o28 = ZZ[a, b, c]

o28 : PolynomialRing

i29 : {a,b,c}

o29 = {a, b, c}

o29 : List

i30 : class oo

o30 = List

o30 : Type

i31 : parent oo

o31 = VisibleList

o31 : Type

i32 : {a,b,c}

o32 = {a, b, c}

o32 : List

i33 : class oo

o33 = List

o33 : Type

i34 : parent oo

o34 = VisibleList

o34 : Type

i35 : parent oo

o35 = BasicList

o35 : Type

i36 : new BasicList from {a,b,c}

o36 = BasicList{a, b, c}

o36 : BasicList

i37 : Container = new Type of BasicList

o37 = Container

o37 : Type

i38 : t = new Container from {a,b}

o38 = Container{a, b}

o38 : Container

i39 : join(t,t)

o39 = Container{a, b, a, b}

o39 : Container

i40 : Container ++ Container := join;

i41 : t ++ t

o41 = Container{a, b, a, b}

o41 : Container

i42 : s = new MutableList from {a,b,c}

o42 = MutableList{...3...}

o42 : MutableList

i43 : peek s

o43 = MutableList{a, b, c}

i44 : s#2 = 1234;

i45 : s

o45 = MutableList{...3...}

o45 : MutableList

i46 : peek s

o46 = MutableList{a, b, 1234}

i47 : Bag {100!}

o47 = {*a bagged integer*}

o47 : Bag

i48 : peek oo

o48 = Bag{9332621544394415268169923885626670049071596826438162146859296389521
      -----------------------------------------------------------------------
      75999932299156089414639761565182862536979208272237582511852109168640000
      -----------------------------------------------------------------------
      00000000000000000000}

i49 : showStructure(List,Sequence,Array,Container,MutableList,Bag,BasicList)

o49 = Thing : BasicList : Container
                          MutableList : Bag
                          VisibleList : Array
                                        List
                                        Sequence

o49 : Descent

i50 :