Class: Farce::LazyRef

Inherits:
Reference
  • Object
show all
Defined in:
lib/farce/lazy_ref.rb

Overview

A Reference for a Lazy value.

Results use the lazy value's transfer mode, which defaults to :smart.

Calling freeze resolves and freezes the target. Checking frozen? before the first successful freeze does not resolve it.

Examples:

initialized = Farce::Counter.new

lazy_ref = Farce::LazyRef.new do
  initialized.increment
  Farce::Map.new
end

initialized.value # => 0
lazy_ref[:key] = :value
initialized.value # => 1

See Also:

Instance Method Summary collapse

Constructor Details

#initialize(factory, mode: :smart) ⇒ LazyRef #initialize(self: nil, mode: :smart) { ... } ⇒ LazyRef

Valid modes are:

  • :smart - Applies smart rules or a dedicated proxy. Raises for unsupported values. This is the default for most mode-backed classes.
  • :smart_raise - Applies smart rules or a dedicated proxy, with a raising fallback.
  • :smart_copy - Applies smart rules or a dedicated proxy, then falls back to copying or Marshal. This is the default for Port.
  • :smart_move - Applies smart rules or a dedicated proxy, then falls back to moving.
  • :copy - The value will be copied between Ractors.
  • :marshal - The value will be serialized immediately and reconstructed once per Ractor with Ruby's Marshal protocol. Contents must support Marshal. Nested shareable values may be reconstructed too.
  • :make_shareable - The value will be made Ractor-shareable using Ractor.make_shareable.
  • :move - The value will be moved between Ractors. This saves memory compared to copying, and supports values that can't be copied but moved (like IO objects). However, the value will no longer be accessible on the Ractor that pushed it.
  • :mutable - A Mutable instance will be created for the value. This isn't done recursively and thus will fail for nested unshareable values.
  • :local - The value will be kept local to the Ractor that pushed it. Another ractor trying to receive it will get an error. Useful for usage contained within a single Ractor.
  • :proxy - The value will be wrapped in a Farce::Proxy that executes calls in the original Ractor.
  • :raise - An error will be raised if the value is not Ractor-shareable. Useful for enforcing shareability.
  • :dedup - The value will be deduplicated using Farce.dedup, then made Ractor-shareable. This may update and freeze the original. Already-shareable values pass through unchanged.
  • :shareable_copy - The value will be copied and the copy will be made Ractor-shareable.

Overloads:

  • #initialize(factory, mode: :smart) ⇒ LazyRef

    Parameters:

    • mode (Symbol) (defaults to: :smart) —

      the transfer mode for the computed result

    • factory (Class, Proc, #call) —

      The factory to use for creating the value. Must be ractor-shareable.

  • #initialize(self: nil, mode: :smart) { ... } ⇒ LazyRef

    Parameters:

    • mode (Symbol) (defaults to: :smart) —

      the transfer mode for the computed result

    • self (BasicObject) (defaults to: nil) —

      The self parameter to be provided to the block. Must be ractor-shareable.

    Yields:

    • The block to use for creating the value. Must be ractor-shareable.

    Yield Returns:

    • (BasicObject) —

      The value to be returned by the lazy instance.

    Yield Receiver:

    • (BasicObject) —

      The self parameter provided, or nil if not provided.



42
 
# File 'lib/farce/lazy_ref.rb', line 42

LazyRef = Reference[Lazy]