<A>(self: MutableList<A>, messages: Iterable<A>): numberAppends all elements from an iterable to the end of the MutableList. Returns the number of elements added.
Example (Appending multiple elements)
import { MutableList } from "effect"
const list = MutableList.make<number>()
MutableList.append(list, 1)
MutableList.append(list, 2)
// Append multiple elements
const added = MutableList.appendAll(list, [3, 4, 5])
console.log(added) // 3
console.log(list.length) // 5
// Elements maintain order: [1, 2, 3, 4, 5]
console.log(MutableList.takeAll(list)) // [1, 2, 3, 4, 5]
// Works with any iterable
const newList = MutableList.make<string>()
MutableList.appendAll(newList, new Set(["a", "b", "c"]))
console.log(MutableList.takeAll(newList)) // ["a", "b", "c"]
// Useful for bulk loading
const bulkList = MutableList.make<number>()
const count = MutableList.appendAll(
bulkList,
Array.from({ length: 1000 }, (_, i) => i)
)
console.log(count) // 1000export const const appendAll: <A>(
self: MutableList<A>,
messages: Iterable<A>
) => number
Appends all elements from an iterable to the end of the MutableList.
Returns the number of elements added.
Example (Appending multiple elements)
import { MutableList } from "effect"
const list = MutableList.make<number>()
MutableList.append(list, 1)
MutableList.append(list, 2)
// Append multiple elements
const added = MutableList.appendAll(list, [3, 4, 5])
console.log(added) // 3
console.log(list.length) // 5
// Elements maintain order: [1, 2, 3, 4, 5]
console.log(MutableList.takeAll(list)) // [1, 2, 3, 4, 5]
// Works with any iterable
const newList = MutableList.make<string>()
MutableList.appendAll(newList, new Set(["a", "b", "c"]))
console.log(MutableList.takeAll(newList)) // ["a", "b", "c"]
// Useful for bulk loading
const bulkList = MutableList.make<number>()
const count = MutableList.appendAll(
bulkList,
Array.from({ length: 1000 }, (_, i) => i)
)
console.log(count) // 1000
appendAll = <function (type parameter) A in <A>(self: MutableList<A>, messages: Iterable<A>): numberA>(self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
interface MutableList<in out A>A mutable linked list data structure optimized for high-throughput operations.
MutableList provides efficient append/prepend operations and is ideal for
producer-consumer patterns, queues, and streaming scenarios.
Example (Creating and consuming a mutable list)
import { MutableList } from "effect"
// Create a mutable list
const list: MutableList.MutableList<number> = MutableList.make()
// Add elements
MutableList.append(list, 1)
MutableList.append(list, 2)
MutableList.prepend(list, 0)
// Access properties
console.log(list.length) // 3
console.log(list.head?.array) // Contains elements from head bucket
console.log(list.tail?.array) // Contains elements from tail bucket
// Take elements
console.log(MutableList.take(list)) // 0
console.log(MutableList.take(list)) // 1
console.log(MutableList.take(list)) // 2
The MutableList namespace contains type definitions and utilities for working
with mutable linked lists.
Example (Typing queue processors)
import { MutableList } from "effect"
// Type annotation using the namespace
const processQueue = (queue: MutableList.MutableList<string>) => {
while (queue.length > 0) {
const item = MutableList.take(queue)
if (item !== MutableList.Empty) {
console.log("Processing:", item)
}
}
}
// Using the namespace for type definitions
const createProcessor = <T>(): {
queue: MutableList.MutableList<T>
add: (item: T) => void
process: () => Array<T>
} => {
const queue = MutableList.make<T>()
return {
queue,
add: (item) => MutableList.append(queue, item),
process: () => MutableList.takeAll(queue)
}
}
MutableList<function (type parameter) A in <A>(self: MutableList<A>, messages: Iterable<A>): numberA>, messages: Iterable<A>messages: interface Iterable<T, TReturn = any, TNext = any>Iterable<function (type parameter) A in <A>(self: MutableList<A>, messages: Iterable<A>): numberA>): number =>
const appendAllUnsafe: <A>(
self: MutableList<A>,
messages: ReadonlyArray<A>,
mutable?: boolean
) => number
Appends all elements from a ReadonlyArray to the end of the MutableList.
This is an optimized version that can reuse the array when mutable=true.
Returns the number of elements added.
When to use
Use when appending a trusted array directly is worth the optimized path and
you control whether the input may be reused.
Gotchas
When mutable=true, the input array may be modified internally. Only use
mutable=true when you control the array lifecycle.
Example (Appending arrays with optional mutation)
import { MutableList } from "effect"
const list = MutableList.make<number>()
MutableList.append(list, 1)
// Safe usage (default mutable=false)
const items = [2, 3, 4]
const added = MutableList.appendAllUnsafe(list, items)
console.log(added) // 3
console.log(items) // [2, 3, 4] - unchanged
// Unsafe but efficient usage (mutable=true)
const mutableItems = [5, 6, 7]
MutableList.appendAllUnsafe(list, mutableItems, true)
// mutableItems may be modified internally for efficiency
console.log(MutableList.takeAll(list)) // [1, 2, 3, 4, 5, 6, 7]
// High-performance bulk operations
const bigArray = new Array(10000).fill(0).map((_, i) => i)
MutableList.appendAllUnsafe(list, bigArray, true) // Very efficient
appendAllUnsafe(self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
import ArrArr.fromIterable(messages: Iterable<A>messages), !var Array: ArrayConstructorArray.ArrayConstructor.isArray(arg: any): arg is any[]isArray(messages: Iterable<A>messages))