Behaviour

Inherits from Object

Abstract

Behaviour — Abstract superclass of all class-describing objects.

Provides method dictionary access, hierarchy queries, and instance creation protocol for class objects. Every class (Counter, Integer, Actor subclasses, etc.) is an instance of Class, which inherits from Behaviour.

In Smalltalk terms, Behaviour defines the protocol shared by Class and Metaclass. In Beamtalk, class objects dispatch to Behaviour methods via the class-side fallback chain.

All Behaviour methods are sealed — users cannot override the class protocol. This limits the blast radius of class protocol changes.

Examples

Counter superclass             // => Actor
Counter subclasses             // => []
Counter canUnderstand: #class  // => true
Counter methods                // => [increment, getValue]

Instance Methods

>> aSelector Sealed source

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

superclass Sealed source

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

Examples

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

allSuperclasses Sealed source

Return all superclasses in order from immediate parent to root.

Examples

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

subclasses Sealed source

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

Examples

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

allSubclasses Sealed source

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

Examples

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

inheritsFrom: aClass Sealed source

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

includesBehaviour: aBehaviour Sealed source

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

methods Sealed source

Return selectors defined on this class (not inherited).

Examples

Counter methods   // => [increment, getValue]

allMethods Sealed source

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:, ...]

canUnderstand: selector Sealed source

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

includesSelector: selector Sealed source

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)

whichClassIncludesSelector: selector Sealed source

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

fieldNames Sealed source

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

Examples

Counter fieldNames   // => [value]

allFieldNames Sealed source

Return all field names including inherited, in slot order.

Examples

Counter allFieldNames   // => [value]

doc Sealed source

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

Examples

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

doc: aString Sealed source

Set the class documentation string. Returns the receiver.

Examples

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

setDocForMethod: aSelector to: aString Sealed source

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"

docForMethod: aSelector Sealed source

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

isBehaviour Sealed source

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

Examples

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

isMeta Sealed source

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

Examples

Counter isMeta   // => false

isMetaclass Sealed source

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

Examples

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

conformsTo: protocolName Sealed source

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)

protocols Sealed source

Return the list of protocols this class conforms to.

Returns a list of protocol name symbols, sorted alphabetically.

Examples

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

sourceFile Sealed source

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)

reload Sealed source

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

removeFromSystem Sealed source

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

Inherited Methods

From Object

class

Return the class of the receiver.

Examples

42 class              // => Integer
"hello" class         // => String

isNil

Test if the receiver is nil. Returns false for all objects except nil.

Examples

42 isNil              // => false
nil isNil             // => true

notNil

Test if the receiver is not nil. Returns true for all objects except nil.

Examples

42 notNil             // => true
nil notNil            // => false

ifNil: _nilBlock

If the receiver is nil, evaluate nilBlock. Otherwise return self.

Examples

42 ifNil: [0]         // => 42
nil ifNil: [0]        // => 0

ifNotNil: notNilBlock

If the receiver is not nil, evaluate notNilBlock with self.

Examples

42 ifNotNil: [:v | v + 1]   // => 43
nil ifNotNil: [:v | v + 1]  // => nil

ifNil: _nilBlock ifNotNil: notNilBlock

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

ifNotNil: notNilBlock ifNil: _nilBlock

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

printString

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"

displayString

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

Inspect the receiver.

Examples

42 inspect             // => "42"

yourself Sealed

Return the receiver itself. Useful for cascading side effects.

Examples

42 yourself            // => 42

hash

Return a hash value for the receiver.

Examples

42 hash

respondsTo: selector Sealed

Test if the receiver responds to the given selector.

Examples

42 respondsTo: #abs    // => true

fieldNames Sealed

Return the names of fields.

Examples

42 fieldNames             // => #()

fieldAt: name Sealed

Return the value of the named field.

Examples

object fieldAt: #name

fieldAt: name put: value Sealed

Set the value of the named field (returns new state).

Examples

object fieldAt: #name put: "Alice"

perform: selector Sealed

Send a unary message dynamically.

Examples

42 perform: #abs       // => 42

perform: selector withArguments: args Sealed

Send a message dynamically with arguments.

Examples

3 perform: #max: withArguments: #(5)   // => 5

subclassResponsibility

Raise an error indicating this method must be overridden by a subclass.

Examples

self subclassResponsibility

notImplemented

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

show: aValue

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: "

showCr: aValue

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"

isKindOf: aClass

Test if the receiver is an instance of aClass or any of its subclasses.

Examples

42 isKindOf: Integer    // => true
42 isKindOf: Object     // => true
#foo isKindOf: Symbol   // => true
#foo isKindOf: String   // => false

error: message

Raise an error with the given message.

Examples

self error: "something went wrong"

From ProtoObject

== other

Test value equality (Erlang ==).

Examples

42 == 42           // => true
"abc" == "abc"     // => true

/= other

Test value inequality (negation of ==).

Examples

1 /= 2             // => true
42 /= 42           // => false

class

Return the class of the receiver.

Examples

42 class            // => Integer
"hello" class       // => String

doesNotUnderstand: selector args: arguments

Handle messages the receiver does not understand. Override for custom dispatch.

Examples

42 unknownMessage   // => ERROR: does_not_understand

perform: selector withArguments: arguments

Send a message dynamically with an arguments list.

Examples

42 perform: #abs withArguments: #()   // => 42

performLocally: selector withArguments: arguments

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)

perform: selector withArguments: arguments timeout: timeoutMs

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