Struct LazyTable 

pub struct LazyTable { /* private fields */ }

Table whose entry values are produced on demand by ValueLoader closures and memoized after their first force.

Each entry’s loader runs at most once; the first result (value or error) is cached and returned for every later access. Metadata operations (has/keys/len) do not force loaders, while get/del/entries and encoding do. Implements the kernel Table contract and the object-encoding contracts, round-tripping through its LazyTableDescriptor citizen form. The entry map is guarded by an RwLock, so a LazyTable is shareable and mutable through a shared reference.

Implementations

impl LazyTable

pub fn new() -> Self

Construct an empty lazy table.

pub fn with_loaders(pairs: Vec<(Symbol, ValueLoader)>) -> Self

Construct a lazy table whose entries are produced on demand by the given loaders.

Each loader runs at most once, on first access of its key, and its result is memoized.

Examples

use std::sync::Arc;
use sim_kernel::{Cx, DefaultFactory, NoopEvalPolicy, Result, Symbol, Table, Value};
use sim_table_lazy::{LazyTable, ValueLoader};

let mut cx = Cx::new(Arc::new(NoopEvalPolicy), Arc::new(DefaultFactory));
let loader: ValueLoader = Arc::new(|cx: &mut Cx| cx.factory().bool(true));
let table = LazyTable::with_loaders(vec![(Symbol::new("x"), loader)]);

// Metadata does not force the loader.
assert!(table.has(&mut cx, Symbol::new("x")).unwrap());
// get forces it (once) and memoizes the result.
let forced = table.get(&mut cx, Symbol::new("x")).unwrap();
assert_eq!(forced, table.get(&mut cx, Symbol::new("x")).unwrap());

pub fn with_entries(entries: Vec<(Symbol, Value)>) -> Self

Construct a lazy table pre-populated with already-computed values.

Each entry is stored as an eager (pre-cached) loader, so accessing it performs no further computation. Later entries with the same key overwrite earlier ones.

pub fn put_lazy(&self, key: Symbol, loader: ValueLoader)

Insert (or replace) a lazily computed entry under key.

The loader runs at most once, on first access of key, and its result is memoized.

Trait Implementations

impl Citizen for LazyTable

fn citizen_symbol() -> Symbol

The citizen’s namespace/name class symbol.

fn citizen_version() -> u32

The citizen’s encoding version.

fn citizen_arity() -> usize

Number of constructor fields (excluding the version argument).

fn citizen_fields() -> &'static [&'static str]

The citizen’s field names, in constructor order.

impl Clone for LazyTable

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for LazyTable

fn default() -> Self

Returns the “default value” for a type.

impl Object for LazyTable

fn display(&self, _cx: &mut Cx) -> Result<String>

Render the object as a human-readable display string.

fn as_any(&self) -> &dyn Any

Expose the object for Rust downcasting.

fn header(&self) -> &ObjectHeader

Identity and trust header for the object; defaults to the shared anonymous header.

fn op(&self, _key: &OpKey) -> Option<&dyn Op>

Resolve the operation registered under key, if any.

fn claims( &self, _cx: &mut Cx, _pattern: &ClaimPattern, _sink: &mut dyn ClaimSink, ) -> Result<(), Error>

Emit the object’s claims matching pattern into sink.

fn snapshot(&self, _cx: &mut Cx) -> Result<Option<Datum>, Error>

Optional content-addressable snapshot of the object’s state.

impl ObjectCompat for LazyTable

fn class(&self, cx: &mut Cx) -> Result<ClassRef>

Class object this value belongs to; defaults to nil.

fn as_expr(&self, cx: &mut Cx) -> Result<Expr>

Expression form of the object; defaults to an opaque extension node.

fn truth(&self, _cx: &mut Cx) -> Result<bool>

Truthiness of the object; defaults to true.

fn as_table_impl(&self) -> Option<&dyn Table>

Table-implementation view, if the object is a table.

fn as_object_encoder(&self) -> Option<&dyn ObjectEncode>

Object-encoder view, if the object encodes other objects.

fn as_callable(&self) -> Option<&dyn Callable>

Callable view, if the object can be invoked.

fn as_class(&self) -> Option<&dyn Class>

Class view, if the object is a class.

fn as_shape(&self) -> Option<&dyn Shape>

Shape view, if the object is a shape.

fn as_read_constructor(&self) -> Option<&dyn ReadConstructor>

Read-constructor view, if the object decodes data forms.

fn as_number_domain(&self) -> Option<&(dyn NumberDomain + 'static)>

Number-domain view, if the object is a number domain.

fn as_number_value(&self) -> Option<&dyn NumberValue>

Number-value view, if the object is a domain number.

fn as_eval_fabric(&self) -> Option<&dyn EvalFabric>

Eval-fabric view, if the object is a distributed eval surface.

fn as_stream(&self) -> Option<&dyn Stream>

Stream view, if the object is a stream.

fn as_sequence(&self) -> Option<&dyn Sequence>

Sequence view, if the object is a sequence.

fn as_thunk(&self) -> Option<&dyn Thunk>

Thunk view, if the object is a deferred computation.

fn as_list(&self) -> Option<&(dyn ListValue + 'static)>

List view, if the object is a list value.

fn as_dir(&self) -> Option<&(dyn Dir + 'static)>

Directory view, if the object is a directory.

fn publish_shape_satisfaction_claims( &self, _cx: &mut Cx, _shape: &Ref, ) -> Result<bool, Error>

Publish claims asserting that the object satisfies shape; returns whether any were published.

fn as_table(&self, cx: &mut Cx) -> Result<Value, Error>

Project the object into a table value; the default exposes its display.

impl ObjectEncode for LazyTable

fn object_encoding(&self, cx: &mut Cx) -> Result<ObjectEncoding>

Returns the ObjectEncoding this object should be rendered as.

impl Table for LazyTable

fn backend_symbol(&self) -> Symbol

Symbol identifying the backend representation.

fn get(&self, cx: &mut Cx, key: Symbol) -> Result<Value>

Looks up key, returning nil when absent.

fn set(&self, _cx: &mut Cx, key: Symbol, value: Value) -> Result<()>

Inserts or replaces the value for key.

fn has(&self, _cx: &mut Cx, key: Symbol) -> Result<bool>

Whether key is present.

fn del(&self, cx: &mut Cx, key: Symbol) -> Result<Value>

Removes key, returning its prior value or nil.

fn keys(&self, _cx: &mut Cx) -> Result<Vec<Symbol>>

All keys, in backend order.

fn entries(&self, cx: &mut Cx) -> Result<Vec<(Symbol, Value)>>

All key/value pairs, in backend order.

fn len(&self, _cx: &mut Cx) -> Result<usize>

Number of entries.

fn clear(&self, _cx: &mut Cx) -> Result<()>

Removes all entries.

fn is_empty(&self, cx: &mut Cx) -> Result<bool, Error>

Whether the table has no entries.

fn as_table_expr(&self, cx: &mut Cx) -> Result<Expr, Error>

Projects the table to an Expr::Map.

fn table_eq( &self, cx: &mut Cx, other: &(dyn Table + 'static), ) -> Result<bool, Error>

Order-insensitive equality against another table’s entries.