Class

Return the name of the receiver (class or metaclass) as a Symbol.

Declared on Behaviour so registry walks that hold the abstract Behaviour type (e.g. SystemNavigation allClasses, superclassChain) can read the name without a dnu suppression. Class inherits this directly; Metaclass overrides it to append class (e.g. #'Integer class'). The className primitive resolves the name for any class object.

Examples

Counter name   // => #Counter
Integer name   // => #Integer

Look up a method by selector, returning a CompiledMethod object, or nil if the selector is not found in the method dictionary.

Follows Smalltalk-80 convention: Behaviour >> #selector returns a CompiledMethod with selector, source, and argument count metadata.

Examples

(Integer >> #+) selector         // => #+
(Integer >> #+) argumentCount    // => 1
Integer >> #nonExistent          // => nil

Return the superclass of the receiver as a class object, or nil for roots.

Examples

Counter superclass      // => Actor (as class object)
ProtoObject superclass  // => nil

Return all superclasses in order from immediate parent to root.

Examples

Counter allSuperclasses   // => [Actor, Object, ProtoObject]

Return direct subclasses of the receiver as a list of class objects.

Examples

Object subclasses   // => [Behaviour, Actor, Integer, ...]

Return all subclasses transitively (breadth-first) as class objects.

Examples

Object allSubclasses   // => [Behaviour, Class, Actor, ...]

Return the chain from self up to (and including) Object as a list.

Self is at the head; Object is at the tail when the class inherits from Object. For classes that do not reach Object (e.g. ProtoObject or ProtoObject subclass: classes such as Erlang), returns the full chain to the root. For Object itself, returns [Object].

When called on a metaclass receiver, walks the parallel metaclass hierarchy and terminates at Object class: Counter class superclassChain => [Counter class, Actor class, Object class]. The parallel chain is grounded at Class (ADR 0036 / BT-2217), so the underlying allSuperclasses continues through Class → Behaviour → Object → ProtoObject. superclassChain deliberately stops at Object class — symmetric with the instance-side Object terminator — so the metaclass view ends where the parallel tower meets the instance tower.

Examples

Counter superclassChain        // => [Counter, Actor, Object]
Object superclassChain         // => [Object]
Counter class superclassChain  // => [Counter class, Actor class, Object class]

Test whether the receiver strictly inherits from aClass (self not included).

Pure Beamtalk — delegates to allSuperclasses.

Examples

Counter inheritsFrom: Actor    // => true
Counter inheritsFrom: Counter  // => false

Test whether aBehaviour is the receiver or one of its ancestors.

Pure Beamtalk — identity check plus inheritsFrom:.

Examples

Counter includesBehaviour: Counter  // => true
Counter includesBehaviour: Actor    // => true
Counter includesBehaviour: Integer  // => false

Return selectors defined on this class (not inherited).

Examples

Counter methods   // => [increment, getValue]

Return all selectors understood by instances, including inherited ones.

Walks the class chain collecting methods at each level.

Examples

Counter allMethods   // => [increment, getValue, class, respondsTo:, ...]

Test whether instances of the receiver understand the given selector (checks full inheritance chain).

Pure Beamtalk — checks local then walks hierarchy.

Examples

Counter canUnderstand: #increment  // => true
Counter canUnderstand: #class      // => true (inherited from ProtoObject)
Counter canUnderstand: #bogus      // => false

Test whether the selector is defined locally in this class (does not check superclasses).

Examples

Counter includesSelector: #increment  // => true
Counter includesSelector: #class      // => false (defined in ProtoObject)

Walk the hierarchy and return the class that defines the given selector, or nil if no class defines it.

Pure Beamtalk — walks self then allSuperclasses.

Examples

Counter whichClassIncludesSelector: #class  // => ProtoObject

Return the names of fields declared in this class (not inherited).

Examples

Counter fieldNames   // => [value]

Return all field names including inherited, in slot order.

Examples

Counter allFieldNames   // => [value]

Return the class-side field (class variable) names declared in this class.

These are the slots declared with classState: (the class-side counterpart to instance-side fieldNames). A distinct selector is required because fieldNames is a call-site-intercepted instance-reflection operation.

Examples

TranscriptStream classVarNames   // => [current]

Return all class-side field names including inherited, in slot order.

Examples

TranscriptStream allClassVarNames   // => [current]

Return the class documentation string, or nil if none set.

Examples

Counter doc           // => nil (or "A counter actor" if set)

Set the class documentation string. Returns the receiver.

Examples

Counter doc: "A counter actor"
Counter doc           // => "A counter actor"

Set the documentation string for a specific method. Returns the receiver.

Examples

Counter setDocForMethod: #increment to: "Increment the counter by 1"
(Counter >> #increment) doc   // => "Increment the counter by 1"

Return the documentation string for a specific method, or nil if no doc is set or the method does not exist.

Examples

Counter docForMethod: #increment   // => "Increase the counter by one." (or nil)
Counter docForMethod: #nonExistent // => nil

Test whether this is a Behaviour (class-describing object).

Examples

Counter isBehaviour   // => true
42 isBehaviour        // => false

Test whether this is a metaclass. Returns false; overridden in Metaclass.

Examples

Counter isMeta   // => false

Test whether this is a Metaclass. Returns false; overridden in Metaclass.

Examples

Counter isMetaclass   // => false
Integer isMetaclass   // => false

Test whether instances of the receiver conform to a protocol.

Structural conformance: the class conforms if it responds to all required selectors of the protocol.

Examples

Integer conformsTo: #Printable    // => true
Integer conformsTo: #Sortable     // => false (if Sortable requires sortKey)

Return the list of protocols this class conforms to.

Returns a list of protocol name symbols, sorted alphabetically.

Examples

Integer protocols   // => [#Printable, #Comparable, ...]

Return the path of the source file this class was compiled from, or nil.

Returns nil for stdlib classes, bootstrap classes, and classes created via ClassBuilder (dynamic classes with no backing file).

Examples

Counter sourceFile   // => "examples/counter.bt"
Integer sourceFile   // => nil (stdlib built-in)

Recompile this class from its source file and hot-swap the BEAM module.

Live actors pick up new code on next message dispatch (BEAM two-version code loading — no state migration needed for method changes).

Raises an error if sourceFile is nil — stdlib and dynamic classes (created via ClassBuilder) cannot be reloaded from source.

Examples

Counter reload              // recompile + hot-swap Counter
Integer reload              // => Error: Integer has no source file — stdlib classes cannot be reloaded

Compile a method from a source body String and install it in this class, attempting to record a durable ChangeLog entry (ADR 0082).

This is the primitive that backs the durable live-patch path. The >> patcher form and compile:source: are distinct front doors that converge at the runtime install chokepoint (>> is not parser sugar for this primitive); both produce the same in-memory patch and ChangeLog entry there (Counter >> increment => body and Counter compile: #increment source: "increment => body" are equivalent in effect). The body is passed as a String value, not concatenated into a >> expression — tools (MCP save_method, the browser "Save" action, the REPL editor) call this directly with the body value so a quote char or multi-line body never has to be escaped back into source.

The patch installs in memory immediately. If this class is backed by an in-project .bt source file, the ChangeLog entry is intended flushable and a later Workspace flush can splice the body back to disk; for stdlib / dynamic / dependency classes the entry is intended flushable: false and flush skips it (the patch is still live in memory). ChangeLog append is best-effort and does not block or undo the successful in-memory install — the install still succeeds even if logging fails. Returns the receiver class.

Examples

Counter compile: #increment source: "increment => self.value := self.value + 1"
// => Counter

Compile and install a method like compile:source:, but record an ephemeral ChangeLog intent (ADR 0082), via a best-effort ChangeLog append that never blocks the in-memory install.

Intended for exploration: spike a candidate fix, run it, and either discard it (ephemeral entries auto-prune on flush and on workspace restart) or promote it by calling compile:source: with the same body to upgrade the intent to durable. The audit trail still records every tryCompile:source: call — visibility into what was tried is part of the ChangeLog's value. Backs the MCP try_method tool. Returns the receiver class.

Examples

Counter tryCompile: #doubled source: "doubled => self.value * 2"
// => Counter

Remove this class from the system, cleaning up all associated state.

Follows Smalltalk convention (Counter removeFromSystem). Performs full cleanup: stops live actors of the class, terminates the class gen_server, removes from class hierarchy ETS table and pg group, and purges the BEAM module.

Safety checks:

• Refuses to remove stdlib/sealed classes (Integer, String, Object, etc.)
• Refuses if class has subclasses (must remove children first)
• Stops all live actors of this class before removal

Examples

Counter removeFromSystem   // => nil (Counter class removed)
Integer removeFromSystem   // => Error: cannot remove stdlib class

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"

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