Enum Value 

pub enum Value {
    MScalar {
        size_in_bits: usize,
    },
    MFloat {
        size_in_bits: usize,
    },
    MBool,
    Scalar {
        size_in_bits: usize,
        kind: ScalarKind,
    },
    Float {
        size_in_bits: usize,
    },
    Bool,
    Ciphertext {
        size_in_bits: usize,
    },
    ArcisX25519Pubkey,
    Point,
    Array(Vec<Value>),
    Tuple(Vec<Value>),
    Struct(Vec<Value>),
}

Circuit interface value types.

Represents all possible types that can be used as inputs or outputs in Arcium circuits.

Variants

MScalar

Fields

size_in_bits: usize

MFloat

Fields

size_in_bits: usize

MBool

Scalar

Plaintext scalar value (integer).

Fields

• size_in_bits - Bit width of the scalar (8, 16, 32, 64, or 128)
• kind - Whether the scalar is signed or unsigned

Examples

• Scalar { size_in_bits: 32, kind: ScalarKind::Unsigned } represents u32
• Scalar { size_in_bits: 64, kind: ScalarKind::Signed } represents i64

Fields

size_in_bits: usize

kind: ScalarKind

Float

Fields

size_in_bits: usize

Bool

Ciphertext

Fields

size_in_bits: usize

ArcisX25519Pubkey

Point

Array(Vec<Value>)

Tuple(Vec<Value>)

Struct(Vec<Value>)

Implementations

impl Value

pub fn size_in_scalars(&self) -> usize

Returns the number of scalar field elements this value occupies.

For primitive types (Scalar, Bool, Float, etc.), this returns 1. For composite types (Array, Tuple, Struct), this recursively counts all scalar fields.

Examples

use arcis_interface::{Value, ScalarKind};

let scalar = Value::Scalar { size_in_bits: 32, kind: ScalarKind::Unsigned };
assert_eq!(scalar.size_in_scalars(), 1);

let tuple = Value::Tuple(vec![
    Value::Scalar { size_in_bits: 32, kind: ScalarKind::Unsigned },
    Value::Bool,
]);
assert_eq!(tuple.size_in_scalars(), 2);

pub fn flatten(&self) -> Vec<Value>

Flattens composite types into a vector of primitive values.

For primitive types, returns a single-element vector containing self. For composite types (Array, Tuple, Struct), recursively flattens all nested values into a flat vector of primitives.

Examples

use arcis_interface::{Value, ScalarKind};

let scalar = Value::Scalar { size_in_bits: 32, kind: ScalarKind::Unsigned };
assert_eq!(scalar.flatten().len(), 1);

let tuple = Value::Tuple(vec![
    Value::Scalar { size_in_bits: 32, kind: ScalarKind::Unsigned },
    Value::Tuple(vec![Value::Bool, Value::Bool]),
]);
assert_eq!(tuple.flatten().len(), 3); // u32, bool, bool

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Value

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Value

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Value

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Value

impl StructuralPartialEq for Value