You aren't seeing a difference because you're using the same set of objects.  for your indexes.  Here is a simple example that will show the difference.

```i1 = "abc"
i2 = "ab"||"c"

table = .table~new
itable = .identitytable~new

table[i1] = "Walter"
table[i2] = "Pachl"

say table~items   -- 1 item
say table[i1] table[i2] -- "Pachl Pachl"

itable[i1] = "Walter"
itable[i2] = "Pachl"

say itable~items   -- 2 items
say itable[i1] itable[i2] -- "Walter Pachl"
```
With a table, both i1 and i2 are the same index because the two objects compare equal.  With an identitytable, i1 and i2 are NOT the same index because they are different objects.  For most purposes, a table is sufficient for the job.  There are some advanced uses, however, where the distinction is important.  You really need to have a better understanding of what objects are before I attempt to explain those uses.

Rick

On Fri, Sep 21, 2012 at 2:10 PM, Walter Pachl wrote:
Can someone tell me why I cannot find a difference?
I read and compared carefully sections 5.3.16 and 17.
Pls find my observations (and change suggestions) at the end ot this.
Would it be better to report that as a doc bug (?)

Thanks for your understanding
Walter

/* REXX ***************************************************************
* Trying to demonstrate the difference between table and identitytable
* 21.09.2012 Walter Pachl
**********************************************************************/
Select
When arg(1)='?' Then Do
Say 'rexx testtab <I> tests table vs. identitytable'
Say 'What must be changed to see a difference?'
Say 'I expected the indexes c and cc to make a difference'
Say 'what''s the difference between == and object identity??'
Exit
End
When arg(1)='I' Then Do
Say 'Test with identitytable'
tab=.identitytable~new /* create a new identity                 */
End
Otherwise Do
Say 'Test with identitytable'
tab=.table~new    /* create a new table                          */
End
End
Call create_objects
tab[1]=a              /* fill first table entry                      */
tab["two"]=b          /* index can be any object                     */
tab~put(e,c)          /* put method is synonymous with []=           */
cc=c~copy
Say 'c: '  c~identityHash
Say 'cc:' cc~identityHash
tab[four]=d           /* four = FOUR                                 */
Call show_tab 1
tab~put(e,cc)         /* put method is synonymous with []=           */
If cc==c  Then Say 'cc and c are =='
If cc\==c Then Say 'cc and c are \=='
Call show_tab 2
Exit

show_tab:
Say 'show_tab' arg(1)
Say tab~items 'items'
xlist=tab~allindexes  /* puts all indexes into array xlist         */
Do item over xlist    /* loop over array and show elements         */
Say item            /* -> 1                                      */
End
ilist=tab~allitems    /* puts all items into array ilist           */
i=0
Do item over ilist    /* loop over array and show elements         */
Say item~show       /* ->     1 Adam Ants       1000             */
End
Return

create_objects:       /* ->                                          */
a=.payroll~new(1,'Adam Ants',1000) /* create a payroll entry         */
b=.payroll~new(2,'Barry Bee',2000) /* create a payroll entry         */
c=.payroll~new(3,'Charly Ce',3000) /* create a payroll entry         */
d=.payroll~new(4,'Donald Duck',4000) /* create a payroll entry       */
e=.payroll~new(5,'Eva Ericson',5000) /* create a payroll entry       */
f=.payroll~new(6,'Fred Feuerstein',6000) /* create a payroll entry       */
Return
::class payroll public
::attribute persnr                 /* variables of payroll's objects */
::attribute name
::attribute salary
::method init                      /* initialize the object          */
expose persnr name salary        /* get access to payroll's objects*/
parse arg persnr, name, salary   /* assign parameters to variables */
::method show                      /* show the payroll data          */
expose persnr name salary
Return right(persnr,5) left(name,15) salary

