Smalltalk Syntax Cheat Sheet/en

A short, one page summary of what beginners need to know about Smalltalk/X (ST/X) syntax. Non standard ST/X extensions are marked with (*).
A list of most useful messages is found "List of Useful Selectors".

Syntax

Comments

Regular comment	" this is a comment "
EOL-Comment (*)	"/ this is an End-of-Line comment
Token-Comment (*)	"<<END a multiline token-comment up to a line starting with 'END' more commented stuff here ... comment ends here END

Literal Constants

Integers	12345 -12345
Large integers	1234567890123456789012345... (arbitrary size)
Integers with radix	hex: 16rAFFE 0xFEED 16r-AFFE -0xBEAF -16rAFFE binary: 2r010101 0b11011 2r-010101 -0b1100 octal: 8r0777 (the 0x, 0b variants are extensions to standard Smalltalk)
Floats (IEEE double; roughly 17 decimals)	12.456 1.234e17 -6.9 -6e-10 Float pi Float e
Short floats (IEEE single; roughly 8 decimals)	1.234f17 -6f-10
Long floats (IEEE quad; roughly 20 decimals) (*)	1.234q17 -6q-10
Fractions	(1/3) (17/2)
ScaledDecimal	123.456s2 10s4
Characters	$a Character space Character nl Also: "null", "tab", "return", "bell"...
Strings	'hello' with C-escape sequences (*):  c'hello\nworld' with embedded expressions (*):  e'it is {Time now}\nHave fun' internationalization (*):  i'Sunday' or i'Sunday {Date today}' regex (*):  r'a*' or r'[a-z][0-9a-z]*'
Symbols	#'hello' #foo (without quotes, if only alphaNumeric characters)
Arrays	#( el1 el2 ... elN ) each element being a literal constant for arrays within an array constant, the leading hash ("#") can be ommitted Notice: these are constants, allocated at compile time; (for arrays constructed at run time, see brace construct below)
Byte arrays	#[ b1 b2 ... bN ] each byte-element being an integer constant in 0..255
Special number arrays (*)	#XX( v1 v2 ... vN ) XX: is one of  'u8', 's8', 'u16', 's16', 'u32', 's32', 'u64', 's64', 'f32', 'f64'  and each element being an integer or float constant
Immediate Inline Objects (*)	#{ foo: fooValue . bar: barValue } fooValue and barValue: constant

Blocks (aka Lambdas / Closures)

Without argument	[ expr1 . expr2 ... exprN ] when evaluated (by sending it the "value" message),  the value is the value from  the last expression, exprN
One argument	[:arg | expr1 . expr2 ... exprN ] evaluate by sending it the "value:" message
Multiple arguments	[:a1 :a2 ... :aN | expr1 . expr2 ... exprN ] evaluate by sending it a "value:...value:" message

Expressions

Unary Expression (without argument)	receiver messageName receiver is itself either a constant, a lambda-block, a unary expression or a parenthesized expression
Keyword Expression: (1 arg)	receiver messageNamePart:argExpression whitespace between the colon and the argExpression is optional.
Keyword Expression: (any number of args)	receiver     messageNamePart1:argExpression1     messageNamePart2:argExpression2     ...     messageNamePartN:argExpressionN
Binary Expression	receiver binOP arg with binOP being any combination of special characters: * , + , - , % , & , / , \ , | , = , < , > , ? and , I.e. "foo ==> 123" is the binary message "==>" sent to foo with 123 as argument. And "foo ? 123" is the binary message "?" (or-if-nil) sent to foo with 123 as argument. And "foo , bar" is the binary message "," (concatenation) sent to foo with bar as argument.
Cascade Expression (sending multiple messages to the same receiver)	receiver message1 ; message2 ; ... messageN the receiver expression is evaluated, then multiple messages (separated by ";") are sent to this receiver. The value of the cascade is the value returned by the last message.
Parentheses for grouping	( any expression )
Assignment	variable := expression can be used as expression.
Computed Array (Brace Construct)	{ expr1 . expr2 . ... . exprN } instantiates a new Array object with elements from the expressions.
Computed Inline Objects (*)	{ foo: fooExpr . bar: barExpr } fooExpr and barExpr are expressions. Notice the period to separate fields.

