I think we are on the right track but it needs a little tweaking:
t=.table~of(("adam","male"), ("berta","female"), ("caesar","male") )
sayt~class":"
dowithindexiitemoovert
say"#"i":"pp(o)
end
say
say"--- the desired output:"
i=1
dowithindexidxitemoovert
say"#"i":"pp(idx) "->"pp(o)
i=i+1
end
say
say"--- how about this?"
dowithindexiitemidxovert~allindexes~supplier
say"#"i":"pp(idx) "->"pp(t[idx])
end
say
::routinepp
return"["arg(1)"]"
Gil B
-----------------------------------------------------------------------------------------------------------
On 2/20/2019 8:06 AM, Rony G. Flatscher wrote:
On 20.02.2019 07:06, Erich Steinböck wrote:
number a do with over a table where the indices are not numbers,
or over a set or bag
Use
do with index i item j over c~allItems
This is *not* the same collection as "c", but an array of all of the
items in the "c" MapCollection! The important information of which
index is associated with which item gets lost.
The "do with...over" is meant to iterate over a supplier which is
especially important for non-orderable collections.
In the case of Map/SetCollections the index object is as important as
the item object, such that it cannot be forgone. (The supplier is the
only means for Map/SetCollections to get all index-item-pairs, cf.
e.g. for .Relation collections.)
-----------------------
One may be inclined to think that "do with...over" is fine for
Orderable collections as array collections demonstrate:
a=("a","z","b")
say a~class":"
do with index i item o over a
say "#" i":" pp(o)
end
say
l=.list~of("a","y","b")
say l~class":"
do with index i item o over l
say "#" i":" pp(o)
end
say
::routine pp
return "["arg(1)"]"
---------------------------------------------------------------------------
G:\test\oorexx\201902doover>test_do_over.rex
The Array class:
# 1: [a]
# 2: [z]
# 3: [b]
The List class:
# 0: [a]
# 1: [y]
# 2: [b]
However the index value starting out with 0 in the List collection
case! The expected output in the case of the List class probably would
have been:
The List class:
# 1: [a]
# 2: [y]
# 3: [b]
However, as one can see the List does not have a numeric index that
start with 1, like it is the case with Array collections.
In the case of an Orderable collection only the "allitems" array will
allow for using the index for numbering, starting with one (because an
array always starts with 1):
l=.list~of("a","y","b")
say l~class":"
do with index i item o over l~allItems
say "#" i":" pp(o)
end
say
::routine pp
return "["arg(1)"]"
---------------------------------------------------------------------------
G:\test\oorexx\201902doover>test_do_over.rex
The List class:
# 1: [a]
# 2: [y]
# 3: [b]
=====================================
Using allItems or allIndexes would not help in the case of
Map/SetCollections, where the index object is as important as the item
object.
Example with a Table collection:
t=.table~of(("adam","male"), ("berta","female"), ("caesar","male") )
say t~class":"
do with index i item o over t
say "#" i":" pp(o)
end
say
say "--- now with t~allItems:"
do with index i item o over t~allItems
say "#" i":" pp(o)
end
say
say "--- now with t~allIndexes:"
do with index i item o over t~allIndexes
say "#" i":" pp(o)
end
say
say "--- the desired output:"
i=1
do with index idx item o over t
say "#" i":" pp(idx) "->" pp(o)
i=i+1
end
say
::routine pp
return "["arg(1)"]"
Yielding:
The Table class:
# berta: [female]
# caesar: [male]
# adam: [male]
--- now with t~allItems:
# 1: [female]
# 2: [male]
# 3: [male]
--- now with t~allIndexes:
# 1: [berta]
# 2: [caesar]
# 3: [adam]
--- the desired output:
# 1: [berta] -> [female]
# 2: [caesar] -> [male]
# 3: [adam] -> [male]
------------------------------------------------
Example of a relation (index is a human, item a child of that human; a
human may have more than one child):
r=.relation~of(("adam","henry"), ("adam","julia"), ("berta","julia"), ("caesar","denise"),
("caesar","mark") )
say r~class":"
do with index i item o over r
say "#" i":" pp(o)
end
say
say "--- now with t~allItems:"
do with index i item o over r~allItems
say "#" i":" pp(o)
end
say
say "--- now with t~allIndexes:"
do with index i item o over r~allIndexes
say "#" i":" pp(o)
end
say
say "--- the desired output:"
i=1
do with index idx item o over r
say "#" i":" pp(idx) "->" pp(o)
i=i+1
end
say
::routine pp
return "["arg(1)"]"
Yielding:
The Relation class:
# caesar: [mark]
# caesar: [denise]
# berta: [julia]
# adam: [julia]
# adam: [henry]
--- now with t~allItems:
# 1: [mark]
# 2: [denise]
# 3: [julia]
# 4: [julia]
# 5: [henry]
--- now with t~allIndexes:
# 1: [caesar]
# 2: [caesar]
# 3: [berta]
# 4: [adam]
# 5: [adam]
--- the desired output:
# 1: [caesar] -> [mark]
# 2: [caesar] -> [denise]
# 3: [berta] -> [julia]
# 4: [adam] -> [julia]
# 5: [adam] -> [henry]
Having a "counter" subkeyword would allow numbering without the need
to know the kind of collection that is being iterated. E.g.
List example:
l=.list~of("a","y","b")
say l~class":"
do with index idx item o over l counter i
say "#" i":" pp (idx) "->" pp(o)
end
--- yielding:
# 1: [0] -> [a]
# 2: [1] -> [y]
# 3: [2] -> [b]
Table example:
t=.table~of(("adam","male"), ("berta","female"), ("caesar","male") )
say t~class":"
do with index idx item o over t counter i
say "#" i":" pp(idx) "->" pp(o)
i=i+1
end
--- yielding:
# 1: [berta] -> [female]
# 2: [caesar] -> [male]
# 3: [adam] -> [male]
or
Relation example:
r=.relation~of(("adam","henry"), ("adam","julia"), ("berta","julia"), ("caesar","denise"),
("caesar","mark") )
say r~class":"
do with index idx item o over r counter i
say "#" i":" pp(idx) "->" pp(o)
end
--- yielding:
# 1: [caesar] -> [mark]
# 2: [caesar] -> [denise]
# 3: [berta] -> [julia]
# 4: [adam] -> [julia]
# 5: [adam] -> [henry]
---rony
_______________________________________________
Oorexx-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/oorexx-devel
--
Gil Barmwater
_______________________________________________
Oorexx-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/oorexx-devel
