Support of algebraic operations on sets

Well, maybe its because i currently solving a problems where a set
operations on dictionaries is much more useful to me, so i tend to
state that they having much higher value than simple #= :)
Btw, using set operations we can simply implement equality for sets
(and dictionaries) as following:
Set>>= anObject
"two sets considered equal if their symmetric difference is an empty set"
^ (self difference: anObject) isEmpty and: [ (anObject difference:
self) isEmpty ]

Which is strictly based on mathematic laws and having zero chances to
be changed for the rest of the days. You might say its not optimal for
speed, but this is another story.

>
> Changing #do: is a major concern for me.  There is a huge amount of value to
> iteration over values and therefore we can predict a lot of people have used
> it in their code.  This form of iteration makes Dictionary consistent with
> Collection.  Again it is not consistent with Set operations but I don't see
> the value of set operations on dictionaries since only the keys are sets.  I
> don't see these relationships of keys to sets translating into dictionaries
> are sets.  We expect to find only one entry per index on a dictionary, but
> this is true of collections too.

1st: a current #do: is _NOT_ consistent with Collection, as i showed
before, following code will fail with dictionary:

elem := a -> b.
dict add: elem.
assert: [ dict includes: elem].

2nd: as Bert notes, Collections don't introduce index at all. There's
no #at: , #at:put: in Collection. Collections introducing basic
methods (like #do:) which used for iterating through all of its items,
which actually states that any collection must know how iterate
through own items, but there's nothing about how these items are
stored/accessed or how they are indexed.
And then, based on this method, we having a number of methods which
use this property of collection, like #includes: e.t.c.

If you can see, the changes need to make for Dictionary to make it
conform with what i proposing is much less to what you proposing. But
yes , the amount of code which uses old semantics is paramount.
So, its better to create a new class then, because adding new methods
in Dictionary does not solves problems, but just makes Dictionary
having even less consistent and dirty protocol(s).

>
> Come to think of it we could just implement the set operations as
> #shouldNotImplement and we can replace that functionality with the methods
> above.
>
> Dictionaries are widely used in Smalltalk, too much so in my opinion (I'm as
> guilty as anyone).  In many cases modeling your dictionary into proper
> objects eliminates a shortcut but provides greater clarity to your model.
>


> Happy coding!
>

> Date: Sat, 16 Jun 2007 14:53:14 +0300
> From: [hidden email]
> To: [hidden email]
> Subject: Re: Support of algebraic operations on dictionaries (was: ... sets)
>
> Another example of breaking protocol rules. Do you see any practical
> and good use in overriding #do: in Dictionary to iterate through list
> of values instead of associations by default? I don't. I'm serious.


Well, if one views a Dictionary as an Array type collection that just happens to use something other then numbers as the index, then one would expect #do: to operate on the values as it does with other indexable collections.

---

Make every IM count. Download Windows Live Messenger and join the i’m Initiative now. It’s free.  Make it count!

> Date: Sun, 17 Jun 2007 22:56:42 +0300
And this is place that traits can really help.  What would really be correct here is a trait called "Indexable" or similar that all indexable collections have.  Then we wouldn't have to have so many #shouldNotImplement messages. :)

---

Live Earth is coming.  Learn more about the hottest summer event - only on MSN. Check it out!