This note refers to Squeak3.4beta but I think it applies also to all earlier versions of Squeak.
In the literal #('Hello' true false nil) the four elements are: 1. the string 'Hello' 2. the symbol #true (not the sole instance of class True) 3. the symbol #false (not the sole instance of class False) 4. the symbol #nil (not the sole instance of class UndefinedObject)
This is traditional "Blue Book" Smalltalk. The Blue Book says (on page 21): "The literal representation of an array is a sequence of other literals - numbers, characters, strings, symbols, and arrays - delimited by parentheses and preceded by a pound sign. The other literals are separated by spaces. Embedded symbols and arrays are not preceded by pound signs."
This traditional denotation was implemented in both Smalltalk-80 and Digitalk Smalltalk/V.
But then there came a change with one of the releases of Smalltalk-80 (I think it was release 2.5, but I cannot find documentation that proves this). The literal expression #('Hello' true false nil) was now interpreted as the writing form of an array with these elements:
1. the string 'Hello' 2. the sole instance of class True (not a symbol) 3. the sole instance of class False (not a symbol) 4. the sole instance of class UndefinedObject (not a symbol)
An array with symbols was now written as: #('Hello' #true #false #nil) The use of the pound symbol with embedded symbols was introduced to be able to distinguish between the symbol #true and the value true.
All major Smalltalks changed to the interpretation that allows the use of the values true, false, nil in array literals. Squeak is, as far as I can see, the sole Smalltalk that follows the "Blue Book" interpretation.
Here is what a draft of the ANSI specification from 1997 says:
5.4.6.6 Array Literals An array literal is a sequenced collection with numeric keys which may contain any number of other literals.
<array literal> ::= '#(' <array element>* ')' <array element> ::= <literal> | identifier The value of an array literal is an object that implements the <sequencedReadableCollection> protocol. The elements of an array literal can consist of any combination of literal forms. If an identifier appears as an <array element> and it is one of the reserved identifiers nil, true or false the value of the corresponding element of the collection is the value of that reserved identifier. The meaning is undefined if any other identifier is used as an <array element>. If an <array literal> has no <array element>clauses the collection has no elements.
My question to the community: Should we adopt the ANSI interpretation of array literals or should we keep the 'Blue Book' interpretation?
Note that we can use curly brackets to create an array with logical values and with the value nil: {'Hello'. true. false. nil. #true. #false. #nil}
The curly brackets are not part of the 'Blue Book' Smalltalk. They are, to the best of my understanding, also not part of the ANSI specification, but at times they are very useful.
The attached change set is perhaps(!) sufficient to change to ANSI. It should be seen as an experimental change; please try it only with an image that does not contain work that you cannot restore after a fatal crash.
Greetings and best wishes for a successful new year Boris
squeak-dev@lists.squeakfoundation.org