Smalltalk | By the Bluebook implementation of Smalltalk-80 | 3D Printing library

As Beck explains, some clients may need to enumerate a collection in a way that the elements are sorted before exposing them, others would require not iterating twice over the same object (which may appear twice in the collection), etc.

One way to address these situations would be to add methods such as #sortedDo:, #withoutDuplicatesDo:, etc. to the collection class. Sooner or later, this approach would derive in populating the class with other variants of #do: such as #sortedSelect:, #withoutDuplicatesCollect:, and the like. The problem is that the resulting protocol of the class would quickly grow too large, adding complexity to the simple task of finding the right selector, increasing the risk of duplicating pieces of code when the search is not exhaustive enough, etc.

To avoid those side effects, the class should provide methods for converting its instances in instances of other classes. So, instead of #sortedDo: the client may use

As the compiler tells you, you cannot move a value out of a place observable by others. But since you have the replacement at the ready, you can use std::mem::replace:

Once you load polymath, you will have all packages available to load. The tool used to load/save packages in Pharo is called iceberg (is a git client). You can find it in the menu "tools" in Pharo 8 or in "browse" in Pharo 9.

A Float is a data structure that codifies a number, which regardless of how we see or interpret it, mathematically speaking, cannot be anything but a rational quantity (i.e., an integer or fraction). This codification is appropriate for arithmetic operations, which the CPU performs at high speed. The price we pay is that the codification doesn't exhibit the numerator and denominator it represents. The method Float >> #asTrueFraction answers with these numbers, in other words, it decodes the bits enclosed in the instance of Float, and answers with the actual fraction it codifies.

What you have to understand is that when you write 0.001 you are telling the Compiler to create a Float that approximates the fraction 1/1000. Had the CPU used decimal rather than binary representations, this would have been similar to asking it to codify 1/3 using a finite number of decimal places, which leads irrevocably to 0.33333..3, for some maximum number of digits 3. In the case where the denominator is not a power of 2, the CPU has to solve a similar problem and ends up approximating the provided quantity so that it fits in the number of bits allocated to Floats. The method #asTrueFraction reverses that process and reveals the exact value of the approximation, which Float hides behind the way it prints its instances.

In Pharo, Float >> #asFraction is the same as Float >> #asTrueFraction, so no difference there.

The comment in Float >> #asMinimalDecimalFraction is very clear, it will give what you usually expect, this is, the shortest decimal Fraction that will equal self when converted back asFloat.

Finally, Float >> #asApproximateFraction uses some algorithm to produce an acceptable approximation of the receiver.

Here's a contrived demonstration program. It reads in strings from standard input until EOF, sorts them, then prints them out:

The problem is that there's a conflict between the Smalltalk gst command and, evidently, an alias provided by the git package installation called gst which probably does a git status. This cause has been indicated in other linked answers (e.g., here), but those answers don't tell you what to do to solve it.

There are a couple of ways this can be solved easily:

You can undo the alias that the git installation setup by doing an unalias in your login profile. Make sure you put it after any global profile is executed:

Sounds like this is a source file from a Xerox-internal version of Smalltalk-80. For the public release they must have replaced these "unusual" chars (which required custom font glyphs) with ASCII, only keeping ← and ↑ glyphs for the _ and ^ ASCII characters.

This is a best guess based on my experience with St76/78 (Update: confirmed by Dan Ingalls):

1. ← assignment as in var ← object. Same in St80.

2. rcvr word← arg is an alternative to word: and usually indicates assignment to a slot of the receiver (e.g. x← as in point x ← 100). St80 only allows keywords ending in a colon :.

   The parser treats ← as lower precedence so you can have keyword expressions on both sides of it. E.g.

   a foo: b ← c bar: d

   would eval c bar: d and pass the result as second argument to a's foo:← method).

3. ◦ indexing as in array◦index. St80 uses at: instead.

4. ◦← equivalent to St80's at:put: as in array◦index ← value

5. ≡ identity, like St80's ==

6. ¬ literal for negative numbers as in ¬1 for -1. The parser treated - as a binary message selector so another symbol had to be used for negative numbers literals.

7. ≠ not equal, like St80's ~=

8. ≢ not identical, like St80's ~~

9. ⌾ create a Point, like St80's @

10. ∢ match token from stream. If the next token read from stream matches the argument, it is consumed and returned. Otherwise it answers false.

For more info check out the Smalltalk Zoo website.

I can't speak for other dialects, but GemStone does have this capability:

Yes, it is super simple to just run