List
List — Ordered collection of elements.
Lists in Beamtalk are Erlang linked lists, created with #() syntax.
Fast prepend (O(1)), sequential access. Use for stack-like and
functional patterns.
BEAM Mapping
Beamtalk lists map directly to Erlang lists.
Examples
#(1, 2, 3) class // => List
#(1, 2, 3) size // => 3
#(1, 2, 3) first // => 1
#(1, 2) ++ #(3, 4) // => #(1, 2, 3, 4)
Methods
- class » withAll: list
- class » new: elements
- size
- isEmpty
- first
- rest
- last
- at: index
- includes: item
- sort
- sort: comparator
- reversed
- unique
- detect: block
- detect: block ifNone: default
- do: block
- collect: block
- select: block
- reject: block
- inject: initial into: block
- take: n
- drop: n
- flatten
- flatMap: block
- count: block
- anySatisfy: block
- allSatisfy: block
- ++ other
- printString
- inspect
- from: start to: end
- indexOf: item
- eachWithIndex: block
- zip: other
- groupBy: block
- partition: block
- takeWhile: block
- dropWhile: block
- intersperse: separator
- addFirst: item
- add: item
- stream
- atRandom
- join
- join: separator
Class Methods
Create a List from a list (identity — a list is already a List).
Used by the species pattern on Collection so that collect: and
select: on a List return a List.
Examples
List class withAll: #(1, 2, 3) // => #(1, 2, 3)
Create a List from a list. Convenience alias for withAll:.
Examples
List new: #(1, 2, 3) // => #(1, 2, 3)
Instance Methods
Number of elements in the list.
Examples
#(1, 2, 3) size // => 3
#() size // => 0
Test if the list has no elements.
Examples
#() isEmpty // => true
#(1) isEmpty // => false
Return the first element.
Examples
#(1, 2, 3) first // => 1
Return all elements except the first (the tail).
Examples
#(1, 2, 3) rest // => #(2, 3)
Return the last element.
Examples
#(1, 2, 3) last // => 3
Return the element at the given 1-based index.
Examples
#(10, 20, 30) at: 2 // => 20
Test if the list contains the given item.
Examples
#(1, 2, 3) includes: 2 // => true
#(1, 2, 3) includes: 9 // => false
Sort the list in ascending order.
Examples
#(3, 1, 2) sort // => #(1, 2, 3)
Sort the list using a custom comparator block.
Examples
#(3, 1, 2) sort: [:a :b | a > b] // => #(3, 2, 1)
Reverse the order of elements.
Examples
#(1, 2, 3) reversed // => #(3, 2, 1)
Remove duplicate elements.
Examples
#(1, 2, 2, 3) unique // => #(1, 2, 3)
Find the first element for which block returns true.
Examples
#(1, 2, 3) detect: [:x | x > 1] // => 2
Find the first element matching block, or evaluate default if none.
Examples
#(1, 2) detect: [:x | x > 5] ifNone: [0] // => 0
Iterate over each element, evaluating block with each one.
Examples
#(1, 2, 3) do: [:x | Transcript show: x]
Collect results of evaluating block on each element.
Examples
#(1, 2, 3) collect: [:x | x * 2] // => #(2, 4, 6)
Select elements for which block returns true.
Examples
#(1, 2, 3, 4) select: [:x | x > 2] // => #(3, 4)
Reject elements for which block returns true.
Examples
#(1, 2, 3, 4) reject: [:x | x > 2] // => #(1, 2)
Reduce the list with an accumulator. Evaluates block with accumulator and each element.
Examples
#(1, 2, 3) inject: 0 into: [:sum :x | sum + x] // => 6
Return the first n elements.
Examples
#(1, 2, 3, 4) take: 2 // => #(1, 2)
Return all elements after the first n.
Examples
#(1, 2, 3, 4) drop: 2 // => #(3, 4)
Flatten one level of nested lists.
Examples
#(#(1, 2), #(3, 4)) flatten // => #(1, 2, 3, 4)
Map each element with block then flatten one level.
Examples
#(1, 2) flatMap: [:x | #(x, x * 10)] // => #(1, 10, 2, 20)
Count elements for which block returns true.
Examples
#(1, 2, 3, 4) count: [:x | x > 2] // => 2
Test if any element satisfies block.
Examples
#(1, 2, 3) anySatisfy: [:x | x > 2] // => true
Test if all elements satisfy block.
Examples
#(2, 4, 6) allSatisfy: [:x | x isEven] // => true
Concatenate two lists.
Examples
#(1, 2) ++ #(3, 4) // => #(1, 2, 3, 4)
Return a developer-readable string representation.
Examples
#(1, 2, 3) printString // => "#(1, 2, 3)"
Override inspect to use printString rather than the field-based format defined in Value. Lists are primitives, not map-based value objects.
Return a subsequence from start to end (1-based, inclusive).
Examples
#(10, 20, 30, 40) from: 2 to: 3 // => #(20, 30)
Return the 1-based index of the first occurrence, or nil if not found.
Examples
#(10, 20, 30) indexOf: 20 // => 2
#(10, 20, 30) indexOf: 99 // => nil
Iterate with both element and 1-based index.
Examples
#("a", "b") eachWithIndex: [:item :i | Transcript show: i]
Combine two lists element-wise into a list of pairs.
Examples
#(1, 2) zip: #("a", "b") // => #(#(1, "a"), #(2, "b"))
Group elements by the result of block into a Dictionary.
Examples
#(1, 2, 3, 4) groupBy: [:x | x isEven]
Partition elements into a Dictionary with "matching" and "nonMatching" keys.
Examples
#(1, 2, 3, 4) partition: [:x | x isEven]
// => Dictionary("matching" -> #(2, 4), "nonMatching" -> #(1, 3))
Take elements from the front while block returns true.
Examples
#(1, 2, 3, 4) takeWhile: [:x | x < 3] // => #(1, 2)
Drop elements from the front while block returns true.
Examples
#(1, 2, 3, 4) dropWhile: [:x | x < 3] // => #(3, 4)
Insert separator between each pair of elements.
Examples
#(1, 2, 3) intersperse: 0 // => #(1, 0, 2, 0, 3)
Prepend an item to the front of the list in O(1) time (returns a new list).
Examples
#(2, 3) addFirst: 1 // => #(1, 2, 3)
#() addFirst: "x" // => #("x")
Append an item to the end of the list (returns a new list).
Examples
#(1, 2) add: 3 // => #(1, 2, 3)
Return a lazy Stream over the list elements.
Examples
(#(1, 2, 3) stream) asList // => #(1, 2, 3)
Return a random element from the list.
Examples
#(10, 20, 30) atRandom // => one of 10, 20, 30
Join a list of strings into a single string (no separator).
Examples
#("a", "b", "c") join // => "abc"
#() join // => ""
Join a list of strings into a single string with a separator.
Examples
#("a", "b", "c") join: ", " // => "a, b, c"
#("hello", "world") join: " " // => "hello world"
Inherited Methods
From Collection
Return the number of elements.
Iterate over each element, evaluating block with each one.
Return a developer-readable string representation.
Return the class used to build results from collection operations.
Used by collect:, select:, and reject: to return the same
collection type as the receiver. Sealed subclasses override this.
Examples
#(1, 2) species // => List
#[1, 2] species // => Array
Test if the collection has no elements.
Examples
#() isEmpty // => true
#(1) isEmpty // => false
Test if the collection has at least one element.
Examples
#(1) isNotEmpty // => true
#() isNotEmpty // => false
Test if the collection contains the given element.
Default implementation iterates with do: and returns early on match.
Subclasses may override with more efficient lookup.
Examples
#(1, 2, 3) includes: 2 // => true
#(1, 2, 3) includes: 9 // => false
Reduce the collection with an accumulator.
Evaluates block with (accumulator, element) for each element.
Returns the final accumulator value.
Kept as @primitive because the pure-BT implementation using do: with
local-variable mutation does not work for abstract-class methods: the
compiler generates lists:foreach (no state threading) instead of
lists:foldl. The Erlang helper calls the block as Block(Acc, Elem)
(accumulator first) to match the Beamtalk block value: acc value: each
convention expected by collect:, select:, and reject:.
Examples
#(1, 2, 3) inject: 0 into: [:sum :x | sum + x] // => 6
Collect results of evaluating block on each element.
Returns a collection of the same type as the receiver (species pattern).
Builds the result in reverse using addFirst: then converts via species withAll:.
Examples
#(1, 2, 3) collect: [:x | x * 2] // => #(2, 4, 6)
Select elements for which block returns true.
Returns a collection of the same type as the receiver (species pattern).
Builds the result in reverse using addFirst: then converts via species withAll:.
Examples
#(1, 2, 3, 4) select: [:x | x > 2] // => #(3, 4)
Reject elements for which block returns true.
Examples
#(1, 2, 3, 4) reject: [:x | x > 2] // => #(1, 2)
Find the first element for which block returns true.
Returns nil if no element matches. Uses ^ (non-local return) for
early exit — this compiles to throw/catch on BEAM.
Examples
#(1, 2, 3) detect: [:x | x > 1] // => 2
Find the first element matching block, or evaluate noneBlock if none.
Uses ^ (non-local return) for early exit — compiles to throw/catch on BEAM.
Examples
#(1, 2) detect: [:x | x > 5] ifNone: [0] // => 0
Test if any element satisfies block.
Uses ^ (non-local return) for early exit — compiles to throw/catch on BEAM.
Examples
#(1, 2, 3) anySatisfy: [:x | x > 2] // => true
Test if all elements satisfy block.
Uses ^ (non-local return) for early exit — compiles to throw/catch on BEAM.
Examples
#(2, 4, 6) allSatisfy: [:x | x isEven] // => true
Return a string representation.
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.
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