Supervisor
Supervisor — Abstract base class for static OTP supervision trees.
Subclass Supervisor to define a static supervision tree: one whose
children are known at startup. Override class children to return
the list of child classes (or SupervisionSpec values for per-child
configuration). All other configuration methods have sensible defaults
that can be selectively overridden.
See ADR 0059 for the full design.
Examples
Supervisor subclass: WebApp
class children => #(DatabasePool HTTPRouter MetricsCollector)
app := (WebApp supervise) unwrap
app count // => 3
@see DynamicSupervisor (for runtime-added children) @see Actor (base class for supervised processes) @see SupervisionSpec (for per-child configuration)
Methods
Class Methods
OTP supervisor restart strategy.
Valid values: #oneForOne, #oneForAll, #restForOne.
Default: #oneForOne.
Maximum number of restarts within restartWindow seconds.
If this rate is exceeded, the supervisor itself shuts down.
Time window in seconds for the maxRestarts rate limit.
Whether this class is a supervisor (always true for Supervisor subclasses).
Used by SupervisionSpec childSpec to determine type and shutdown.
Return the list of child classes (or SupervisionSpec values) for this supervisor.
Must be overridden by concrete subclasses. Raises SubclassResponsibility otherwise.
Examples
Supervisor subclass: WebApp
class children => #(DatabasePool HTTPRouter)
Lifecycle hook called after all children have started.
Override to perform post-start wiring (e.g., discovering siblings
via which: or injecting dependencies). Runs in the caller's
process, so which: and other supervisor calls will not deadlock.
Examples
Supervisor subclass: App
class children => #(Store, Engine)
class initialize: sup =>
engine := (sup which: Engine) unwrap
store := (sup which: Store) unwrap
engine connectStore: store
Start this supervisor (or return the already-running instance).
Registers the supervisor under its class name. Subsequent calls to
supervise or current return the running instance.
ADR 0080 Phase 2 (BT-1999): returns Result(Self, Error) so subclass
typing is preserved (e.g. MySupervisor supervise unwrap is typed as
MySupervisor, not the abstract Supervisor base). Use unwrap for
boot-style "crash on failure" call sites, or ifOk:ifError: /
andThen: for recoverable starts. Failures surface as
Result error: #beamtalk_error{kind = supervisor_start_failed}.
Return the running supervisor instance, or nil if not started.
Instance Methods
Return the OTP child ids of currently-running children.
BT-1997 / ADR 0080 Phase 1: whichChildren/1 returns a Result-shaped
value; call unwrap at the FFI boundary so the user-facing signature is
a list of child-id Symbols while the runtime migrates to Result returns.
Stdlib signature updates land in Phase 2 (BT-P2-stdlib).
BT-2254: now that FFI list element types are carried, whichChildren's
{ok, [atom()]} spec resolves unwrap to List(Symbol). The declared
return type matches that inferred body type so no type-mismatch warning
is produced (the runtime value is a list of atoms, i.e. List(Symbol)).
Look up the running child process for the given class.
ADR 0080 Phase 2 (BT-2041): returns Result(Object, Error). The ok
variant spans Object | nil — a class with no running child returns
Result ok: nil, not an error. Genuine failures (e.g. supervisor
process dead) surface as Result error: #beamtalk_error{kind = stale_handle}.
Terminate the running child process for the given class.
ADR 0080 Phase 2 (BT-1999): returns Result(Nil, Error). Idempotent
on not_found — terminating an already-gone child returns Result ok: nil.
Genuine failures surface as
Result error: #beamtalk_error{kind = terminate_failed}.
Return the count of currently-running children.
BT-1997 / ADR 0080 Phase 1: countChildren/1 returns a Result-shaped
value; call unwrap at the FFI boundary to preserve the pre-migration
user-facing signature.
Stop this supervisor and all its children.
BT-1997 / ADR 0080 Phase 1: stop/1 returns a Result-shaped value;
call unwrap at the FFI boundary to preserve the pre-migration
user-facing signature.
Inherited Methods
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