View source for User:NevilleDNZ/link list template

<lang algol68># BEGIN TEMPLATE #
  MODE LINKDATA = STRUCT(REF LINKDATA prev, next, DATA data);
  MODE REFDATA = UNION(REF LINKDATA, INT);
  MODE LISTDATA = STRUCT(INT lwb, upb, REF LINKDATA landing);
  MODE RETLIST = REF LISTDATA; # the list is not always req to be returned #
  MODE FIND = UNION(INT, VOID); # is EMPTY is nothing is found #

  MODE YIELDDATA = PROC(DATA)VOID;
  MODE GENDATA = PROC(YIELDDATA)VOID;

  MODE YIELDLINKDATA = PROC(REF LINKDATA)VOID;
  MODE GENLINKDATA = PROC(YIELDLINKDATA)VOID;

  MODE ITERDATA = UNION(LISTDATA, []DATA, GENDATA);
  MODE SLICE = STRUCT(UNION(INT, VOID) lwb, upb, by);

  MODE ARGS = FLEX[0]UNION(CHAR, STRING, BITS, BOOL, INT, REAL, COMPL);

  PROC raise index error = (ARGS args)VOID: (
    putf(stand error, ($"Index Error: "$, args, $l$));
    stop
  );

MODE CLASSLISTDATA = STRUCT(
  PROC (REF LISTDATA #self#)RETLIST new,
  PROC (REF LISTDATA #self#, ITERDATA #iter data#)RETLIST init,
  PROC (REF LISTDATA #self#, REFDATA #pos#)REF LINKDATA get link,
  PROC (REF LISTDATA #self#, REFDATA #pos#, DATA #data#)DATA set  item,
  PROC (REF LISTDATA #self#, SLICE #slice#)REF LISTDATA set slice,
  PROC (REF LISTDATA #self#, REFDATA #pos#)REF DATA get item,
  PROC (REF LISTDATA #self#, SLICE #slice#)LISTDATA get slice,
  PROC (REF LISTDATA #self#, SLICE #slice#)LISTDATA gen slice,
  PROC (REF LISTDATA #self#, REFDATA #pos#)VOID del item,
  PROC (REF LISTDATA #self#, SLICE #in slice#)VOID del slice,
  PROC (ITERDATA #iter#, YIELDDATA #yield#)VOID gen data, # merge with iter? #
  PROC (ITERDATA #iter#, YIELDDATA #yield#)VOID rgen data, # merge with reverse? #
  PROC (LISTDATA #list#, YIELDLINKDATA #yield#)VOID gen link,
  PROC (LISTDATA #list#, YIELDLINKDATA #yield#)VOID rgen link,
  PROC (REF LISTDATA #iter#, YIELDDATA #yield#)VOID iter,
  PROC (REF LISTDATA #self#, YIELDDATA #yield#)VOID reversed,
  PROC (REF LISTDATA #self#)RETLIST sort,
  PROC (REF LISTDATA #self#)RETLIST reverse,
  PROC (REF LISTDATA #self#)STRING repr,
  PROC (REF LISTDATA #self#, LISTDATA #other#)INT cmp,
  PROC (REF LISTDATA #self#, LISTDATA #other#)BOOL lt,
  PROC (REF LISTDATA #self#, LISTDATA #other#)BOOL le,
  PROC (REF LISTDATA #self#, LISTDATA #other#)BOOL eq,
  PROC (REF LISTDATA #self#, LISTDATA #other#)BOOL ne,
  PROC (REF LISTDATA #self#, LISTDATA #other#)BOOL ge,
  PROC (REF LISTDATA #self#, LISTDATA #other#)BOOL gt,
  PROC (REF LISTDATA #self#)INT len,
  PROC (REF LISTDATA #self#, DATA #data#)INT count,
  PROC (REF LISTDATA #self#, DATA #needle#)BOOL contains,
CO
  PROC (REF LISTDATA #self#, DATA #data#)INT index,
  PROC (REF LISTDATA #self#, DATA #data#)INT rindex,
END CO
  PROC (REF LISTDATA #self#, DATA #data#)FIND find,
  PROC (REF LISTDATA #self#, DATA #data#)FIND rfind,
  PROC (REF LISTDATA #self#, REFDATA #pos#, DATA #data#)RETLIST insert,
  CO PROC (REF LISTDATA #self#, ITERDATA #other#)RETLIST extend, CO
  PROC (REF LISTDATA #self#, LISTDATA #list#)RETLIST add,
  PROC (REF LISTDATA #self#, DATA #data#)RETLIST append,
  PROC (REF LISTDATA #self#, LISTDATA #list#)RETLIST plusab,
  PROC (REF LISTDATA #self#, INT #n#)RETLIST timesab,
  PROC (REF LISTDATA #self#, INT #n#)RETLIST times,
  PROC (REF LISTDATA #self#, INT #n#)RETLIST rtimes,
  PROC (REF LISTDATA #self#)DATA pop,
  PROC (REF LISTDATA #self#, DATA #data#)RETLIST minusab
);

CLASSLISTDATA class list data = (
# PROC new = # (REF LISTDATA self)RETLIST: SKIP, # ToDo #

# PROC init = # (REF LISTDATA self, ITERDATA iter data)RETLIST: (
    landing OF self := HEAP LINKDATA; # In C this could be part of the STRUCT #
    next OF landing OF self := prev OF landing OF self := landing OF self;
    # data OF landing OF self := NIL; CO leave as undefined to cause an exception #
    data OF landing OF self := (111,"Emergency");
    lwb OF self := 1;
    upb OF self := 0;
    CASE iter data IN
      ([]DATA array data): (
         lwb OF self := LWB array data;
         upb OF self := lwb OF self - 1;
         (init OF class list data)(self, (YIELDDATA yield)VOID:
           FOR key FROM LWB array data TO UPB array data DO
             yield(array data[key])
           OD
         )
      ),
      (LISTDATA list data): (
         print(("Creating list from list", new line))
      ),
      (GENDATA gen data): ( # Suspect #
      # FOR DATA data IN # gen data( # ) DO ( #
      ##   (DATA data)VOID: (
              (append OF class list data)(self, data)
           )
      # OD # )
      )
    ESAC;
    self
  ),

# link OF class list data is not in python #
# PROC get link = # (REF LISTDATA self, REFDATA pos)REF LINKDATA:
    CASE pos IN
      (REF LINKDATA pos): pos,
      (INT pos): (
        IF pos > upb OF self THEN raise index error(("get link OF class list data",pos,">",upb OF self)) FI;
        REF LINKDATA out;
        IF pos - lwb OF self < upb OF self - pos THEN
          INT count := lwb OF self;
        # FOR REF LINKDATA link IN # (gen link OF class list data)(self, # DO #
        ##   (REF LINKDATA link)VOID:
            IF count < pos THEN count +:=1 ELSE out := link; found FI
        # OD # );
          found: out
        ELSE
          INT count := upb OF self;
        # FOR REF LINKDATA link IN # (rgen link OF class list data)(self, # DO #
        ##   (REF LINKDATA link)VOID:
            IF count < pos THEN count -:=1 ELSE out := link; found FI
        # OD # );
          found: out
        FI
      )
      OUT SKIP
    ESAC,

# PROC set item = # (REF LISTDATA self, REFDATA pos, DATA data)DATA: (
    REF LINKDATA here := (get link OF class list data)(self, pos);
    IF here IS landing OF self THEN raise index error(("Attempt to set landing.")) FI;
    data OF here := data
  ),

# PROC set slice = # (REF LISTDATA self, SLICE slice)REF LISTDATA: SKIP, # ToDo #

# PROC get item = # (REF LISTDATA self, REFDATA pos)REF DATA: (
    REF LINKDATA here := (get link OF class list data)(self, pos);
    IF here IS landing OF self THEN raise index error(("Attempt to get landing.")) FI;
    data OF here
  ),

# PROC get slice = # (REF LISTDATA self, SLICE slice)LISTDATA: SKIP, # ToDo #
# PROC gen slice = # (REF LISTDATA self, SLICE slice)LISTDATA: SKIP, # ToDo #

# PROC del item = # (REF LISTDATA self, REFDATA pos)VOID: (
    REF LINKDATA here := (get link OF class list data)(self, pos);
    IF here IS landing OF self THEN raise index error(("Attempt to delete landing.")) FI;
    # print(("Deleting:", data OF prev OF here, data OF here, data OF next OF here, new line)); #
    next OF prev OF here := next OF here;
    prev OF next OF here := prev OF here;
    upb OF self -:= 1
  ),

# PROC del slice = # (REF LISTDATA self, SLICE in slice)VOID: (
    STRUCT(INT lwb, upb, by) slice = (
      (lwb OF in slice|(INT i):i, (VOID):lwb OF self),
      (upb OF in slice|(INT i):i, (VOID):upb OF self),
      (by  OF in slice|(INT i):i, (VOID):1)
    );
    REF LINKDATA here := (get link OF class list data)(self, lwb OF slice);
    FOR count FROM 0 TO upb OF slice - lwb OF slice DO # ToDo handle -ve by #
      REF LINKDATA next := next OF here;
      IF count MOD by OF slice = 0 THEN (del  item OF class list data)(self, here) FI;
      here := next
    OD;
    self
  ),

# PROC gen data = # (ITERDATA iter, YIELDDATA yield)VOID:
    CASE iter IN
      ([]DATA array data): (
         FOR key FROM LWB array data TO UPB array data DO
           print((key, "data:", array data[key], newline));
           yield(array data[key])
         OD
      ),
      (LISTDATA list data): (
      # FOR LINKDATA link data IN # (gen link OF class list data)(list data, # ) DO ( #
      ##   (REF LINKDATA link data)VOID:
           yield(data OF link data)
      # OD # )
      ),
      (GENDATA gen data): (
      # FOR DATA link IN # gen data( # ) DO ( #
      ##   (DATA data)VOID:
           yield(data)
      # OD # )
      )
    ESAC,

# PROC rgen data = # (ITERDATA iter, YIELDDATA yield)VOID:
    CASE iter IN
      ([]DATA array data): (
         FOR key FROM UPB array data BY -1 TO LWB array data DO
           print((key, "data:", array data[key], newline));
           yield(array data[key])
         OD
      ),
      (LISTDATA list data): (
      # FOR LINKDATA link data IN # (rgen link OF class list data)(list data, # ) DO ( #
      ##   (REF LINKDATA link data)VOID:
           yield(data OF link data)
      # OD # )
      ),
      (GENDATA rgen data): (
      # FOR DATA link IN # rgen data( # ) DO ( #
      ##   (DATA data)VOID:
           yield(data)
      # OD # )
      )
    ESAC,

# PROC gen link = # (LISTDATA list, YIELDLINKDATA yield)VOID: (
    REF LINKDATA link := landing OF list;
    WHILE
      link := next OF link;
    # WHILE # link ISNT landing OF list DO
      yield(link)
    OD
  ),

# PROC rgen link = # (LISTDATA list, YIELDLINKDATA yield)VOID: (
    REF LINKDATA link := landing OF list;
    WHILE
      link := prev OF link;
    # WHILE # link ISNT landing OF list DO
      yield(link)
    OD
  ),

# PROC iter = # (REF LISTDATA iter, YIELDDATA yield)VOID:
  # FOR LINKDATA link IN # (gen data OF class list data)(iter, # ) DO ( #
  ##   (DATA data)VOID: (
         yield(data)
       )
  # OD # ),

# PROC reversed = # (REF LISTDATA self, YIELDDATA yield)VOID:
  # FOR LINKDATA link IN # (rgen data OF class list data)(self, # ) DO ( #
  ##   (DATA data)VOID: (
         yield(data)
       )
  # OD # ),

# PROC sort = # (REF LISTDATA self)RETLIST: self, # ToDo #

# PROC reverse = # (REF LISTDATA self)RETLIST: (
    REF LINKDATA next := landing OF self;
    WHILE
      REF LINKDATA link := next;
 #    print((REPR data OF next, REPR data OF landing OF self, new line)); #
      next := next OF link;
      next OF link := prev OF link;
      prev OF link := next;
  # WHILE # next ISNT REF LINKDATA(landing OF self) DO
      SKIP
    OD;
    self
  ),

# PROC repr = # (REF LISTDATA self)STRING: (
    FILE f; STRING buf; associate(f, buf);
    putf(f,$"("$);
    STRING sep := "";
    INT i := lwb OF self;
  # FOR DATA data IN # (iter OF class list data)(self, # ) DO ( #
  ##   (DATA data)VOID: (
        # putf(f, ($g$, sep, $g(0)":"$, i)); #
        put(f, sep);
        putf(f, (data fmt, data));
        i +:= 1;
        sep := ", "
      )
  # OD # );
    putf(f, ($")"$));
    putf(f, ($"[@"g(0)$, lwb OF self, $":"g(0)$, upb OF self, $"]"$));
    close(f);
    buf
  ),

# Review: this could be generalisd to handle iterators #
# PROC cmp = # (REF LISTDATA self, LISTDATA other)INT: (
    LINKDATA link := landing OF other;
    # FOR DATA data IN # (gen data OF class list data)(self, # ) DO ( #
    ##   (DATA data)VOID: (
           link := next OF link;
           IF link IS landing OF other THEN short
           ELIF (data CMP data OF link) < 0 THEN negative
           ELIF (data CMP data OF link) > 0 THEN positive FI
         )
    # OD # );
    # review: where the lwb OF the link list #
    short: (upb OF self - lwb OF self) - (upb OF other - lwb OF other) EXIT
    negative: -1 EXIT
    positive:  1
  ),

# PROC lt = # (REF LISTDATA self, LISTDATA other)BOOL:
    (cmp OF class list data )(self, other) <= 0,

# PROC le = # (REF LISTDATA self, LISTDATA other)BOOL: 
    (cmp OF class list data )(self, other) < 0,

# PROC eq = # (REF LISTDATA self, LISTDATA other)BOOL: 
  IF lwb OF self /= lwb OF other OR lwb OF self /= lwb OF other THEN
    FALSE
  ELSE
    (cmp OF class list data )(self, other) = 0
  FI,

# PROC ne = # (REF LISTDATA self, LISTDATA other)BOOL: 
    NOT (eq OF class list data)(self, other),

# PROC ge = # (REF LISTDATA self, LISTDATA other)BOOL:
    (cmp OF class list data )(self, other) >= 0,

# PROC gt = # (REF LISTDATA self, LISTDATA other)BOOL:
    (cmp OF class list data )(self, other) >  0,

# PROC len = # (REF LISTDATA self)INT: upb OF self - lwb OF self + 1,

# PROC count = # (REF LISTDATA self, DATA needle)INT: (
    INT index := lwb OF self;
    INT count := 0;
  # FOR DATA straw IN # (iter OF class list data)(self, # ) DO ( #
  ##   (DATA straw)VOID:
       IF straw CMP needle = 0 THEN count +:= 1 FI
  # OD # );
    count
  ),

# PROC contains = # (REF LISTDATA self, DATA needle)BOOL:
  CASE (find OF class list data)(self, needle) IN (INT): TRUE OUT FALSE ESAC,

CO
# PROC index = # (REF LISTDATA self, DATA data)INT: # fix: case when lwb=-max int fails #
  CASE (find OF class list data)(self, data) IN (INT n):n OUT lwb OF self - 1 ESAC,

# PROC rindex = # (REF LISTDATA self, DATA data)INT: 
  CASE (rfind OF class list data)(self, data) IN (INT n):n OUT lwb OF self - 1 ESAC,
END CO

# PROC find = # (REF LISTDATA self, DATA needle)FIND: (
    INT index := lwb OF self;
  # FOR DATA straw IN # (iter OF class list data)(self, # ) DO ( #
  ##   (DATA straw)VOID:
       IF straw CMP needle = 0 THEN index exit FI
  # OD # );
    EMPTY EXIT
    index exit: index
  ),

# PROC rfind = # (REF LISTDATA self, DATA needle)FIND: (
  INT index := upb OF self;
  # FOR DATA straw IN # (reversed OF class list data)(self, # ) DO ( #
  ##   (DATA straw)VOID:
       IF straw CMP needle = 0 THEN index exit FI
  # OD # );
    EMPTY EXIT
    index exit: index
  ),

# PROC insert = # (REF LISTDATA self, REFDATA pos, DATA data)RETLIST: (
    REF LINKDATA here := (get link OF class list data)(self, pos);
# prepare the new #
    HEAP LINKDATA new := (prev OF here, here, data);
# insert the new #
    prev OF next OF new := next OF prev OF here := new;
    upb OF self +:= 1;
    self
  ),

CO # here are the equivalent python operators #
Algol68     Python
+:=         +=        ['a', 'b', 'c', 'd', 'e', 't', 'c'] join lists
PLUSAB      __iadd__  ['a', 'b', 'c', 'd', 'e', 't', 'c'] join lists
+           +         ['a', 'b', 'c', 'd', 'e', 't', 'c'] join lists
+           __add__   ['a', 'b', 'c', 'd'] # as per +     join lists #
+:=         extend    ['a', 'b', 'c', 'd', 'e', 't', 'c'] join lists
+:=         append    ['a', 'b', 'c', 'd', ['e', 't', 'c']] add element
[n/a]       insert    ['a', 'b', 'c', ['e', 't', 'c'], 'd'] insert element
s in s      in, find, index
[n/a]       in, rfind, rindex
+=: PLUSTO  [n/a] insert(0)
-:= MINUSAB [n/a] remove
-=: MINUSTO [n/a] rremove
*:= TIMESAB [n/a]

Key string attributes:
  __contains__ count find index rfind rindex __len__ 
  __getitem__ __getslice__ 
  __add__ __mod__ __mul__ __rmul__ __rmod__ 
  join replace startswith endswith

Key python dict attribytes:
  __cmp__ __contains__ has_key __len__ 
  __setitem__ __getitem__ __delitem__ get pop popitem 
  __iter__ keys values items iterkeys itervalues iteritems 
  clear copy fromkeys
  setdefault update 
END CO

CO
# extend is the same as plusab, save plusab creates the op +:= #
# PROC extend = # (REF LISTDATA self, ITERDATA other)RETLIST: (
    # FOR DATA data IN # (gen data OF class list data)(other, # ) DO ( #
    ##   (DATA data)VOID:
         (plusab OF class list data)(self, data)
    # OD #);
    self
  ),
END CO

# PROC add = # (REF LISTDATA self, LISTDATA list)RETLIST: (
    REF LISTDATA out = INIT HEAP LISTDATA; 
    (plusab OF class list data)(out, self);
    (plusab OF class list data)(out, list)
  ),

# PROC append = # (REF LISTDATA self, DATA data)RETLIST:
    (insert OF class list data)(self, landing OF self, data),

# PROC plusab = # (REF LISTDATA self, LISTDATA list)RETLIST: (
# warning: x += x currently fails #
  # FOR DATA data IN # (iter OF class list data)(LOC LISTDATA := list, # ) DO ( #
  ##   (DATA data)VOID:
       (append OF class list data)(self, data)
  # OD #);
      self
  ),

# PROC timesab = # (REF LISTDATA self, INT n)RETLIST: (
    TO n DO # fix: this doubles list length #
      (plusab OF class list data)(self, self) # !!! #
    OD;
    self
  ),

# PROC times = # (REF LISTDATA self, INT n)RETLIST: SKIP,     # * ToDo #
# PROC rtimes = # (REF LISTDATA self, INT n)RETLIST: SKIP,     # b * a  ToDo #

# PROC pop = # (REF LISTDATA self)DATA: (
    DATA out = upb OF self ELEM self;
    (del item OF class list data)(self, upb OF self);
    out
  ),

# PROC minusab = # (REF LISTDATA self, DATA data)RETLIST: SKIP

);

PRIO INIT = 1;

OP INIT = (REF LISTDATA list)REF LISTDATA:
  (init OF class list data)(list,  LOC[0]DATA);

OP INIT = (REF LISTDATA list, []DATA array)REF LISTDATA: 
  (init OF class list data)(list,  array);

OP INIT = (REF LISTDATA list, GENDATA gen)REF LISTDATA: SKIP;

OP LWB = (LISTDATA list)INT: lwb OF list;
OP UPB = (LISTDATA list)INT: upb OF list;
OP LEN = (LISTDATA list)INT: UPB list - LWB list + 1;
#ToDo:  ⌊, ⌈ #

OP ELEM  = (INT key, LISTDATA list)REF DATA: (get item OF class list data)(LOC LISTDATA := list, key);
OP ELEM  = (LISTDATA list, SLICE key)ITERDATA: SKIP; # ToDo #
OP ELEM  = (LISTDATA list, DATA data)REF DATA: SKIP; # ToDo #
# ToDo: □ #

CO OP -  = (LISTDATA list)LISTDATA: (reversed OF class list data)(LOC LISTDATA := list, SKIP); # review #  CO

OP +  = (LISTDATA list, DATA data)LISTDATA: SKIP; # ToDo #
OP -  = (LISTDATA list, DATA data)LISTDATA: SKIP; # ToDo #
OP *  = (LISTDATA list, INT n)LISTDATA: (times OF class list data)(LOC LISTDATA := list, n);
OP *  = (INT n, LISTDATA list)LISTDATA: (rtimes OF class list data)(LOC LISTDATA := list, n);
OP +:=  = (REF LISTDATA list, DATA data)REF LISTDATA: (append OF class list data)(list, data);
OP +=:  = (DATA data, REF LISTDATA list, INT n)LISTDATA: SKIP; # ToDo #
OP +:=  = (REF LISTDATA list, LISTDATA iter)REF LISTDATA: (plusab OF class list data)(list, iter);
OP +=:  = (LISTDATA iter, REF LISTDATA list)LISTDATA: SKIP; # ToDo, prepend #
CO candidate...
OP +:=  = (REF LISTDATA list, ITERDATA iter)REF LISTDATA: (plusab OF class list data)(list, iter);
OP +=:  = (ITERDATA list, REF LISTDATA list, INT n)LISTDATA: SKIP; # ToDo, prepend #
END CO
PRIO *=: = 1, -=: = 1;
OP -:=  = (REF LISTDATA list, DATA data)LISTDATA: (minusab OF class list data)(LOC LISTDATA := list, data);
CO OP -=:  = (REF LISTDATA list, DATA data)LISTDATA: (minusto OF class list data)(LOC LISTDATA := list, data); review LIST and ITER CO
OP *:=  = (REF LISTDATA list, INT n)RETLIST: SKIP; # ToDo #
# ToDo: PLUSAB, PLUSTO, MINUSAB, TIMESAB, ×, ×:= #

OP CMP = (LISTDATA list, LISTDATA other)INT: (cmp OF class list data)(LOC LISTDATA := list, other);

OP <  = (LISTDATA a,b)BOOL: a CMP b <  0,
   <= = (LISTDATA a,b)BOOL: a CMP b <= 0,
    = = (LISTDATA a,b)BOOL: a CMP b  = 0,
   /= = (LISTDATA a,b)BOOL: a CMP b /= 0,
   >= = (LISTDATA a,b)BOOL: a CMP b >= 0,
   >  = (LISTDATA a,b)BOOL: a CMP b >  0;

# ToDo: LT, LE, EQ, NE, GE, GT, ≤, ≥, ≠ #

OP REPR = (LISTDATA list)STRING: (repr OF class list data)(LOC LISTDATA := list);</lang>

Test:
<lang algol68>MODE DATA = STRUCT(INT i, STRING s);
FORMAT data fmt = $"("g(0)","""g""")"$;

PRIO CMP = 5; 
OP CMP = (DATA a,b)INT: i OF a - i OF b;

PR READ "linked_list.a68" PR

OP <  = (DATA a,b)BOOL: a CMP b <  0,
   <= = (DATA a,b)BOOL: a CMP b <= 0,
    = = (DATA a,b)BOOL: a CMP b  = 0,
   /= = (DATA a,b)BOOL: a CMP b /= 0,
   >= = (DATA a,b)BOOL: a CMP b >= 0,
   >  = (DATA a,b)BOOL: a CMP b >  0;

OP REPR = (DATA data)STRING: (FILE f; STRING buf; associate(f, buf); putf(f, (data fmt, data)); close(f); buf);
PROC dump list = (STRING prefix, REF LISTDATA list)VOID: print((prefix,"=", REPR list,";", new line));

test:(
  []DATA data = (
    (1,"Was"),(2,"it"),(3,"a"),(4,"cat"),(5,"I"),(6,"saw"),
    (7,"Was"),(8,"it"),(9,"a"),(10,"cat"),(11,"I"),(12,"saw")
  );
  REF LISTDATA list := LOC LISTDATA INIT data;
  REF LISTDATA listb := LOC LISTDATA INIT data;

  dump list("test a",list);

  (del item OF class list data)(list,2);
  dump list("test b",list);

  (del slice OF class list data)(list, SLICE((2,EMPTY,2)));
  dump list("test del slice",list);

  (set item OF class list data)(list, 3, (666,"Satan"));
  dump list("test del 3",list);

  print((REPR(3 ELEM list), new line));
  (3 ELEM list) := (888,"Saint");
  print((REPR(3 ELEM list), new line));
  dump list("test elem 3", list);

  (reverse OF class list data)(list);
  dump list("test reverse", list);

#  dump list("test f", LOC LISTDATA INIT reversed OF class list data) #
  print(("Compare self:", list = list, new line));
  print(("Compare b:", list = listb, new line));
  SKIP
)</lang>
Output:
<pre>
test a=((1,"Was"), (2,"it"), (3,"a"), (4,"cat"), (5,"I"), (6,"saw"), (7,"Was"), (8,"it"), (9,"a"), (10,"cat"), (11,"I"), (12,"saw"))[@1:12];
test b=((1,"Was"), (3,"a"), (4,"cat"), (5,"I"), (6,"saw"), (7,"Was"), (8,"it"), (9,"a"), (10,"cat"), (11,"I"), (12,"saw"))[@1:11];
test del slice=((1,"Was"), (4,"cat"), (6,"saw"), (8,"it"), (10,"cat"), (12,"saw"))[@1:6];
test del 3=((1,"Was"), (4,"cat"), (666,"Satan"), (8,"it"), (10,"cat"), (12,"saw"))[@1:6];
(666,"Satan")
(888,"Saint")
test elem 3=((1,"Was"), (4,"cat"), (888,"Saint"), (8,"it"), (10,"cat"), (12,"saw"))[@1:6];
test reverse=((12,"saw"), (10,"cat"), (8,"it"), (888,"Saint"), (4,"cat"), (1,"Was"))[@1:6];
Compare self:T
Compare b:F
</pre>