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

i1 : new Type of BasicList from Function := (A,B,f) -> hashTable { net => f };

i2 : f = s -> "--list of type X--"

o2 = f

o2 : FunctionClosure

i3 : X = new Type of List from f

o3 = X

o3 : Type

i4 : class X

o4 = Type

o4 : Type

i5 : parent X

o5 = List

o5 : Type

i6 : peek X

o6 = Type of List{net => f}

i7 : x = new X from {1,3,11,12}

o7 = --list of type X--

o7 : X

i8 : class x

o8 = X

o8 : Type

i9 : parent x

o9 = Nothing

o9 : Type

i10 : peek x

o10 = {1, 3, 11, 12}

i11 : new Type of BasicList := (type,array) -> (
                          stderr << "--new " << type << " of " 
                                 << array << " being made" << endl;
                          new MutableHashTable)

o11 = {*Function[stdio:11:38-14:24]*}

o11 : FunctionClosure

i12 : M = new Type of BasicList
--new Type of BasicList being made

o12 = M

o12 : Type

i13 : m = new M from {3,4,5}

o13 = M{3, 4, 5}

o13 : M

i14 : class m

o14 = M

o14 : Type

i15 : m#1

o15 = 4

i16 : - M := reverse

o16 = reverse

o16 : CompiledFunction

i17 : - m

o17 = M{5, 4, 3}

o17 : M

i18 : new M from ZZ := (M',i) -> 0 .. i

o18 = {*Function[stdio:21:24-21:32]*}

o18 : FunctionClosure

i19 : n = new M from 13

o19 = M{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}

o19 : M

i20 : - n

o20 = M{13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

o20 : M

i21 : new M := (M') -> {a,b,c}

o21 = {*Function[stdio:24:14-24:22]*}

o21 : FunctionClosure

i22 : new M

o22 = M{a, b, c}

o22 : M

i23 :