On Thursday 26 April 2001 12:45, txporter@mindspring.com wrote:

As a new Squeaker, I am slowly making my way through Mark's book on Squeak.

At the end of chapter 2, there are some exercises, specifically No. 3: Write a piece of workspace code [...] to do the following: (a) Replace all vowels in the string 'Squeak' with dashes. (b) Compute the average of a set of integers in an array.

I did this like so, but think it is more like "procedural-language speak' and not Smalltalk. Anyone have any more elegant solutions? I particularly do not like the use of the aCount variable.

aString := 'squeak'. aCount := 1. aString do: [:element | element isVowel ifTrue: [aString at: aCount put: $-]. "Could aString be self?" aCount := aCount +1].

'squeak' collect: [ :ea | ea isVowel ifTrue: [ $- ] ifFalse: [ ea ]]

anArray := #(12 14 16 18 20). aSum := 0. aCount := 0. anArray do: [:num | aSum := aSum + num. aCount := aCount +1]. anAverage := aSum / aCount.

#(12 14 16 18 20) average

At 03:45 PM 4/26/2001 -0400, txporter@mindspring.com wrote:

As a new Squeaker, I am slowly making my way through Mark's book on Squeak.

At the end of chapter 2, there are some exercises, specifically No. 3: Write a piece of workspace code [...] to do the following: (a) Replace all vowels in the string 'Squeak' with dashes. (b) Compute the average of a set of integers in an array. aString := 'squeak'. aCount := 1. aString do: [:element | element isVowel ifTrue: [aString at: aCount put: $-]. "Could aString be self?" aCount := aCount +1].

anArray := #(12 14 16 18 20). aSum := 0. aCount := 0. anArray do: [:num | aSum := aSum + num. aCount := aCount +1]. anAverage := aSum / aCount.

This will work...

(anArray detectSum: [:num | num]) / anArray size

When it comes to collections...browse the methods in the 'enumerating' message category of the class Collection.

Also, Kent Beck's book "Smalltalk Best Practice Patterns" book talks a great deal about about Collections.

Mark

On Thu, 26 Apr 2001 txporter@mindspring.com wrote:

As a new Squeaker, I am slowly making my way through Mark's book on Squeak.

At the end of chapter 2, there are some exercises, specifically No. 3: Write a piece of workspace code [...] to do the following: (a) Replace all vowels in the string 'Squeak' with dashes.

Like others, I'll presume that returning a new string is kosher.

(b) Compute the average of a set of integers in an array.

I did this like so, but think it is more like "procedural-language speak' and not Smalltalk.

I'm not sure that the issue is primarily procedural vs. OO (as others have said), but Smalltalky vs. transliterated other language :)

Anyone have any more elegant solutions? I particularly do not like the use of the aCount variable.

As others have pointed out, at least implicitly, #do is a pretty blunt instrument. Much joy comes from mastering the enumeration protocal, especially the *ect: methods--#detect:, #select:, #collect:, #reject:, #inject:into:, the combos such as #select:thenCollect: and the "withIndex:" wonders, an so on. Each one is worth learning, and one quickly becomes adept at using them. Manical giggling is optional, but hard to avoid.

The *key* thing, when dealing with string, is to remember that they're collections, indeed, that they are Arrays. So, not only are the a bazillon useful methods in String, and not only, should you peek up the hierachy to see what *other* groovey methods there are, but it's often useful to stop *thinking* of them as strings and treat them just as collections.

Which means, and I don't *think* anyone else has brought this up yet, and which is the whole justifiction for this note, you get to use STREAMS! with them!

And if that's not cause for estatic excitment, well then, uh, you have a much more interesting life than me!

Here's one example: | strm | strm := (ReadWriteStream with: 'Squeak') reset. [strm atEnd] whileFalse: [strm peek isVowel ifTrue: [strm nextPut: $-] ifFalse: [strm next]]. strm contents.

This will modify the orginal string (with the negative consequence for the string literal that Andrew noted). But you can use #do: to iterate over the string: String streamContents: [:strm | 'Squeak' do: [:chr | chr isVowel ifTrue: [strm nextPut: $-] ifFalse: [strm nextPut: chr]]].

(String>>streamContents: is *wonderful* for using WriteStreams to build up strings. Saves some bookkeeping lines.)

(You could also setup a ReadStream on the string. Useful if you need to make decisions based on looking ahead, etc.)

Now, this is nasty compared to the #collect: varient, but it has a *huge* advantage...you can replace the vowels with strings instead of just characters.

E.g., if you replace the ifTrue: block with: [strm nextPut: $-; nextPut: $|]

or the more idomatic: [strm nextPutAll: '-|']

you'll get: 'Sq-|-|-|k'

(Properly managed, streams are generally more speedy for concatenation.)

Cheers, Bijan Parsia.