[up] [next]

Smalltalk/X Cheat Sheet

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



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

Literal Constants

Integers 12345
Large integers 1234567890123456789012345...
(arbitrary size)
Integers with radix 16rAFFE 0xFEED
16r-AFFE -0xBEAF
2r010101 0b11011
2r-010101 -0b1100
* the 0x, 0b variants are non-standard
(IEEE double; roughly 17 decimals)
Float pi
Float e
Short floats
(IEEE single; roughly 8 decimals)
Long floats
(IEEE quad; roughly 20 decimals) (*)
Character space
Character nl

Also: "null", "tab", "return", "bell"...

with C-escape sequences (*):

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]*'

(without quotes, if only alphaNumeric characters)
#( el1 el2 ... elN )
each element 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: 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


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.

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
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)
message1 ;
message2 ;
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 Number (abstract superclass)
Integer (integral numbers),
Float (inexact)
a few more...
Collections Array (fixed size array)
OrderedCollection, List (variable size)
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
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)

Command Line

A more complete description is found in the Command Line section of the getting started document.
-I ignore snapshot image
--quick quick startup; no banner shown
--repl start an interactive read-eval-print-loop
--print expr eval expr, print its value then exit
--eval expr eval expr (without printing) then exit
--execute filename execute the script in fileName then exit
--loadPackage package-ID preload a compiled smalltalk class library (package)
--help show all other command line options

Copyright © 2017-2020 Claus Gittinger, all rights reserved

<cg at exept.de>

Doc $Revision: 1.17 $ $Date: 2021/06/14 16:20:31 $