Struct Bits128 

pub struct Bits128(pub [u64; 2]);

A value flowing through the DAG at runtime.

This is the universal runtime representation for all Polydat data. Every node input and output is a Value. The variant determines the data type:

Variant	Rust type	Polydat DSL type	Usage
U64	u64	u64	Cycle counters, hashes, IDs, bitwise ops
F64	f64	f64	Floating point math, distributions, noise
Bool	bool	bool	Conditions, flags
Str	String	String	Names, formatted output, templates
Bytes	Vec<u8>	bytes	Raw binary data, digests
Json	serde_json::Value	json	Structured data, vectors
Ext	Box<dyn ReflectedValue>	adapter-specific	CQL UUIDs, timestamps, etc.
None	—	—	Uninitialized buffer slot (never flows through wiring)

The assembly phase validates type correctness at compile time. Runtime code can safely use as_u64(), as_f64(), etc. — a type mismatch is a compiler bug, not a user error.

Ext enables adapter-contributed types (e.g., uuid::Uuid from the CQL adapter) to flow through the DAG without the kernel knowing the concrete type. Any consumer can display, serialize, or inspect an Ext value via ReflectedValue. The producing adapter can downcast via as_any(). Two-limb carrier for 128-bit integers inside Value.

Limbs are little-endian ([lo, hi]). Using [u64; 2] instead of a raw u128/i128 field keeps Value’s alignment at 8 and its size inside the 40-byte buffer-slot envelope; reassembly is two register moves.

Tuple Fields

0: [u64; 2]

Implementations

impl Bits128

pub fn from_u128(v: u128) -> Self

The two-word form of a u128, low word first.

pub fn from_i128(v: i128) -> Self

The two-word form of an i128, low word first.

pub fn as_u128(self) -> u128

The word as a u128.

pub fn as_i128(self) -> i128

The word as an i128.

pub fn to_le_bytes(self) -> [u8; 16]

The word’s sixteen bytes, little-endian.

pub fn from_le_bytes(b: [u8; 16]) -> Self

A word from sixteen little-endian bytes.

impl Bits128

pub fn lanes_i8(self) -> [i8; 16]

The word as lanes of one element type, lane 0 at the lowest address.

pub fn from_lanes_i8(lanes: [i8; 16]) -> Self

A word from lanes of one element type, lane 0 at the lowest address.

impl Bits128

pub fn lanes_i16(self) -> [i16; 8]

The word as lanes of one element type, lane 0 at the lowest address.

pub fn from_lanes_i16(lanes: [i16; 8]) -> Self

A word from lanes of one element type, lane 0 at the lowest address.

impl Bits128

pub fn lanes_i32(self) -> [i32; 4]

The word as lanes of one element type, lane 0 at the lowest address.

pub fn from_lanes_i32(lanes: [i32; 4]) -> Self

A word from lanes of one element type, lane 0 at the lowest address.

impl Bits128

pub fn lanes_i64(self) -> [i64; 2]

The word as lanes of one element type, lane 0 at the lowest address.

pub fn from_lanes_i64(lanes: [i64; 2]) -> Self

A word from lanes of one element type, lane 0 at the lowest address.

impl Bits128

pub fn lanes_f32(self) -> [f32; 4]

The word as lanes of one element type, lane 0 at the lowest address.

pub fn from_lanes_f32(lanes: [f32; 4]) -> Self

A word from lanes of one element type, lane 0 at the lowest address.

impl Bits128

pub fn lanes_f64(self) -> [f64; 2]

The word as lanes of one element type, lane 0 at the lowest address.

pub fn from_lanes_f64(lanes: [f64; 2]) -> Self

A word from lanes of one element type, lane 0 at the lowest address.

impl Bits128

pub fn lanes_f16(self) -> [f16; 8]

f16 lanes go through the bit-pattern codec (half::f16 has no to_le_bytes).

pub fn from_lanes_f16(lanes: [f16; 8]) -> Self

A word from eight f16 lanes, through the bit-pattern codec.

Trait Implementations

impl Clone for Bits128

fn clone(&self) -> Bits128

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Bits128

impl Debug for Bits128

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Bits128

impl Hash for Bits128

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Bits128

fn eq(&self, other: &Bits128) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Bits128

impl Wire for Bits128

const PORT: PortType = PortType::Reg128

Static port type for the DSL type-checker.

const JIT: Option<JitType> = None

JIT carrier classification. Some(_) means the type rides the Phase-2 u64 buffer; None means typed-eval only.

fn extract(v: &Value) -> Self

Pull a typed value out of a Value wire.

fn inject(self) -> Value

Push a typed value back into the Value outputs stream.

const RESOLVER: Option<DefaultResolver> = None

SRD-53 §“Source-string call-site sugar” — auto-resolver for Str-typed upstream wires feeding this slot. None (the default) disables auto-promotion; the workload must supply the wire’s actual port type directly. Set via the Resolved<R, T> marker wrapper.

const WIRE_COST: WireCost = crate::ast::WireCost::Data

SRD-15 §“WireCost::Config” — cost class for this wire. Defaults to WireCost::Data (cheap per-cycle input). Set to WireCost::Config via the Config<T> marker wrapper to signal that the wire is rarely-changing and the compiler should warn on cycle-time binding.