User:NevilleDNZ/link list template

From Rosetta Code

<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 = (

  1. PROC new = # (REF LISTDATA self)RETLIST: SKIP, # ToDo #
  1. 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
 ),
  1. link OF class list data is not in python #
  2. 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,
  1. 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
 ),
  1. PROC set slice = # (REF LISTDATA self, SLICE slice)REF LISTDATA: SKIP, # ToDo #
  1. 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
 ),
  1. PROC get slice = # (REF LISTDATA self, SLICE slice)LISTDATA: SKIP, # ToDo #
  2. PROC gen slice = # (REF LISTDATA self, SLICE slice)LISTDATA: SKIP, # ToDo #
  1. 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
 ),
  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
 ),
  1. 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,
  1. 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,
  1. 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
 ),
  1. 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
 ),
  1. 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 # ),
  1. 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 # ),
  1. PROC sort = # (REF LISTDATA self)RETLIST: self, # ToDo #
  1. 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
 ),
  1. 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
 ),
  1. Review: this could be generalisd to handle iterators #
  2. 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
 ),
  1. PROC lt = # (REF LISTDATA self, LISTDATA other)BOOL:
   (cmp OF class list data )(self, other) <= 0,
  1. PROC le = # (REF LISTDATA self, LISTDATA other)BOOL:
   (cmp OF class list data )(self, other) < 0,
  1. 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,
  1. PROC ne = # (REF LISTDATA self, LISTDATA other)BOOL:
   NOT (eq OF class list data)(self, other),
  1. PROC ge = # (REF LISTDATA self, LISTDATA other)BOOL:
   (cmp OF class list data )(self, other) >= 0,
  1. PROC gt = # (REF LISTDATA self, LISTDATA other)BOOL:
   (cmp OF class list data )(self, other) >  0,
  1. PROC len = # (REF LISTDATA self)INT: upb OF self - lwb OF self + 1,
  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
 ),
  1. PROC contains = # (REF LISTDATA self, DATA needle)BOOL:
 CASE (find OF class list data)(self, needle) IN (INT): TRUE OUT FALSE ESAC,

CO

  1. 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,
  1. 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

  1. 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
 ),
  1. 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
 ),
  1. PROC insert = # (REF LISTDATA self, REFDATA pos, DATA data)RETLIST: (
   REF LINKDATA here := (get link OF class list data)(self, pos);
  1. prepare the new #
   HEAP LINKDATA new := (prev OF here, here, data);
  1. 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

  1. extend is the same as plusab, save plusab creates the op +:= #
  2. 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

  1. 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)
 ),
  1. PROC append = # (REF LISTDATA self, DATA data)RETLIST:
   (insert OF class list data)(self, landing OF self, data),
  1. PROC plusab = # (REF LISTDATA self, LISTDATA list)RETLIST: (
  2. 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
 ),
  1. 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
 ),
  1. PROC times = # (REF LISTDATA self, INT n)RETLIST: SKIP, # * ToDo #
  2. PROC rtimes = # (REF LISTDATA self, INT n)RETLIST: SKIP, # b * a ToDo #
  1. PROC pop = # (REF LISTDATA self)DATA: (
   DATA out = upb OF self ELEM self;
   (del item OF class list data)(self, upb OF self);
   out
 ),
  1. 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;

  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 #

  1. 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 #

  1. 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;
  1. 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);
  1. 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: 

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
Retrieved from "https://rosettacode.org/wiki/User:NevilleDNZ/link_list_template?oldid=154901"