Hi Stef.
I present ;-) -
{} - The argument from simplicity.
I expect things in Squeak to dynamicly calculated, unless explicitly
cached or immutable.
#() is in violation of that. That's forgivable only because it's usually
not changed, and filled with immutables - and we do need those often.
A syntax is by definition a bunch of patterns that specially handled, I
measure a good syntax by getting good expressiveness with few surprises.
Theoretically, I'd prefer to see a Smalltalk with no #(), than a
Smalltalk with no {}, because {} gives more bang for the buck. Only
reason I see to keep #() (and I may be forgetting something here) is
speed.
Fact is, we also very often need less restricted bunches of stuff to
start a calculation out, and you should have a reasonable syntax to do
it.
So, Stef, a challenge -
Provide some alternative, that doesn't make this code look stuffy.
Because it's sure doesn't belong in a suit... ;-)
Bag new addAll: ((1 to: 5) collect: [:e | Ball colored: {Color white.
Color blue. Color red} atRandom])
Daniel
P.S. - come to think about it, what if we do dump #(), use {}, and just
cache where we need the speed? How bad would that be?
"David N. Smith (IBM)" <dnsmith(a)watson.ibm.com> wrote:
> Stef:
>
> But......
> I use it all the time. It's a neat idea. Here is code I found by searching all source for #{.
>
> EToyIncommingMessages class>>allTypes
>
> ^MessageTypes ifNil: [
> MessageTypes _ {
> self typeKeyboardChat.
> self typeMorph.
> self typeFridge.
> self typeStatusRequest.
> self typeStatusReply.
> self typeSeeDesktop.
> self typeAudioChat.
> self typeAudioChatContinuous.
> self typeMultiChat. } ]
>
> HeadMorph>>addSpikyHair
> | hair |
> hair _ PolygonMorph
> vertices: {83@3. 81@30. 91@27. 111@23. 97@32. 112@37. 99@45. 114@52. 95@53. 55@43. 10@50. 1@40. 14@40. 8@26. 24@37. 15@11. 29@29. 30@16. 36@30. 41@6. 49@31. 54@8. 61@32. 64@1. 70@27}
>
>
> Next is a fragment of a demo. The names Babble, Donut and Marble are humorous, but descriptive.
>
> d := BabbleDonutMorph new largeDonut; name: '- Commons Area -'.
> d addAllMarbles: {
> (BabbleMarbleMorph new mediumMarble name: 'Wendy').
> (BabbleMarbleMorph new mediumMarble name: 'Dave and Archie at home').
> (BabbleMarbleMorph new mediumMarble name: 'Tom in Minneapolis').
> (BabbleMarbleMorph new mediumMarble name: 'Mark').
> (BabbleMarbleMorph new mediumMarble name: 'Big Screen').
> (BabbleMarbleMorph new mediumMarble name: 'John in the Lab') } shuffled.
>
>
> These are just a few examples I picked to show 'interesting' uses of { and }. I found 794 methods in my image that contained at least one ${. A few were commented out C code. Most were from the array constructor. It's used widely and the result of using it makes the code much more readable than 'Array with:'.
>
> The construct is useful and widely used. If it has definitional and theoretical problems, then certainly look at how to fix those; but let's not discard a useful construct.
>
>
> At 8:49 +0200 9/30/01, ducasse stephane wrote:
> >Hi daniel
> >
> >I send it into the mailing list too becuase this is important
> >
> >From a language design perspective
> >
> >#() is necessary because it is compiled statically and cannot not be
> >simulated by other construct. Storing #() in Stack frame is not really goo
> >but this is an implementation aspect.
>
> I don't think this is true at all. #() holds symbols, strings, characters numbers, and in some Smalltalk systems it holds true and false. There is nothing in a #() that you can't write as a literal elsewhere, so:
>
> #( abc 'abc' 4 3.4 $r )
>
> can be written as:
>
> (Array with: #abc with: 'abc'), (Array with: 4 with: 3.4 with: $r)
>
> #() is a great convenience, but it is not absolutely necessary.
>
> >#{} is not necessary because this is shortcut macro-expansion for Array new
> >add: ....
> >
> >So why having only this one. There is two ways:
> > or you have a way to describe macro-expansion like in Scheme where you
> > can define any macro in a clear way (you know the semantic of the stuff
> >
> > or we remove it because why not having
> > {{}} for Set new add:
>
> This already has a definition: an empty array in an array, like: #(#()).
>
> > {#[]} for OrderedCollection new....Because I use more
> > OrderedCollection than array
>
> #[] isn't used in Squeak, but some Smalltalk systems (and maybe the standard) use it as a way of writing ByteArray literals: #[ 0 255 76 98 4 67 2 ]. We should carefully decide if we want to differ from others in syntax. (Actually, 'we' already have; for some odd reason '#[' is a symbol! I would have expected to have to write #'[' to get a symbol with a special character.)
>
> I use more OrderedCollection's too, but it was interesting to note that after looking at a couple of hundred uses of {} I don't recall seeing even one message send to convert the array to something else. I think that OCs are widely used when code is building an indexed collection, but rare when the collection is built ahead of time by a literal array or array constructor.
>
> >... SNIP ...
> >
>
> Dave
> --
> _______________________________
> David N. Smith
> IBM T J Watson Research Center
> Hawthorne, NY
> dnsmith(a)watson.ibm.com