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:
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