GNU Smalltalk is an implementation of the Smalltalk
Smalltalk
Smalltalk is an object-oriented, dynamically typed, reflective programming language. Smalltalk was created as the language to underpin the "new world" of computing exemplified by "human–computer symbiosis." It was designed and created in part for educational use, more so for constructionist...
A programming language is an artificial language designed to communicate instructions to a machine, particularly a computer. Programming languages can be used to create programs that control the behavior of a machine and/or to express algorithms precisely....
The GNU Project is a free software, mass collaboration project, announced on September 27, 1983, by Richard Stallman at MIT. It initiated GNU operating system development in January, 1984...
.
The implementation, unlike other Smalltalk environments, uses text files for program input and interprets the contents as Smalltalk code. In this way, GNU Smalltalk acts more like an interpreter rather than an environment in the traditional Smalltalk manner.
In computing, a binding from a programming language to a library or OS service is an API providing that service in the language.Many software libraries are written in systems programming languages such as C or C++...
s for many free software libraries including SQLite
SQLite
SQLite is an ACID-compliant embedded relational database management system contained in a relatively small C programming library. The source code for SQLite is in the public domain and implements most of the SQL standard...
cairo is a software library used to provide a vector graphics-based, device-independent API for software developers. It is designed to provide primitives for 2-dimensional drawing across a number of different backends...
In computing, gettext is an internationalization and localization system commonly used for writing multilingual programs on Unix-like computer operating systems. The most commonly-used implementation of gettext is GNU gettext, released by the GNU Project in 1995.- History :gettext was originally...
In computing, Expat is a stream-oriented XML 1.0 parser library, written in C. As one of the first available open-source XML parsers, Expat has found a place in many open-source projects. Such projects include the Apache HTTP Server, Mozilla, Perl, Python and PHP...
.
Examples
These examples only work on GNU Smalltalk 3.0 and later versions. Classic Hello world example:
'Hello World!' displayNl
Some basic Smalltalk code:
"Everything, including a literal, is an object, so this works:"
-199 abs "199"
'gst is cool' size "11"
'Slick' indexOf: $c "4"
'Nice Day Isnt It?' asLowercase asSet asSortedCollection asString "' '?acdeinsty'"
In computer science, an array type is a data type that is meant to describe a collection of elements , each selected by one or more indices that can be computed at run time by the program. Such a collection is usually called an array variable, array value, or simply array...
:
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))"
In computer science, a hash table or hash map is a data structure that uses a hash function to map identifying values, known as keys , to their associated values . Thus, a hash table implements an associative array...
In computer science, a closure is a function together with a referencing environment for the non-local variables of that function. A closure allows a function to access variables outside its typical scope. Such a function is said to be "closed over" its free variables...
:
"remember a block."
remember := [ :name | ('Hello, %1!' % { name }) displayNl ].
"When the time is right -- call the closure!"
remember value: 'world'
"=> 'Hello, world!'"
Returning closures from a method:
Integer extend [
asClosure [
| value |
value := self.
^{ [ :x | value := x ]. [ value ] }
]
]
A method such as inject:into: 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 foldl function in functional programming languages. For example:
(1 3 5) inject: 10 into: [ :sum :element | sum + element ] "=> 19"
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.
Blocks work with many built-in methods:
(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."
Using an enumeration and a block to square the numbers 1 to 10:
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:.
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
The above prints three names in reverse age order:
OrderedCollection (Mark (63) Dan (23) Cod (16) )
Exceptions
An exception is raised with a halt call:
self halt
An optional message can be added to the exception; there's also error: which raises a different kind of exception:
self halt: 'This is a message'
self error: 'This is a message'
These are actually wrappers for the actual exception raising method, signal:
Error signal
Error signal: 'Illegal arguments!'
Exceptions are handled by on:do: blocks.
[ something to do ]
on: Exception
do: [ :ex | handle exception in ex ]
Of course you can catch only particular exceptions (and their subclasses):
[ something to do ]
on: Warning
do: [ :ex | handle exception in ex ]
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:
[ Error signal: 'foo' ]
on: Error
do: [ :ex | ex return: 5 ]
