<A>(self: MutableList<A>, n: number): voidRemoves up to n elements from the beginning of the MutableList without
returning them.
When to use
Use to discard a bounded number of values from the head of a MutableList
when the removed values are not needed.
Details
If n is less than or equal to zero, or the list is empty, the list is left
unchanged. If n is greater than or equal to the current length, the list is
cleared.
export const const takeNVoid: <A>(
self: MutableList<A>,
n: number
) => void
Removes up to n elements from the beginning of the MutableList without
returning them.
When to use
Use to discard a bounded number of values from the head of a MutableList
when the removed values are not needed.
Details
If n is less than or equal to zero, or the list is empty, the list is left
unchanged. If n is greater than or equal to the current length, the list is
cleared.
takeNVoid = <function (type parameter) A in <A>(self: MutableList<A>, n: number): voidA>(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>, n: number): voidA>, n: numbern: number): void => {
if (n: numbern <= 0 || !self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<A>.head: MutableList.Bucket<A> | undefinedhead) return
n: numbern = var Math: MathAn intrinsic object that provides basic mathematics functionality and constants.
Math.Math.min(...values: number[]): numberReturns the smaller of a set of supplied numeric expressions.
min(n: numbern, self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<in out A>.length: numberlength)
if (n: numbern === self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<in out A>.length: numberlength && self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<A>.head: MutableList.Bucket<A>(property) MutableList<A>.head: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
MutableList<in out A>.Bucket<A>.offset: numberoffset === 0 && !self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<A>.head: MutableList.Bucket<A>(property) MutableList<A>.head: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
MutableList<in out A>.Bucket<A>.next: MutableList.Bucket<A> | undefinednext) {
const clear: <A>(
self: MutableList<A>
) => void
Removes all elements from the MutableList, resetting it to an empty state.
This operation is highly optimized and releases all internal memory.
Example (Clearing a mutable list)
import { MutableList } from "effect"
const list = MutableList.make<number>()
MutableList.appendAll(list, [1, 2, 3, 4, 5])
console.log(list.length) // 5
// Clear all elements
MutableList.clear(list)
console.log(list.length) // 0
console.log(MutableList.take(list)) // Empty
// Can still use the list after clearing
MutableList.append(list, 42)
console.log(list.length) // 1
// Useful for resetting queues or buffers
function resetBuffer<T>(buffer: MutableList.MutableList<T>) {
MutableList.clear(buffer)
console.log("Buffer cleared and ready for reuse")
}
clear(self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
let count: numbercount = 0
let let chunk:
| MutableList.Bucket<A>
| undefined
interface MutableList<in out A>.Bucket<A>Storage node used by the exposed head and tail fields of a
MutableList.
Details
Most code should treat buckets as an implementation detail and use
MutableList operations such as append, prepend, and take instead
of constructing or mutating buckets directly.
Example (Inspecting buckets)
import { MutableList } from "effect"
const list = MutableList.make<number>()
MutableList.append(list, 1)
MutableList.append(list, 2)
// Access bucket information (for debugging or advanced usage)
const inspectBucket = (
bucket: MutableList.MutableList.Bucket<number> | undefined
) => {
if (bucket) {
console.log("Bucket array:", bucket.array)
console.log("Bucket offset:", bucket.offset)
console.log("Bucket mutable:", bucket.mutable)
console.log("Has next bucket:", bucket.next !== undefined)
}
}
inspectBucket(list.head)
inspectBucket(list.tail)
Bucket<function (type parameter) A in <A>(self: MutableList<A>, n: number): voidA> | undefined = self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<A>.head: MutableList.Bucket<A>(property) MutableList<A>.head: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
let chunk:
| MutableList.Bucket<A>
| undefined
const size: numbersize = let chunk: MutableList.Bucket<A>let chunk: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
MutableList<in out A>.Bucket<A>.array: A[]array.Array<T>.length: numberGets or sets the length of the array. This is a number one higher than the highest index in the array.
length - let chunk: MutableList.Bucket<A>let chunk: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
MutableList<in out A>.Bucket<A>.offset: numberoffset
if (let count: numbercount + const size: numbersize > n: numbern) {
let chunk: MutableList.Bucket<A>let chunk: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
MutableList<in out A>.Bucket<A>.offset: numberoffset += n: numbern - let count: numbercount
self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<A>.head: MutableList.Bucket<A> | undefinedhead = let chunk: MutableList.Bucket<A>let chunk: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}
MutableList<in out A>.length: numberlength -= n: numbern
return
}
let count: numbercount += const size: numbersize
let chunk:
| MutableList.Bucket<A>
| undefined
let chunk: MutableList.Bucket<A>let chunk: {
array: Array<A>;
mutable: boolean;
offset: number;
next: Bucket<A> | undefined;
}
MutableList<in out A>.Bucket<A>.next: MutableList.Bucket<A> | undefinednext
}
const clear: <A>(
self: MutableList<A>
) => void
Removes all elements from the MutableList, resetting it to an empty state.
This operation is highly optimized and releases all internal memory.
Example (Clearing a mutable list)
import { MutableList } from "effect"
const list = MutableList.make<number>()
MutableList.appendAll(list, [1, 2, 3, 4, 5])
console.log(list.length) // 5
// Clear all elements
MutableList.clear(list)
console.log(list.length) // 0
console.log(MutableList.take(list)) // Empty
// Can still use the list after clearing
MutableList.append(list, 42)
console.log(list.length) // 1
// Useful for resetting queues or buffers
function resetBuffer<T>(buffer: MutableList.MutableList<T>) {
MutableList.clear(buffer)
console.log("Buffer cleared and ready for reuse")
}
clear(self: MutableList<A>(parameter) self: {
head: MutableList.Bucket<A> | undefined;
tail: MutableList.Bucket<A> | undefined;
length: number;
}