Module sycamore::reactive

Re-export of the sycamore-reactive crate.

Reactive primitives for Sycamore.

Structs

• NodeHandle
  A handle to a reactive node (signal, memo, effect) that lets you run further tasks in it or manually dispose it.
• ReadSignal
  A read-only reactive value.
• RootHandle
  A handle to a root. This lets you reinitialize or dispose the root for resource cleanup.
• Signal
  A reactive value that can be read and written to.

Traits

• Accessor
  A trait that is implemented for reactive data that can be accessed and tracked, such as Signal.
• Trackable
  A trait that is implemented for reactive data that can be tracked, such as Signal.

Functions

• batch
  Batch updates from related signals together and only run memos and effects at the end of the scope.
• create_child_scope
  Create a child scope.
• create_effect
  Creates an effect on signals used inside the effect closure.
• create_memo
  Creates a memoized computation from some signals. The output is derived from all the signals that are used within the memo closure. If any of the tracked signals are updated, the memo is also updated.
• create_reducer
  An alternative to create_signal that uses a reducer to get the next value.
• create_root
  Creates a new reactive root with a top-level [Scope]. The returned RootHandle can be used to dispose the root.
• create_selector
  Creates a memoized value from some signals. Unlike create_memo, this function will not notify dependents of a hange if the output is the same. That is why the output of the function must implement PartialEq.
• create_selector_with
  Creates a memoized value from some signals. Unlike create_memo, this function will not notify dependents of a change if the output is the same.
• create_signal
  Create a new Signal.
• derived
  Create an Accessor that represents a derived signal.
• map_indexed
  Function that maps a Vec to another Vec via a map function. The mapped Vec is lazy computed, meaning that it’s value will only be updated when requested. Modifications to the input Vec are diffed by index to prevent recomputing values that have not changed.
• map_keyed
  Function that maps a Vec to another Vec via a map function. The mapped Vec is lazy computed, meaning that it’s value will only be updated when requested. Modifications to the input Vec are diffed using keys to prevent recomputing values that have not changed.
• on
  A helper function for making dependencies explicit.
• on_cleanup
  Adds a callback that is called when the scope is destroyed.
• provide_context
  Provide a context value in this scope.
• try_use_context
  Tries to get a context value of the given type. If no context is found, returns None.
• untrack
  Run the passed closure inside an untracked dependency scope.
• use_context
  Get a context with the given type. If no context is found, this panics.
• use_context_or_else
  Try to get a context with the given type. If no context is found, returns the value of the function and sets the value of the context in the current scope.
• use_current_scope
  Get a handle to the current reactive scope.
• use_global_scope
  Get a handle to the root reactive scope.
• use_scope_depth
  Gets how deep the current scope is from the root/global scope. The value for the global scope itself is always 0.