🥮 mooncakes.io
    Sign in

    mizchi/luna/luna/signal does not have a README file

    Snapshot

    source
    pub trait Snapshot {
      snapshot(Self) -> Self
    }

    Trait for signal records that can produce a snapshot

    AsyncState

    source
    pub enum AsyncState[T] {
      Pending
      Success(T)
      Failure(String)
    }

    Async state representation - environment independent

    AsyncState::error

    source
    fn[T] AsyncState::error(self : AsyncState[T]) -> String?

    Get error if failure, None otherwise

    AsyncState::is_failure

    source
    fn[T] AsyncState::is_failure(self : AsyncState[T]) -> Bool

    Check if state is failure

    AsyncState::is_pending

    source
    fn[T] AsyncState::is_pending(self : AsyncState[T]) -> Bool

    Check if state is pending

    AsyncState::is_success

    source
    fn[T] AsyncState::is_success(self : AsyncState[T]) -> Bool

    Check if state is success

    AsyncState::value

    source
    fn[T] AsyncState::value(self : AsyncState[T]) -> T?

    Get value if success, None otherwise

    Context

    source
    pub struct Context[T] {
      id : Int
      default_value : () -> T
      providers : Array[(Int, () -> T)]
    }

    Context type with typed getter The current_getter is managed per-context and tracks the current value chain

    EffectRunner

    source
    pub struct EffectRunner {
      id : Int
      run : () -> Unit
    }

    Effect wrapper with unique ID for deduplication

    Lens

    source
    pub struct Lens[S, A] {
      get : (S) -> A
      set : (S, A) -> S
    }

    A lens focuses on a specific part of a larger structure

    Lens::new

    source
    fn[S, A] Lens::new(get : (S) -> A, set : (S, A) -> S) -> Lens[S, A]

    LensStore

    source
    pub struct LensStore[T] {
      source : Signal[T]
    }

    A store with lens-based field access Each focused lens creates a derived signal that only updates when that field changes

    LensStore::focus

    source
    fn[T, A : Eq] LensStore::focus(self : LensStore[T], lens : Lens[T, A]) -> (Signal[A], (A) -> Unit)

    Focus on a field using a lens, returns getter and setter functions The getter is memoized and only recomputes when the focused value changes Uses render_effect for synchronous updates

    LensStore::new

    source
    fn[T] LensStore::new(initial : T) -> LensStore[T]

    LensStore::snapshot

    source
    fn[T] LensStore::snapshot(self : LensStore[T]) -> T

    Get the current snapshot of the entire store

    LensStore::update

    source
    fn[T] LensStore::update(self : LensStore[T], f : (T) -> T) -> Unit

    Update the entire store

    Owner

    source
    pub struct Owner {
      id : Int
      parent : Owner?
      children : Array[Owner]
      cleanups : Array[() -> Unit]
      disposers : Array[() -> Unit]
      disposed : Bool
    }

    Owner - manages lifecycle of reactive computations (Solid.js style)

    Owner::dispose

    source
    fn Owner::dispose(self : Owner) -> Unit

    Dispose this owner and all its children

    Owner::new

    source
    fn Owner::new(parent : Owner?) -> Owner

    Create a new Owner

    Resource

    source
    pub struct Resource[T] {
      state : Signal[AsyncState[T]]
      // private fields
    }

    Resource - Async value container with Signal integration Environment-agnostic: uses callbacks instead of Promise/async directly

    Resource::error

    source
    fn[T] Resource::error(self : Resource[T]) -> String?

    Get error if failure

    Resource::get

    source
    fn[T] Resource::get(self : Resource[T]) -> AsyncState[T]

    Get current async state (reactive)

    Resource::is_failure

    source
    fn[T] Resource::is_failure(self : Resource[T]) -> Bool

    Check if failed

    Resource::is_pending

    source
    fn[T] Resource::is_pending(self : Resource[T]) -> Bool

    Check if currently pending

    Resource::is_success

    source
    fn[T] Resource::is_success(self : Resource[T]) -> Bool

    Check if successfully loaded

    Resource::peek

    source
    fn[T] Resource::peek(self : Resource[T]) -> AsyncState[T]

    Peek current state without tracking

    Resource::refetch

    source
    fn[T] Resource::refetch(self : Resource[T]) -> Unit

    Trigger refetch

    Resource::value

    source
    fn[T] Resource::value(self : Resource[T]) -> T?

    Get value if success

    Signal

    source
    pub struct Signal[T] {
      value : T
      subscribers : Array[EffectRunner]
    }

    Signal type - holds a value and notifies subscribers on change. A reactive primitive that stores a value and automatically tracks dependencies.
    test {
      let count = @signal.signal(0)
      inspect(count.get(), content="0")
      count.set(5)
      inspect(count.get(), content="5")
    }

    Signal::clear_subscribers

    source
    fn[T] Signal::clear_subscribers(self : Signal[T]) -> Unit

    Clear all subscribers (for cleanup)

    Signal::filter

    source
    fn[T] Signal::filter(self : Signal[T], predicate : (T) -> Bool) -> Signal[T?]

    Filter signal updates - only updates when predicate is true. Returns a signal that only updates when predicate passes.
    test {
      let num = @signal.signal(0)
      let even_only = num.filter(fn(n) { n % 2 == 0 })
      inspect(even_only.get(), content="Some(0)") // 0 hasn't passed through filter yet
      num.set(1) // Odd, filtered out
      num.set(2) // Even, passes
      inspect(even_only.get(), content="Some(2)")
      num.set(3) // Odd, filtered out
      inspect(even_only.get(), content="Some(2)") // Still 2
    }

    Signal::filter_map

    source
    fn[T, U] Signal::filter_map(self : Signal[T], f : (T) -> U?) -> Signal[U?]

    Filter and map signal updates Uses render_effect for synchronous execution

    Signal::get

    source
    fn[T] Signal::get(self : Signal[T]) -> T

    Get the current value and track dependency if inside an effect. When called inside an effect or memo, automatically subscribes to changes.
    test {
      let count = @signal.signal(0)
      let log : Array[Int] = []
      let _ = @signal.render_effect(fn() { log.push(count.get()) })
      count.set(1)
      count.set(2)
      inspect(log, content="[0, 1, 2]")
    }

    Signal::map

    source
    fn[T, U] Signal::map(self : Signal[T], f : (T) -> U) -> (() -> U)

    Map a signal's value through a function. Returns a getter function (like memo) that recomputes when the signal changes.
    test {
      let count = @signal.signal(5)
      let doubled = count.map(fn(n) { n * 2 })
      inspect(doubled(), content="10")
      count.set(7)
      inspect(doubled(), content="14")
    }

    Signal::new

    source
    fn[T] Signal::new(initial : T) -> Signal[T]

    Create a new signal with initial value.
    test {
      let name = @signal.Signal::new("Alice")
      inspect(name.get(), content="Alice")
    }

    Signal::peek

    source
    fn[T] Signal::peek(self : Signal[T]) -> T

    Get value without tracking (won't create dependency). Useful when you need to read a signal without subscribing to it.
    test {
      let count = @signal.signal(0)
      let runs : Ref[Int] = { val: 0 }
      let _ = @signal.render_effect(fn() {
        // peek() won't create dependency
        let _ = count.peek()
        runs.val = runs.val + 1
      })
      count.set(1)
      count.set(2)
      // Effect only ran once (initial), not on updates
      inspect(runs.val, content="1")
    }

    Signal::remove_subscriber

    source
    fn[T] Signal::remove_subscriber(self : Signal[T], id : Int) -> Unit

    Remove a specific subscriber by ID

    Signal::set

    source
    fn[T] Signal::set(self : Signal[T], new_value : T) -> Unit

    Set a new value and notify all subscribers.
    test {
      let count = @signal.signal(0)
      count.set(42)
      inspect(count.get(), content="42")
    }

    Signal::subscriber_count

    source
    fn[T] Signal::subscriber_count(self : Signal[T]) -> Int

    Get number of subscribers (for debugging)

    Signal::to_getter

    source
    fn[T] Signal::to_getter(self : Signal[T]) -> (() -> T)

    Create a read-only getter for a signal

    Signal::update

    source
    fn[T] Signal::update(self : Signal[T], f : (T) -> T) -> Unit

    Update the value using a function. Useful for updating based on current value.
    test {
      let count = @signal.signal(10)
      count.update(fn(n) { n * 2 })
      inspect(count.get(), content="20")
      count.update(fn(n) { n + 5 })
      inspect(count.get(), content="25")
    }

    SplitStore2

    source
    pub struct SplitStore2[A, B] {
      field1 : Signal[A]
      field2 : Signal[B]
    }

    A record where each field is an independent Signal This is the most performant approach - updates only affect specific fields

    SplitStore2::new

    source
    fn[A, B] SplitStore2::new(v1 : A, v2 : B) -> SplitStore2[A, B]

    SplitStore3

    source
    pub struct SplitStore3[A, B, C] {
      field1 : Signal[A]
      field2 : Signal[B]
      field3 : Signal[C]
    }

    3-field version

    SplitStore3::new

    source
    fn[A, B, C] SplitStore3::new(v1 : A, v2 : B, v3 : C) -> SplitStore3[A, B, C]

    all

    source
    fn all(signals : Array[Signal[Bool]]) -> (() -> Bool)

    Create a signal that is true when all input signals are true.
    test {
      let a = @signal.signal(true)
      let b = @signal.signal(true)
      let c = @signal.signal(false)
      let all_true = @signal.all([a, b, c])
      inspect(all_true(), content="false")
      c.set(true)
      inspect(all_true(), content="true")
      a.set(false)
      inspect(all_true(), content="false")
    }

    any

    source
    fn any(signals : Array[Signal[Bool]]) -> (() -> Bool)

    Create a signal that is true when any input signal is true.
    test {
      let a = @signal.signal(false)
      let b = @signal.signal(false)
      let any_true = @signal.any([a, b])
      inspect(any_true(), content="false")
      a.set(true)
      inspect(any_true(), content="true")
    }

    batch

    source
    fn[T] batch(f : () -> T) -> T

    Run a function in a batch - all signal updates are batched. Effects only run once after all updates complete.
    test {
      let a = @signal.signal(0)
      let b = @signal.signal(0)
      let runs : Ref[Int] = { val: 0 }
      let _ = @signal.render_effect(fn() {
        let _ = a.get() + b.get()
        runs.val = runs.val + 1
      })
      inspect(runs.val, content="1") // Initial run
      @signal.batch(fn() {
        a.set(1)
        b.set(2)
      })
      // Only one additional run, not two
      inspect(runs.val, content="2")
    }

    batch_end

    source
    fn batch_end() -> Unit

    End a batch update - run all pending effects

    batch_start

    source
    fn batch_start() -> Unit

    Start a batch update - effects won't run until batch ends

    combine2

    source
    fn[A, B, R] combine2(a : Signal[A], b : Signal[B], f : (A, B) -> R) -> (() -> R)

    Combine two signals into one. The getter recomputes when either signal changes.
    test {
      let first = @signal.signal("Hello")
      let last = @signal.signal("World")
      let full = @signal.combine2(first, last, fn(f, l) { f + " " + l })
      inspect(full(), content="Hello World")
      first.set("Hi")
      inspect(full(), content="Hi World")
    }

    combine3

    source
    fn[A, B, C, R] combine3(a : Signal[A], b : Signal[B], c : Signal[C], f : (A, B, C) -> R) -> (() -> R)

    Combine three signals into one

    combine4

    source
    fn[A, B, C, D, R] combine4(a : Signal[A], b : Signal[B], c : Signal[C], d : Signal[D], f : (A, B, C, D) -> R) -> (() -> R)

    Combine four signals into one

    computed

    source
    fn[T] computed(compute : () -> T) -> (() -> T)

    Create a computed signal (alias for memo with Signal-like API). Same as memo, but named to be more familiar for those coming from other reactive frameworks.
    test {
      let count = @signal.signal(5)
      let doubled = @signal.computed(fn() { count.get() * 2 })
      inspect(doubled(), content="10")
      count.set(7)
      inspect(doubled(), content="14")
    }

    create_context

    source
    fn[T] create_context(default_value : T) -> Context[T]

    Create a new context with a default value Similar to Solid.js createContext

    create_root

    source
    fn[T] create_root(f : (() -> Unit) -> T) -> T

    Create a new reactive root scope. The function receives a dispose callback that cleans up all effects. Returns the result of the function.
    test {
      let count = @signal.signal(0)
      let log : Array[Int] = []
      let result = @signal.create_root(fn(dispose) {
        let _ = @signal.render_effect(fn() { log.push(count.get()) })
        dispose // Return dispose function
      })
      count.set(1)
      result() // Dispose the root
      count.set(2) // Won't trigger effect
      inspect(log, content="[0, 1]")
    }

    create_root_with_dispose

    source
    fn[T] create_root_with_dispose(f : () -> T) -> (T, () -> Unit)

    Create a reactive root and return both result and dispose function

    deferred

    source
    fn[T] deferred() -> (Resource[T], (T) -> Unit, (String) -> Unit)

    Create a deferred Resource (starts pending, resolve/reject manually)

    effect

    source
    fn effect(fn_ : () -> Unit) -> (() -> Unit)

    Create an effect that is deferred until after rendering completes. (Solid.js style createEffect - deferred execution via microtask) Returns a dispose function to stop the effect. Unlike render_effect, this runs asynchronously via microtask queue.
    // Note: effect() uses microtasks, so testing requires async handling
    let count = @signal.signal(0)
    let _ = @signal.effect(fn() {
    println("count changed to: " + count.get().to_string())
    })
    count.set(1) // Effect will run after current task completes

    effect_once

    source
    fn effect_once(fn_ : () -> Unit) -> Unit

    Create a one-time effect that disposes itself after first run. Useful for initialization logic that should only run once.
    test {
      let count = @signal.signal(0)
      let runs : Ref[Int] = { val: 0 }
      @signal.effect_once(fn() {
        let _ = count.get()
        runs.val = runs.val + 1
      })
      count.set(1)
      count.set(2)
      inspect(runs.val, content="2")
    }

    effect_when

    source
    fn effect_when(condition : () -> Bool, fn_ : () -> Unit) -> (() -> Unit)

    Create an effect that only runs when condition is true. Uses render_effect for synchronous execution.
    test {
      let enabled = @signal.signal(false)
      let count = @signal.signal(0)
      let log : Array[Int] = []
      let _ = @signal.effect_when(fn() { enabled.get() }, fn() {
        log.push(count.get())
      })
      count.set(1) // Won't run, enabled is false
      enabled.set(true)
      count.set(2)
      inspect(log, content="[1, 2]")
    }

    flatten

    source
    fn[T] flatten(outer : Signal[Signal[T]]) -> (() -> T)

    Flatten a signal of signals. Unwraps nested Signal[Signal[T]] to a getter for T.
    test {
      let inner1 = @signal.signal(10)
      let inner2 = @signal.signal(20)
      let outer = @signal.signal(inner1)
      let flat = @signal.flatten(outer)
      inspect(flat(), content="10")
      outer.set(inner2)
      inspect(flat(), content="20")
      inner2.set(30)
      inspect(flat(), content="30")
    }

    get_current_subscriber

    source
    fn get_current_subscriber() -> EffectRunner?

    Get current subscriber (if any) during signal read

    get_owner

    source
    fn get_owner() -> Owner?

    Get the current owner (if any)

    has_owner

    source
    fn has_owner() -> Bool

    Check if currently inside an owner scope

    is_batching

    source
    fn is_batching() -> Bool

    Check if we're currently inside a batch

    memo

    source
    fn[T] memo(compute : () -> T) -> (() -> T)

    Create a memoized computation. Returns a getter function that caches the result and recomputes only when dependencies change.
    test {
      let a = @signal.signal(2)
      let b = @signal.signal(3)
      let compute_count : Ref[Int] = { val: 0 }
      let sum = @signal.memo(fn() {
        compute_count.val = compute_count.val + 1
        a.get() + b.get()
      })
      inspect(sum(), content="5")
      inspect(sum(), content="5") // Cached, no recompute
      inspect(compute_count.val, content="1")
      a.set(10)
      inspect(sum(), content="13") // Recomputes
      inspect(compute_count.val, content="2")
    }

    new_effect_id

    source
    fn new_effect_id() -> Int

    Generate a new unique effect ID
    fn[T] on(sig : Signal[T], callback : (T) -> Unit) -> (() -> Unit)

    Explicitly subscribe to a signal with a callback. Returns an unsubscribe function. Unlike effect(), this doesn't auto-track and only listens to this one signal.
    test {
      let count = @signal.signal(0)
      let values : Array[Int] = []
      let unsub = @signal.on(count, fn(v) { values.push(v) })
      count.set(1)
      count.set(2)
      unsub()
      count.set(3) // This won't be captured
      inspect(values, content="[1, 2]")
    }

    on_cleanup

    source
    fn on_cleanup(cleanup : () -> Unit) -> Unit

    Register a cleanup function to run when the current scope disposes. Works in:
    • Effects: cleanup runs before effect re-runs or when effect disposes
    • Components: cleanup runs when component unmounts (Solid.js style - can be called directly in component body)
    test {
      let count = @signal.signal(0)
      let log : Array[String] = []
      let dispose = @signal.render_effect(fn() {
        let v = count.get()
        log.push("run:" + v.to_string())
        @signal.on_cleanup(fn() { log.push("cleanup:" + v.to_string()) })
      })
      count.set(1)
      dispose()
      inspect(
        log,
        content=(
          #|["run:0", "cleanup:0", "run:1", "cleanup:1"]
        ),
      )
    }

    on_immediate

    source
    fn[T] on_immediate(sig : Signal[T], callback : (T) -> Unit) -> (() -> Unit)

    Subscribe and run immediately with current value. Like on, but also invokes the callback with the current value right away.
    test {
      let count = @signal.signal(10)
      let values : Array[Int] = []
      let unsub = @signal.on_immediate(count, fn(v) { values.push(v) })
      count.set(20)
      unsub()
      // First value (10) was captured immediately, then 20 on update
      inspect(values, content="[10, 20]")
    }

    on_mount

    source
    fn on_mount(fn_ : () -> Unit) -> Unit

    Run a function once after mount (Solid.js style onMount). The function runs without tracking dependencies. Cleanup registered via on_cleanup inside will run when owner is disposed.
    test {
      let count = @signal.signal(0)
      let runs : Ref[Int] = { val: 0 }
      @signal.on_mount(fn() {
        let _ = count.get() // This read won't create subscription
        runs.val = runs.val + 1
      })
      count.set(1)
      count.set(2)
      // on_mount only ran once, signal changes don't trigger re-run
      inspect(runs.val, content="1")
    }
    fn[T] previous(sig : Signal[T]) -> (() -> T?)

    Create a signal that holds the previous value of another signal. Returns a getter function for the previous value (None on first read).
    test {
      let count = @signal.signal(1)
      let prev = @signal.previous(count)
      inspect(prev(), content="None") // No previous value yet
      count.set(2)
      inspect(prev(), content="Some(1)")
      count.set(3)
      inspect(prev(), content="Some(2)")
    }

    previous_with_initial

    source
    fn[T] previous_with_initial(sig : Signal[T], initial : T) -> (() -> T)

    Create a signal that holds the previous value with initial value. Unlike previous, this returns a plain T instead of T?.
    test {
      let count = @signal.signal(10)
      let prev = @signal.previous_with_initial(count, 0)
      inspect(prev(), content="0") // Initial value
      count.set(20)
      inspect(prev(), content="10")
      count.set(30)
      inspect(prev(), content="20")
    }

    provide

    source
    fn[T, R] provide(ctx : Context[T], value : T, f : () -> R) -> R

    Provide a context value for the current Owner and its descendants The value is associated with the current Owner and will be available to all effects and components created within this scope. Example:
    let theme_ctx = create_context("light")
provide(theme_ctx, "dark", fn() {
// All components here will see "dark"
my_component()
})

    register_disposer

    source
    fn register_disposer(disposer : () -> Unit) -> Unit

    Register a disposer with the current owner Called internally by effect() to register its dispose function

    register_owner_cleanup

    source
    fn register_owner_cleanup(cleanup : () -> Unit) -> Unit

    Register a cleanup with the current owner (alternative to onCleanup in effect)

    render_effect

    source
    fn render_effect(fn_ : () -> Unit) -> (() -> Unit)

    Create an effect that runs immediately and re-runs when dependencies change. (Solid.js style createRenderEffect - synchronous execution) Returns a dispose function to stop the effect. Supports on_cleanup() calls inside the effect.
    test {
      let count = @signal.signal(0)
      let log : Array[String] = []
      let dispose = @signal.render_effect(fn() {
        log.push("count=" + count.get().to_string())
      })
      log.push("after-effect")
      count.set(1)
      dispose()
      count.set(2) // Won't trigger effect
      inspect(
        log,
        content=(
          #|["count=0", "after-effect", "count=1"]
        ),
      )
    }

    resource

    source
    fn[T] resource(fetcher : ((T) -> Unit, (String) -> Unit) -> Unit) -> Resource[T]

    Create a Resource from a callback-based fetcher The fetcher receives (resolve, reject) callbacks This is environment-agnostic - the actual async execution is handled by the caller

    resource_rejected

    source
    fn[T] resource_rejected(error : String) -> Resource[T]

    Create a Resource with initial error (already rejected)

    resource_resolved

    source
    fn[T] resource_resolved(value : T) -> Resource[T]

    Create a Resource with initial value (already resolved)

    run_with_cleanup_tracking

    source
    fn[T] run_with_cleanup_tracking(cleanups : Array[() -> Unit], f : () -> T) -> T

    Run a function with cleanup tracking enabled

    run_with_owner

    source
    fn[T] run_with_owner(owner : Owner, f : () -> T) -> T

    Run a function with a specific owner as current

    run_with_subscriber

    source
    fn[T] run_with_subscriber(subscriber : EffectRunner, f : () -> T) -> T

    Run a function with the given subscriber as current This enables auto-tracking of signal dependencies

    schedule_effect

    source
    fn schedule_effect(effect : EffectRunner) -> Unit

    Schedule an effect to run (respects batching, deduplicates)

    select

    source
    fn[T] select(items : Signal[Array[T]], index : Signal[Int]) -> (() -> T?)

    Select from an array signal by index signal. Returns None if index is out of bounds.
    test {
      let items = @signal.signal(["a", "b", "c"])
      let idx = @signal.signal(1)
      let selected = @signal.select(items, idx)
      inspect(
        selected(),
        content=(
          #|Some("b")
        ),
      )
      idx.set(0)
      inspect(
        selected(),
        content=(
          #|Some("a")
        ),
      )
      idx.set(10) // Out of bounds
      inspect(selected(), content="None")
    }

    set_current_cleanups

    source
    fn set_current_cleanups(cleanups : Array[() -> Unit]?) -> Array[() -> Unit]?

    Set the current cleanup array (used internally by effect)

    signal

    source
    fn[T] signal(initial : T) -> Signal[T]

    Convenience function to create a signal. Shorthand for Signal::new.
    test {
      let count = @signal.signal(100)
      inspect(count.get(), content="100")
    }

    switch_

    source
    fn[T] switch_(condition : Signal[Bool], on_true : Signal[T], on_false : Signal[T]) -> (() -> T)

    Switch between signals based on a boolean signal. Returns value from on_true when condition is true, otherwise on_false.
    test {
      let flag = @signal.signal(true)
      let yes = @signal.signal("YES")
      let no = @signal.signal("NO")
      let result = @signal.switch_(flag, yes, no)
      inspect(result(), content="YES")
      flag.set(false)
      inspect(result(), content="NO")
      no.set("NOPE")
      inspect(result(), content="NOPE")
    }

    untracked

    source
    fn[T] untracked(f : () -> T) -> T

    Run a function without tracking (useful for avoiding circular deps). Signal reads inside this function won't create subscriptions.
    test {
      let count = @signal.signal(0)
      let runs : Ref[Int] = { val: 0 }
      let _ = @signal.render_effect(fn() {
        @signal.untracked(fn() {
          let _ = count.get() // Won't create dependency
          runs.val = runs.val + 1
        })
      })
      count.set(1)
      count.set(2)
      // Effect only ran once (initial), not on updates
      inspect(runs.val, content="1")
    }

    use_context

    source
    fn[T] use_context(ctx : Context[T]) -> T

    Use a context value - returns the current provided value or default Walks up the Owner chain to find the nearest provided value. Similar to Solid.js useContext Example:
    let theme = use_context(theme_ctx) // Returns "dark" or default

    watch

    source
    fn[T : Eq] watch(source : () -> T, callback : (T, T) -> Unit) -> (() -> Unit)

    Watch a computed expression and run callback when it changes. Returns a dispose function. The callback receives (newValue, oldValue).
    test {
      let count = @signal.signal(0)
      let changes : Array[(Int, Int)] = []
      let dispose = @signal.watch(fn() { count.get() }, fn(new_val, old_val) {
        changes.push((new_val, old_val))
      })
      count.set(1)
      count.set(2)
      count.set(2) // Same value, no callback
      count.set(3)
      dispose()
      inspect(changes, content="[(1, 0), (2, 1), (3, 2)]")
    }

    watch_immediate

    source
    fn[T : Eq] watch_immediate(source : () -> T, callback : (T, T?) -> Unit) -> (() -> Unit)

    Watch with immediate execution (runs callback on first value too). The callback receives (newValue, oldValue?) where oldValue is None on first run.
    test {
      let count = @signal.signal(5)
      let log : Array[String] = []
      let dispose = @signal.watch_immediate(fn() { count.get() }, fn(
        new_val,
        old_val,
      ) {
        match old_val {
          Some(old) => log.push(old.to_string() + "->" + new_val.to_string())
          None => log.push("init:" + new_val.to_string())
        }
      })
      count.set(10)
      dispose()
      inspect(
        log,
        content=(
          #|["init:5", "5->10"]
        ),
      )
    }

    with_parent_owner

    source
    fn[T] with_parent_owner(captured_owner : Owner?, f : () -> T) -> T

    Run a function with a captured parent owner context (if any) This is useful for rendering child components that need to inherit the parent's owner. If captured_owner is Some, runs with that owner as context. If captured_owner is None, runs directly without owner context.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io