GNU Smalltalk

<h2 id="examples">Examples</h2>
<p>These examples work only on GNU Smalltalk 3.0 and later versions. Classic <a href="/facts/%22Hello,_World!%22_program/vLn0jLlL">Hello world</a> example:
</p>
'Hello World!' displayNl

<p>Some basic Smalltalk code:
</p>
"Everything, including a literal, is an object, so this works:"
-199 abs                                                "199"
'gst is cool' size                                      "11"
'Slick' indexOf: $c                                     "4"
'Nice Day Isn''t It?' asLowercase asSet asSortedCollection asString  "′?acdeinsty"

<h3>Collections</h3>
<p>Constructing and using an <a href="/facts/Array_data_type/gHJJ3XPw">array</a>:
</p>
a := #(1 'hi' 3.14 1 2 (4 5))

a at: 3        "3.14"
a reverse      "((4 5) 2 1 3.14 'hi' 1)"
a asSet        "Set(1 'hi' 3.14 2 (4 5))"

<p>Constructing and using a <a href="/facts/Hash_table/Ht4ptDPF">hash</a>:
</p>
hash := Dictionary from: { 'water' -> 'wet'. 'fire' -> 'hot' }.
hash at: 'fire'     "Prints:  hot"

hash keysAndValuesDo: [ :k :v |
        ('%1 is %2' % { k. v }) displayNl ]

"Prints:  water is wet
          fire is hot"

hash removeKey: 'water'  "Deletes 'water' -> 'wet'"

<h3>Blocks and iterators</h3>
<p>Parameter-passing a block to be a <a href="/facts/Closure_(computer_science)/droP22Xn">closure</a>:
</p>
"remember a block."
remember := [ :name | ('Hello, %1!' % { name }) displayNl ].

"When the time is right -- call the closure!"
remember value: 'world'
"=> 'Hello, world!'"

<p>Returning closures from a method:
</p>
 Integer extend [
     asClosure [
         | value |
         value := self.
         ^{ [ :x | value := x ]. [ value ] }
     ]
 ]
 
 blocks := 10 asClosure.
 setter := blocks first.
 getter := blocks second.
 getter value        "=> 10"
 setter value: 21    "=> 21"
 getter value        "=> 21"

<p>Using block to send info back to the caller:
</p>
 Integer extend [
     ifEven: evenBlock ifOdd: oddBlock [
         ^self even
             ifTrue: [ evenBlock value: self ]
             ifFalse: [ oddBlock value: self ]
     ]
 ]

<p>Invoke the above method, passing it a block:
</p>
10 ifEven: [ :n | n / 2 ] ifOdd: [ :n | n * 3 + 1 ]    "=> 5"

<p>Iterating over enumerations and arrays using blocks:
</p>
array := #(1 'hi' 3.14)
array do: [ :item | item displayNl ]
"=> 1"
"=> hi"
"=> 3.14"

(3 to: 6) do: [ :item | item displayNl ]
"=> 3"
"=> 4"
"=> 5"
"=> 6"

<p>A method such as <i>inject:into:</i> can accept both a parameter and a block. It iterates over each member of a list, performing some function on while retaining an aggregate. This is analogous to the <a href="/facts/Foldl/gllDcCxw">foldl</a> function in <a href="/facts/Functional_programming_languages/cdxqPEIM">functional programming languages</a>. For example:
</p>
#(1 3 5) inject: 10 into: [ :sum :element | sum + element ] "=> 19"

<p>On the first pass, the block receives 10 (the argument to inject) as sum, and 1 (the first element of the array) as element, This returns 11. 11 then becomes sum on the next pass, which is added to 3 to get 14. 14 is then added to 5, to finally return 19.
</p><p>Blocks work with many built-in methods:
</p>
(File name: 'file.txt') withWriteStreamDo: [ :file |
        file nextPutAll: 'Wrote some text.'; nl ]
"File is automatically closed here"

(File name: 'file.txt') linesDo: [ :each |
        each displayNl ]

"=> Wrote some text."

<p>Using an enumeration and a block to square the numbers 1 to 10:
</p>
(1 to: 10) collect: [ :x | x squared ] "=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

<h3>Classes</h3>
<p>The following code defines a class named Person. By deriving from Magnitude, it automatically defines all comparison methods except one (<).  With the addition of that one, asSortedCollection can sort by age.  Note that we can override the way the object is printed/displayed (the default is to share the programmer-print and user-display representation) by overriding printOn:.
</p>
Magnitude subclass: Person [
    | name age |
    Person class >> name: name age: age [
        ^self new name: name; age: age; yourself
   ]

< aPerson [ ^self age < aPerson age ]
    name [ ^name ]
    name: value [ name := value ]
    age [ ^age ]
    age: value [ age := value ]
    printOn: aStream [ aStream nextPutAll: ('%1 (%2)' % { name. age }) ]
]

group := {
        Person name: 'Dan' age: 23.
        Person name: 'Mark' age: 63.
        Person name: 'Cod' age: 16.
}.

group asSortedCollection reverse

<p>The above prints three names in reverse age order:
</p>
OrderedCollection (Mark (63) Dan (23) Cod (16) )

<h3>Exceptions</h3>
<p>An exception is raised with a halt call:
</p>
self halt

<p>An optional message can be added to the exception; there's also error: which raises a different kind of exception:
</p>
self halt: 'This is a message'
self error: 'This is a message'

<p>These are actually wrappers for the actual exception raising method, signal:
</p>
Error signal
Error signal: 'Illegal arguments!'

<p>Exceptions are handled by on:do: blocks.
</p>
[ something to do ]
    on: Exception
    do: [ :ex | handle exception in ex ]

<p>Of course you can catch only particular exceptions (and their subclasses):
</p>
[ something to do ]
    on: Warning
    do: [ :ex | handle exception in ex ]

<p>It is possible to use the exception object, which is made available to the handler clause, to exit or resume the first block; exiting is the default, but can also be mentioned explicitly:
</p>
[ Error signal: 'foo' ]
    on: Error
    do: [ :ex | ex return: 5 ]

(Warning signal: 'now what?') printNl                       "=> nil"
[ (Warning signal: 'now what?')
        printNl ] on: Warning do: [ :ex | ex resume: 5 ]    "=> 5"

<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a></li>
<li><a href="/facts/GLASS_(software_bundle)/rPE5Vp8c">GLASS (software bundle)</a></li></ul>
<h2 id="external-links">External links</h2>
<ul><li><a href="https://www.gnu.org/software/smalltalk/">Official website</a></li></ul>

GNU Smalltalk open-in-new

GNU Smalltalk