Smalltalk Syntax Cheat Sheet

A short, one page summary of what beginners need to know about Smalltalk/X syntax

This page was extracted from the "Smalltalk/X Programmers guide - Smalltalk/X Cheat Sheet".
Smalltalk/X language extensions are marked with (*).

Syntax

Comments

Regular comment	" this is a comment "	any text between double quotes
EOL-Comment (*)	"/ this is an End-of-Line comment	text from quote-slash to line end
Token-Comment (*)	"<<END a multiline token-comment up to a line starting with 'END' more commented stuff here ... comment ends here END	text up to line beginning with whatever token came after the initial "<<"

Literal Constants

Integers	12345 -12345
Large integers	1234567890123456789012345…	arbitrary number of digits
Integers with radix (Smalltalk style)	16rAFFE, 2r010101, 8r0777, 3r012012, 16r-AFFE, 2r-010101	prepend the radix (base) any radix from 2..36 is possible (i.e. 3r222 is a ternary number)
Integers with radix (C style) (*)	0xFEED -0xBEAF 0b11011,-0b1100	C/Java/JavaScript style: prepend radix indicator ('x', 'b', 'o') One of hex, binary and octal
Floats (IEEE double; roughly 17 decimals)	12.456 1.234e17 -6.9 -6e-10 Float pi Float e	called "Float", but actually hold double precision Common constants can be referred to "by name".
Short floats (IEEE single; roughly 8 decimals) (*)	1.234f17 -6f-10
Long floats (IEEE quad; roughly 20 decimals) (*)	1.234q17 -6q-10	actual precision depends on the underlying CPU (on x86/x86_64: only 80bit)
High prec. floats; roughly 60 decimals (*)	1.234Q17 -6Q-10	computed in software; therefore slower; this is not yet officially released.
Fractions	(1/3) (17/2)
Characters	$a Character space Character nl Also: "null", "tab", "return", "bell"...	traditionally, Smalltalk does not support any escape sequence Common constants can be referred to "by name".
Strings	'hello'	traditionally, Smalltalk does not support any escape sequence inside
Strings (C Style) (*)	c'hello\nworld'	supports the common escape sequences, such as "\n", "\t", "\xHH"
Symbols	#'hello' #foo	without quotes, if only alphaNumeric characters
Arrays	#( el1 el2 ... elN )	each element is a literal constant
Byte Arrays	#[ b1 b2 ... bN ]	each byte-element 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: are constants

Lambda Blocks (Closures)

