Just opened a RFE <https://sourceforge.net/p/oorexx/feature-requests/743/>
after studying the
current DO-keyword syntax.
---rony
On 20.02.2019 16:11, Gil Barmwater wrote:
>
> Just another couple of points:
>
> 1) the ~supplier message is not needed; ooRexx will "supply" it
>
> 2) in the case of relation collections, the [] method will return the first
> item with the
> specified index so relation collections with duplicate indices would need
> different handling
> (thanks Rony for pointing that out to me off-list)
>
> Gil
>
> On 2/20/2019 9:18 AM, Gil Barmwater wrote:
>>
>> 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
