Struct ConsList 

pub struct ConsList { /* private fields */ }

A singly linked, shared cons-cell list.

Each node holds an optional car (the head value) and an optional cdr (a shared reference to the next node). The unique empty list is the node with both fields None; a non-empty list is a chain of ConsList::cell nodes terminated by an empty node. Nodes are shared through Arc, so a cdr is a cheap pointer clone and tails can be shared across many lists.

ConsList is the concrete object behind the cons ListBackend (crate::ConsBackend); it implements the kernel list and object-encoding contracts so the runtime treats it as a first-class list value.

Examples

use std::sync::Arc;
use sim_kernel::{Cx, DefaultFactory, EagerPolicy, Factory, ListValue, LengthResult};
use sim_list_cell::ConsList;

let mut cx = Cx::new(Arc::new(EagerPolicy), Arc::new(DefaultFactory));

// The empty list.
let empty = ConsList::from_vec(vec![]);
assert!(empty.is_empty(&mut cx).unwrap());
assert_eq!(empty.len(&mut cx).unwrap(), LengthResult::Known(0));

// A two-element list, read by head and tail.
let a = cx.factory().bool(true).unwrap();
let b = cx.factory().bool(false).unwrap();
let xs = ConsList::from_vec(vec![a, b]);
assert_eq!(xs.len(&mut cx).unwrap(), LengthResult::Known(2));
assert!(xs.car(&mut cx).unwrap().is_some());
let tail = xs.cdr(&mut cx).unwrap().unwrap();
let tail = tail.object().as_list().unwrap();
assert_eq!(tail.len(&mut cx).unwrap(), LengthResult::Known(1));

Implementations

impl ConsList

pub fn empty() -> Self

Returns the empty list (a node with no head and no tail).

pub fn cell(car: Value, cdr: Arc<ConsList>) -> Self

Builds a non-empty cell prepending car onto the shared tail cdr.

pub fn cell_foreign(car: Value, tail: Value) -> Self

Builds a non-empty cell prepending car onto a foreign list tail.

The tail is kept as an opaque list value rather than materialized, so consing onto a lazy or unbounded list stays lazy.

pub fn from_vec(items: Vec<Value>) -> Arc<Self>

Builds a shared list from items in order, the first item at the head.

Trait Implementations

impl Citizen for ConsList

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 ConsList

fn clone(&self) -> ConsList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ListValue for ConsList

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

Whether the list has no elements.

fn car(&self, _cx: &mut Cx) -> Result<Option<Value>>

The first element, or Ok(None) when empty.

fn cdr(&self, cx: &mut Cx) -> Result<Option<Value>>

The tail list after the first element, or Ok(None) when empty.

fn len(&self, cx: &mut Cx) -> Result<LengthResult>

The length, finite or LengthResult::Unknown for endless lists.

fn len_cmp(&self, cx: &mut Cx, n: usize) -> Result<Ordering>

Compares the spine length against n without fully forcing the list.

fn get(&self, cx: &mut Cx, index: usize) -> Result<Option<Value>>

The element at index, or Ok(None) when out of range.

fn for_each( &self, cx: &mut Cx, limit: Option<usize>, visit: &mut dyn FnMut(&Value), ) -> Result<()>

Visits up to limit elements in order, walking the list spine.

fn to_vec(&self, cx: &mut Cx, limit: Option<usize>) -> Result<Vec<Value>, Error>

Collects up to limit elements into a vector.

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

The value to start spine walks from; the receiver itself by default.

fn as_self_value(&self) -> Option<Value>

The receiver re-wrapped as a Value, when it can produce one.

impl Object for ConsList

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 ConsList

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_list(&self) -> Option<&dyn ListValue>

List view, if the object is a list value.

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_table_impl(&self) -> Option<&(dyn Table + 'static)>

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

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 ConsList

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

Returns the ObjectEncoding this object should be rendered as.