Without argument	[ expr1 . expr2 ... exprN ]	multiple expressions sep'd by period. When evaluated, the value is the value from the last expression, exprN
One argument	[ :arg |     expr1 . expr2 ... exprN ]
Multiple arguments	[ :a1 :a2 ... :aN |     expr1 . expr2 ... exprN ]

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 "?" sent to foo with 123 as argument.
Cascade Expression (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.
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 Object (*)	{ foo: fooExpr . bar: barExpr }	fooExpr and barExpr: expressions
Inline string expressions (*)	e'p1{e1}p2{e2}...pN{eN}pM'	syntactic sugar for: ('p1%1p2%2...pN%NpM' bindWith:e1 with:e2 ... with:eN) where each pI is a string with possible C-escapes and each eI is a Smalltalk expression
Array Indexing (*)	coll[idx]	syntactic sugar for: (coll at:idx) where coll must be an indexable collection, and idx of compatible index type. I.e. integer for array-like collections, hash-key for dictionaries, etc.
Collection instantiation (*)	someClass[sz]	syntactic sugar for: (someClass new:sz) where someClass must be a collection class I.e. Array[10] creates an empty array with 10 slots.

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, without false part and with the order reversed are available.
While-Loop (test at top)	[ boolExpr1 ] whileTrue:[ ... ]	notice the receiver being a block. A whileFalse: variant is also available.
Do-Loop (test at bottom)	[ ... ] doWhile:[ boolExpr1 ]	notice the test being a block. A doUntil: variant is also available.
For-Loop	start to:stop do:[:iterVar | ... ]	evaluates the block (lambda) for each value in start..stop.
Enumerating Collections	collection do:[:elementVar | ... ]	evaluates the block (i.e. 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)
Exception Handling	[ ... ] on:Error do:[:ex | ... ]	evaluates the first block; if an error is encountered, evaluate the handler

Special 'Control Structures'

Exception Handling	[ ... ]   on:Error do:[:ex |     ...   ]	the handler will get an exception argument (ex), which contains additional information, and can be told how to deal with the error
Exception Handling - proceeding	[ ... ]   on:Error do:[:ex |     ...     ex proceed   ]	proceed, as if the error did not happen
Exception Handling - restarting	[ ... ]   on:Error do:[:ex |     ...     ex restart   ]	restart the code from the beginning (usually after the handler did some cleanup, such as lazy loading a missing file...)
Exception Handling - printing	[ ... ]   on:Error do:[:ex |     ...     ex description     ...   ]	contains a human readable description of the error
Ensure/Unwind Protect	[ ... ]   ensure:[   ...   ]	the ensure block will be evaluated in any case
Ensure/Unwind Protect	[ ... ]   ifCurtailed:[   ...   ]	the ensure block will be evaluated only on a non-regular exit (i.e. when an exception was raised, or the operation was aborted or the thread terminated)
Queries	Query answer:something do:[[ ...[ Query query[ ...[ ]	to provide answers way down to whoever is interested. Queries answer nil if no one is there to answer. Queries are usually more specifically used as subclasses of Query
Notifications	Notification handle:[...] do:[ ...[ Notification notify:someArg[ ... ]	to provide information way up to whoever is interested Notifications are usually more specifically used as subclasses of Notification
Observers 1	foo onChange:#bla evaluate:[...] ... foo changed:#bla	observer with generic block to evaluate
Observers 2	foo onChangeSend:#xyz to:someone ... foo changed	observer with message send
Observers 3	foo addDependent:someone ... foo changed	observer with send to update method of target

Wellknown Globals

Logging and Messaging

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

Most Wellknown Classes

Numbers	Integer Float Fraction Complex
Collections	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 (lightweight thread) OSProcess (heavyweight OS process) Semaphore, RecursionLock (synchronization) Monitor, BoltLock Delay (time delays)
Files & Streams	Filename (file naming, directory access, mime type) Stream (basic stream framework) ReadStream,WriteStream,EncodedStream ExternalStream, FileStream, Socket (OS streams)
Low Level Access	OperatingSystem (OS API calls) Smalltalk(startup, shutdown and globals) ObjectMemory (VM access)

Examples

exampleMethod1
    |v1 v2|

    v1 := 42.
    v2 := v1 sqrt.
    Transcript showCR: 'the root of the answer to all questions is: %1' with: v2.

using expanded strings, this can be written as:

exampleMethod1_alternative
    |v1|

    v1 := 42.
    Transcript showCR: e'the root of the answer to all questions is: {v1 sqrt}'.

exampleMethod2
    |arr|

    arr := #( 1 2.0 'three' (4 4 4 4) ).
    arr do:[:el |
        Transcript showCR: el
    ]

exampleMethod3
    |arr|

    arr := #( 1 2.0 'three' (4 4 4 4) ).
    arr doWithIndex:[:el :idx |
        Transcript showCR: e'array element at {idx} is {el} and its class is {el class name}\n'
    ]

exampleMethod4
    |s1 nr1 s2 nr2|

    s1 := Dialog request:'Enter the first number' initialAnswer:1.
    s1 isNil ifTrue:[ ^ self ].   "/ cancelled - return from method
    s2 := Dialog request:'Enter the second number' initialAnswer:2.
    s2 isNil ifTrue:[ ^ self ].   "/ cancelled - return from method

    "/ convert; on error return from method
    nr1 := Number readFrom:s1 onError:[^ self].
    nr2 := Number readFrom:s2 onError:[^ self].

    "/ save division
    [
        rslt := nr1 / nr2
    ] on: Error do:[:ex |
        (Dialog confirm: e'Error encountered: {ex description}\nProceed with zero?')
            ifFalse:[^ self]. "/ no; return from method
        ex proceedWith:0
    ].

    Dialog information: e'the result is {rslt}'

---

Copyright © 2014-2024 eXept Software AG