rexxref.pdf observations (Output of my 'famous' COMPAT program
(after massaging the texts)

table.txt
identitytable.txt

OLD-> 5.3.16. The Table Class
OLD-> A table is a collection with indexes that can be any object.
OLD-> In a table, each item is associated with a single index,
OLD-> and there can be only one item for each index
OLD-> (unlike a relation, which can contain more than one item with the same index).
OLD-> Index equality is determined by using the == method.
add ... and item equality ???
OLD-> Note: The Table class also has available class methods that its metaclass,

NEW-> 5.3.17. The IdentityTable Class
NEW-> An identity table is a collection with indexes that can be any object.
NEW-> In an identity table, each item is associated with a single index,
NEW-> and there can be only one item for each index.
NEW-> Index and item matches in an identity table are made using an object identity comparison.
NEW-> That is, an index will only match if the same instance is used in the collection.
NEW-> Note: The IdentityTable class also has available class methods that its metaclass,

the Class class, defines. It also inherits methods from the Map Collection class.
5.3.16.1. Inherited Methods
Methods inherited from the Object class.
new (class method) instanceMethod send
= \= == \== <> >< instanceMethods sendWith
class isA setMethod
copy isInstanceOf start
defaultName objectName startWith
hasMethod objectName= string
identityHash Request unsetMethod
init Run
Methods inherited from the Collection class.
[] hasIndex put
[]= hasItem subset
allIndexes index supplier
allItems intersection union
at items xor
difference makeArray
Methods inherited from the MapCollection class.
putAll
5.3.16.2. new (Class Method)
>>-new---------------------------------------------------------><

OLD-> Returns an empty Table object.
NEW-> Returns an empty IdentityTable object.

5.3.16.3. []
>>-[index]-----------------------------------------------------><
Returns the item associated with index. This is the same as the at() method.
5.3.16.4. []=
>>-[index]=item------------------------------------------------><
Adds item to the table at index index. This method is the same as the put() method.
5.3.16.5. allIndexes
>>-allIndexes--------------------------------------------------><

OLD-> Returns an array of all indexes contained in the table.
NEW-> Returns an array of all indices contained in the table.
???????
5.3.16.6. allItems

>>-allItems----------------------------------------------------><
Returns an array of all items contained in the table.
5.3.16.7. at
>>-at(index)---------------------------------------------------><
Returns the item associated with index index.
Returns the Nil object if the collection has no item associated with index.
5.3.16.8. empty
>>-empty-------------------------------------------------------><
Removes all items from the table.
5.3.16.9. hasIndex
>>-hasIndex(index)---------------------------------------------><
Returns 1 (true) if the collection contains any item associated with index index, or 0 (false).
5.3.16.10. hasItem

OLD-> >>-hasItem(value)----------------------------------------------><
OLD-> Returns 1 (true) if the collection contains the value at any index position

NEW-> >>-hasItem(item)-----------------------------------------------><
NEW-> Returns 1 (true) if the collection contains the item at any index position

why different (item vs. value)???

or otherwise returns 0 (false).

DEL-> Item equality is determined by using the == method of item.

5.3.16.11. index
>>-index(item)-------------------------------------------------><
Returns the index of the specified item within the table.
If the target item appears at more than one index, the first located index will be returned.
Returns the Nil object if the table does not contain the specified item.

DEL-> Item equality is determined by using the == method of item.

5.3.16.12. isEmpty
>>-isEmpty-----------------------------------------------------><
Returns 1 (true) if the table is empty. Returns 0 (false) otherwise.
5.3.16.13. items
>>-items-------------------------------------------------------><
Returns the number of items in the collection.
5.3.16.14. makeArray
>>-makeArray---------------------------------------------------><
Returns a single-index array containing the index objects.
The array indexes range from 1 to the number of items.
The collection items appear in the array in an unspecified order.
5.3.16.15. put
>>-put(item,index)---------------------------------------------><
Makes the object item a member item of the collection and associates it with index index.
The new item replaces any existing items associated with index index.
5.3.16.16. remove
>>-remove(index)-----------------------------------------------><

OLD-> Returns and removes the table item with index index.
NEW-> Returns and removes from a collection the member item with index index.

???????????? the identitytable

Returns the Nil object if no item has index index.

5.3.16.17. removeItem
>>-removeItem(item)--------------------------------------------><
Removes an item from the table. If the target item exists at more than one index,
the first located item is removed. The return value is the removed item.

DEL-> Item equality is determined by using the == method of item.

5.3.16.18. supplier
>>-supplier----------------------------------------------------><
Returns a Supplier object for the collection.
The supplier allows you iterate over the index/item pairs
contained in the table at the time the supplier was created.
The supplier iterates over the items in an unspecified order.
-----------------------
3 Deletions
12 Changes
0 Insertions
78 unchanged lines.
-----------------------

------------------------------------------------------------------------------
Got visibility?
Most devs has no idea what their production app looks like.
Find out how fast your code is with AppDynamics Lite.
http://ad.doubleclick.net/clk;262219671;13503038;y?
http://info.appdynamics.com/FreeJavaPerformanceDownload.html
_______________________________________________
Oorexx-devel mailing list
Oorexx-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/oorexx-devel