WorkspaceInterface
WorkspaceInterface — Per-workspace actor introspection and binding container.
Modeled on Squeak 5.2+'s Environment class: a scoped container for
workspace-level bindings and actor introspection. Each workspace has its
own WorkspaceInterface instance.
The singleton instance is set during workspace bootstrap (ADR 0019 Phase 2).
The convenience binding Workspace is also available after bootstrap.
Examples
WorkspaceInterface current actors
WorkspaceInterface current actorAt: "<0.132.0>"
WorkspaceInterface current actorsOf: Counter
Methods
Class Methods
Return the current singleton instance.
Instance Methods
Return a list of all live actors as object references.
Examples
Workspace actors
Look up a specific actor by pid string.
Examples
Workspace actorAt: "<0.132.0>"
Return all actors of a given class.
Examples
Workspace actorsOf: Counter
Return a list of loaded user classes with source file info.
Examples
Workspace classes
Return classes that are TestCase subclasses.
Examples
Workspace testClasses
Return an immutable Dictionary snapshot of the project namespace.
Includes workspace singletons (Transcript, Beamtalk, Workspace), user-registered bindings (bind:as:), and all user-loaded classes.
Examples
Workspace globals
Sync the project: incrementally compile all changed files.
Scans the current working directory for a beamtalk.toml project
manifest, then finds .bt and .erl files, compiles changed files
in dependency order, and returns a result Dictionary.
The result Dictionary contains:
#summary— human-readable summary String#classes— List of loaded class name Strings#errors— List of error Dictionaries (empty on success)#changedCount— number of files reloaded#unchangedCount— number of unchanged files#deletedCount— number of deleted files
Examples
Workspace sync // => #{#summary => "Reloaded 2 of 5 files (3 unchanged)", ...}
(Workspace sync) at: #summary // => "Reloaded 2 of 5 files (3 unchanged)"
Compile and load a .bt file, registering the class. Returns a List of loaded class objects (empty if none resolved). Returns a structured error if path is not a String or the file cannot be loaded.
Examples
Workspace load: "examples/counter.bt" // => [Counter]
Run all loaded test classes and return a TestResult.
Examples
Workspace test
Run a specific test class and return a TestResult.
Examples
Workspace test: CounterTest
Register a value in the workspace namespace under a given name. Subsequent REPL evals can reference the value by name. Raises an error if name exists in Beamtalk globals (system name conflict). Warns if name is an existing loaded class (use reload instead).
Examples
Workspace bind: myActor as: #MyTool
Remove a registered name from the workspace namespace. Raises an error if name is not found.
Examples
Workspace unbind: #MyTool
Return the OTP application root supervisor, or nil if not configured.
Returns the Supervisor instance registered when a package with
[application] supervisor = "ClassName" starts. Returns nil if the
application has not been started with an OTP supervisor root.
Examples
Workspace supervisor // => #Supervisor<AppSup, <0.200.0>>
Workspace supervisor children // => #(#DatabasePool #HTTPRouter)
Start and attach a supervisor to the workspace supervision tree.
The class must be a Supervisor or DynamicSupervisor subclass. Idempotent: returns the existing instance if already attached. Supports iterative development — stop and re-attach after reloading.
Examples
Workspace startSupervisor: MySup // => #Supervisor<MySup, <0.200.0>>
Workspace startSupervisor: MySup // => #Supervisor<MySup, <0.200.0>> (idempotent)
Stop and remove a supervisor from the workspace.
Works for both workspace-attached supervisors and the root application supervisor. Cleanly shuts down the supervisor and all its children. Raises an error if the supervisor is not running or not visible.
Examples
Workspace stopSupervisor: MySup // => nil
List all supervisors visible from the workspace.
Returns the root application supervisor (if registered) and all
supervisors attached via startSupervisor:. The root supervisor
is not part of the workspace supervision tree but is included
for discoverability.
Examples
Workspace supervisors // => #(#Supervisor<MySup, <0.200.0>>)
Return a Dictionary of direct dependency packages for the current workspace.
Keys are package name Strings, values are Package objects. Returns an empty Dictionary if the workspace has no declared dependencies.
Examples
Workspace dependencies
// => _
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.
Examples
42 isKindOf: Integer // => true
42 isKindOf: Object // => true
#foo isKindOf: Symbol // => true
#foo isKindOf: String // => false
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