ChangeLog
ChangeLog — Navigable view of the workspace's pending in-memory changes (ADR 0082 Phase 1).
Returned by Workspace changes, following Pharo's Smalltalk changes
idiom. The ChangeLog is the append-only record of every live method
mutation and the workspace's dirty-state tracker — "what has the running
workspace changed relative to disk?".
A ChangeLog snapshot holds every logged entry, but its default collection
views (size, isEmpty, notEmpty, do:, dirtyMethods) reflect only
the active entries: changes from the current epoch that have not been
orphaned. Prior-epoch and orphan entries (whose memory state was lost on
workspace restart, so they are no longer re-appliable) are excluded from
those views — but select: ranges over the full set, so it can still reach
them (e.g. Workspace changes select: [:e | e isOrphan]).
Backed by beamtalk_workspace_changelog.erl via FFI.
Examples
Workspace changes notEmpty // => false
Workspace changes dirtyMethods // => #{}
Workspace changes do: [:e | Transcript show: e printString]
Workspace changes select: [:e | e isOrphan] // => _
Methods
Instance Methods
Return the active entries: current epoch and not orphaned.
This is the live, re-appliable dirty set that the default collection
views operate on. select: (which can reach orphans) uses the full set
instead.
Return all entries, including prior-epoch and orphan entries.
Examples
Workspace changes allEntries // => _
The number of active (live, re-appliable) changes.
Examples
Workspace changes size // => 0
Whether there are no active changes.
Examples
Workspace changes isEmpty // => true
Whether there is at least one active change.
"Is anything dirty?" is Workspace changes notEmpty.
Examples
Workspace changes notEmpty // => false
Iterate over each active entry, evaluating block with it.
Prior-epoch and orphan entries are skipped — use select: to reach them.
Examples
Workspace changes do: [:e | Transcript show: e authorKind]
Select entries for which block returns true, over the full entry set.
Unlike the other collection views, select: ranges over every entry —
including prior-epoch and orphan entries — so it can still reach them.
Examples
Workspace changes select: [:e | e isOrphan] // orphans only
Workspace changes select: [:e | e isAgent] // agent changes only
Return the dirty methods grouped by class: #{Class -> #{selectors}}.
Derived from the active entries only. Each class maps to a Set of patched
selector Symbols; new-class entries appear under their class with the
placeholder selector #'new-class'.
Examples
Workspace changes dirtyMethods // => #{} (nothing patched)
// After `Counter >> increment => ...`:
// Workspace changes dirtyMethods // => #{#Counter => #{#increment}}
Developer-readable representation, e.g. "a ChangeLog with 2 entries".
Examples
Workspace changes printString // => "a ChangeLog with 0 entries"
Override inspect to use printString rather than the field-based format.
Inherited Methods
From Value
Return a developer-readable string representation showing fields.
Produces ClassName(field: value, ...). Field values are recursively
inspected — strings are quoted, nested objects show their own inspect.
A class with no fields produces ClassName().
Examples
ValuePoint x: 3 y: 4 inspect // => "ValuePoint(x: 3, y: 4)"
ValuePoint new inspect // => "ValuePoint(x: 0, y: 0)"
From Object
Return the class of the receiver.
Examples
42 class // => Integer
"hello" class // => String
Test if the receiver is nil. Returns false for all objects except nil.
Examples
42 isNil // => false
nil isNil // => true
Test if the receiver is not nil. Returns true for all objects except nil.
Examples
42 notNil // => true
nil notNil // => false
If the receiver is nil, evaluate nilBlock. Otherwise return self.
Examples
42 ifNil: [0] // => 42
nil ifNil: [0] // => 0
If the receiver is not nil, evaluate notNilBlock with self.
Examples
42 ifNotNil: [:v | v + 1] // => 43
nil ifNotNil: [:v | v + 1] // => nil
If nil, evaluate nilBlock; otherwise evaluate notNilBlock with self.
Examples
42 ifNil: [0] ifNotNil: [:v | v + 1] // => 43
nil ifNil: [0] ifNotNil: [:v | v + 1] // => 0
If not nil, evaluate notNilBlock with self; otherwise evaluate nilBlock.
Examples
42 ifNotNil: [:v | v + 1] ifNil: [0] // => 43
nil ifNotNil: [:v | v + 1] ifNil: [0] // => 0
Return a developer-readable string representation.
Default implementation returns "a ClassName". Subclasses such as
Integer, String, and List override this to return richer output.
Examples
42 printString // => "42"
Return a user-facing string representation for display purposes.
Default implementation delegates to printString. Subclasses such as
String and Symbol override this to return a more readable form without
developer annotations (e.g. no surrounding quotes or # prefix).
Examples
42 displayString // => "42"
Inspect the receiver.
Examples
42 inspect // => "42"
Return the receiver itself. Useful for cascading side effects.
Examples
42 yourself // => 42
Return a hash value for the receiver.
Examples
42 hash
Test if the receiver responds to the given selector.
Examples
42 respondsTo: #abs // => true
Return the names of fields.
Examples
42 fieldNames // => #()
Return the value of the named field.
Examples
object fieldAt: #name
Set the value of the named field (returns new state).
Examples
object fieldAt: #name put: "Alice"
Send a unary message dynamically.
Examples
42 perform: #abs // => 42
Send a message dynamically with arguments.
Examples
3 perform: #max: withArguments: #(5) // => 5
Raise an error indicating this method must be overridden by a subclass.
Examples
self subclassResponsibility
Raise an error indicating this method has not yet been implemented.
Use this for work-in-progress stubs. Distinct from subclassResponsibility,
which signals an interface contract violation.
Examples
self notImplemented
Send aValue to the current transcript without a trailing newline.
Nil-safe: does nothing when no transcript is set (batch compile, tests).
Examples
42 show: "value: "
Send aValue to the current transcript followed by a newline.
Nil-safe: does nothing when no transcript is set (batch compile, tests).
Examples
42 showCr: "hello world"
Test if the receiver is an instance of aClass or any of its subclasses.
For class-object receivers, follows Smalltalk semantics: self class
is the metaclass, so the check walks the parallel metaclass hierarchy.
The parallel chain is grounded at ProtoObject class superclass == Class
(ADR 0036), so the metaclass tower merges into the instance-side
Class → Behaviour → Object → ProtoObject chain. As a result,
Integer isKindOf: Object and Integer isKindOf: Class both return true.
Examples
42 isKindOf: Integer // => true
42 isKindOf: Object // => true
#foo isKindOf: Symbol // => true
#foo isKindOf: String // => false
Integer isKindOf: Number // => false (metaclass chain, not instance chain)
Integer isKindOf: Number class // => true (Number class is in the parallel chain)
Integer isKindOf: Object // => true (grounded — Object is reachable via the metaclass tower)
Integer isKindOf: Class // => true (Integer class inherits from Class)
Raise an error with the given message.
Examples
self error: "something went wrong"
From ProtoObject
Test value equality (Erlang ==).
Examples
42 == 42 // => true
"abc" == "abc" // => true
Test value inequality (negation of ==).
Examples
1 /= 2 // => true
42 /= 42 // => false
Return the class of the receiver.
Examples
42 class // => Integer
"hello" class // => String
Handle messages the receiver does not understand. Override for custom dispatch.
Examples
42 unknownMessage // => ERROR: does_not_understand
Send a message dynamically with an arguments list.
Examples
42 perform: #abs withArguments: #() // => 42
Execute a class method in the caller's process, bypassing gen_server dispatch.
The caller takes responsibility for knowing the method does not mutate class state. Useful for long-running class methods that would otherwise block the class object's gen_server.
Limitations: only resolves methods defined directly on the target class
module (does not walk the superclass chain). Class variables and self
are not available to the method (nil and #{} are passed).
Examples
MyClass performLocally: #run:ctx: withArguments: #(input, ctx)
Send a message dynamically with an arguments list and explicit timeout.
The timeout (in milliseconds or #infinity) applies to the gen_server:call
when the receiver is an actor. For value types, timeout is ignored.
Examples
actor perform: #query withArguments: #(sql) timeout: 30000