🥮 mooncakes.io
README

#ref

This package provides functionality for working with mutable references, allowing you to create sharable mutable values that can be modified safely.

#Creating and Accessing References

References can be created using @ref.new(). The reference value can be accessed through the val field:

///|
test "creating and accessing refs" {
  let r1 = @ref.new(42)
  inspect(r1.val, content="42")
}

#Updating Reference Values

The update function allows modifying the contained value using a transformation function:

///|
test "updating refs" {
  let counter = @ref.new(0)
  counter.update(x => x + 1)
  inspect(counter.val, content="1")
  counter.update(x => x * 2)
  inspect(counter.val, content="2")
}

#Mapping References

The map function transforms a reference while preserving the reference wrapper:

///|
test "mapping refs" {
  let num = @ref.new(10)
  let doubled = num.map(x => x * 2)
  inspect(doubled.val, content="20")
  let squared = num.map(x => x * x)
  inspect(squared.val, content="100")
}

#Swapping Reference Values

You can exchange the values of two references using the swap function:

///|
test "swapping refs" {
  let r1 = @ref.new("first")
  let r2 = @ref.new("second")
  @ref.swap(r1, r2)
  inspect(r1.val, content="second")
  inspect(r2.val, content="first")
}

#Temporary Value Protection

The protect function temporarily sets a reference to a value and restores it after executing a block:

///|
test "protected updates" {
  let state = @ref.new(100)
  let mut middle = 0
  let result = state.protect(50, () => {
    middle = state.val
    42
  })
  inspect(middle, content="50")
  inspect(result, content="42")
  inspect(state.val, content="100")
}

This is useful for temporarily modifying state that needs to be restored afterwards.

#
Ref

source
pub(all) struct Ref[T] {
  val : T
}

A simple mutable reference type that allows you to store and modify a value of any type.

test {
  let x = @ref.Ref(42)
  @test.assert_eq(x.val, 42)
  x.val = 100
  @test.assert_eq(x.val, 100)
}
impl Show for Ref[X]
impl Debug for Ref[T]

#
Ref::Ref

source
#alias(new, deprecated="`new` is deprecated, use `Ref` instead")
fn[T] Ref::Ref(x : T) -> Ref[T]

create a reference from value

#
Ref::map

source
fn[T, R] Ref::map(self : Ref[T], f : (T) -> R raise?) -> Ref[R] raise?

Maps the value of a Ref using a given function.

Example

test {
  @test.assert_eq(@ref.new(1).map(a => a + 1).val, 2)
}

#
Ref::protect

source
fn[T, R] Ref::protect(self : Ref[T], a : T, f : () -> R raise?) -> R raise?

This function allows you to temporarily replace the value of a reference with a new value, execute a given function, and then restore the original value of the reference.

Arguments

  • self: The reference whose value will be temporarily replaced.
  • a: The new value to assign to the reference.
  • f: The function to execute while the reference value is replaced.

Returns

The result of executing the provided function f.

Example

test {
  let x = @ref.new(1)
  x.protect(2, () => x.val = 3)
  @test.assert_eq(x.val, 1)
}

#
Ref::swap

source
#as_free_fn
fn[T] Ref::swap(self : Ref[T], that : Ref[T]) -> Unit

Swaps the values of two references.

Example

test {
  let x = @ref.new(1)
  let y = @ref.new(2)
  @ref.swap(x, y)
  @test.assert_eq(x.val, 2)
  @test.assert_eq(y.val, 1)
}

#
Ref::update

source
fn[T] Ref::update(self : Ref[T], f : (T) -> T raise?) -> Unit raise?

Applies f to the current value and stores the result.

#
new

source
fn[T] new(x : T) -> Ref[T]

Same as the Ref constructor.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io