-- -*- M2-comint -*- hash: 250919098061662392

i1 : new Type of BasicList from Function := (A,B,f) -> hashTable { net => f, html => 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{html => f}
                  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 = FunctionClosure[stdio:11:25-14:41]

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 = FunctionClosure[stdio:21:17-21:33]

o18 : FunctionClosure

i19 : new M from (ZZ,ZZ) := (M',i,j) -> splice(i:0 .. j)

o19 = FunctionClosure[stdio:22:22-22:50]

o19 : FunctionClosure

i20 : n = new M from 13

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

o20 : M

i21 : - n

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

o21 : M

i22 : new M from (3,2)

o22 = M{0, 1, 2, 0, 1, 2, 0, 1, 2}

o22 : M

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

o23 = FunctionClosure[stdio:26:9-26:30]

o23 : FunctionClosure

i24 : new M

o24 = M{a, b, c}

o24 : M

i25 : 