Remaining Syntax

Local variables (in block or method)	| var1 var2 ... varN | variable declarations must be at the beginning, before any expression.
Separating multiple expressions (sequence)	expr1 . expr2 . ... exprN expressions (statements) are separated by fullstop (period) characters. The last expression may or may not be followed by a fullstop; if there is one, this is treated like a followup empty statement.
Return from method	^ expression returns from the enclosing method (also if inside a block-closure)

Wellknown (Common) Messages

Conditional Execution	boolExpr1 ifTrue:[ ... ] ifFalse:[ ... ] variations without true part (ifFalse:), without false part (ifTrue:) and with the order reversed (ifFalse:ifTrue:) are available.
While-Loop	[ boolExpr1 ] whileTrue:[ ... ] notice the receiver being a block. A whileFalse variant is also available.  Loops with test at end are written as "[...] doWhile:[...]" or "[...] doUntil:[...]"
For-Loop	start to:stop do:[:iterVar | ... ] evaluates the lambda for each value in start..stop.
Enumerating Collections	collection do:[:elementVar | ... ] evaluates the lambda for each element in the collection.
Evaluating a Lambda Block   without arguments:   with arguments:	aBlock value aBlock value:expr1 ... value:exprN the number of arguments must match the number expected by the lambda (although varArg lambdas are also available)
Starting a background thread	aBlock fork evaluates the lambda in a separate thread. Alternatives are "forkNamed:" to give the thread a user friendly name.

Wellknown Globals

Logging and Messaging

Logger - redefinable logger (defaults to standard error) Transcript - console window Stdout - standard output Stderr - standard error Stdin - standard input

Most Wellknown Classes

Numbers

Numbers

Number (abstract superclass) Integer (integral numbers), Float (inexact) Fraction (exact) Complex a few more...

Collections

Collections

Collection (abstract superclass) SequenceableCollection (abstract superclass) Array (fixed size array) OrderedCollection, List (variable size) SortedCollection Set, Bag (unordered) Dictionary (mapped collections) BinaryTree, AVLTree SharedQueue (shared, synchronized) many more...

Process Handling

Process Handling

Process (lightweight thread) OSProcess (heavyweight OS process) Semaphore, RecursionLock (synchronization) Monitor, BoltLock Delay

Files & Streams

Files & Streams

Filename (file naming, directory access, mime type) Stream (basic stream framework) ReadStream, WriteStream, EncodedStream ExternalStream, FileStream, Socket (OS streams)

Low Level Access

Low Level Access

OperatingSystem (OS API calls) Smalltalk (startup, shutdown and globals)

Examples

File Handling

Open a file, write some lines, close it

|fn stream nr nr1 nr2 nr3|. "/ local variables

nr := 123.
nr1 := 10.
nr2 := 20.
nr3 := 30.

fn := 'myFile' asFilename.     "/ convert string to filename
stream := fn writeStream.      "/ open a stream for writing
stream nextPutLine:'bla bla'.  "/ write with line-end-character
stream nextPut:'word1'.        "/ without line-end-character
stream cr.                     "/ line-end-character
stream printf: c'%3d\n' with:nr.  "/ formatted print
stream printf: c'%3d %3x %03x\n' withAll:{nr1 . nr2 . nr3}.
stream close

Open the file, read some lines, close it

|fn stream line word nrs|. "/ local variables

stream := 'myFile' asFilename readStream.       "/ open for reading
line := stream nextLine.                        "/ read a line
word := stream next:5.                          "/ read 5 characters
stream skipThroughEndOfLine.                    "/ skip up-to and including line-end
nrs := stream scanf: c'%3d\n'.                  "/ formatted read; returns vector (with 1 nr in it)
nr1 := nrs at:1.
nrs := stream scanf: c'%3d %3x %03x'.           "/ returns a vector (with 3 nrs in it)
stream close

---

Copyright © 2014-2024 eXept Software AG