Struct Expression 

pub struct Expression { /* private fields */ }

An expression in a Gordian Envelope.

An expression consists of a function (the subject of the envelope) and zero or more parameters (as assertions on the envelope). It represents a computation or function call that can be evaluated.

Expressions form the foundation for Gordian Envelope’s ability to represent computations, queries, and function calls within the envelope structure.

Expressions are documented in BCR-2023-012: Envelope Expressions.

Examples

A simple addition expression:

use bc_envelope::prelude::*;

// Create an expression that adds 2 and 3
let expression = Expression::new(functions::ADD)
    .with_parameter(parameters::LHS, 2)
    .with_parameter(parameters::RHS, 3);

A more complex expression:

use bc_envelope::prelude::*;

// Create a verify signature expression with a public key, signature, and digest
let expression = Expression::new("verifySignature")
    .with_parameter("key", public_key)
    .with_parameter("sig", signature)
    .with_parameter("digest", message_digest);

Implementations

impl Expression

pub fn new(function: impl Into<Function>) -> Self

Creates a new expression with the given function.

The function becomes the subject of the expression envelope.

Parameters

• function - The function identifier for this expression

Returns

A new Expression instance

Examples

use bc_envelope::prelude::*;

// Create a new expression with the ADD function
let expression = Expression::new(functions::ADD);

// Create a new expression with a named function
let expression = Expression::new("verifySignature");

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Display for Expression

Implements Display for Expression.

Outputs the formatted envelope representation of the expression.

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

Formats the value using the given formatter.

impl ExpressionBehavior for Expression

Implementation of ExpressionBehavior for Expression.

fn with_parameter( self, parameter: impl Into<Parameter>, value: impl EnvelopeEncodable, ) -> Self

Adds a parameter to the expression.

fn with_optional_parameter( self, parameter: impl Into<Parameter>, value: Option<impl EnvelopeEncodable>, ) -> Self

Adds a parameter to the expression if the value is not None.

fn function(&self) -> &Function

Returns the function of the expression.

fn expression_envelope(&self) -> &Envelope

Returns the envelope representing the expression.

fn object_for_parameter(&self, param: impl Into<Parameter>) -> Result<Envelope>

Returns the argument for the given parameter.

fn objects_for_parameter(&self, param: impl Into<Parameter>) -> Vec<Envelope>

Returns all arguments for the given parameter.

fn extract_object_for_parameter<T>( &self, param: impl Into<Parameter>, ) -> Result<T>

where T: TryFrom<CBOR, Error = Error> + 'static,

Returns the argument for the given parameter, decoded as the given type.

fn extract_optional_object_for_parameter<T: TryFrom<CBOR, Error = Error> + 'static>( &self, param: impl Into<Parameter>, ) -> Result<Option<T>>

Returns the argument for the given parameter, decoded as the given type, or None if there is no matching parameter.

fn extract_objects_for_parameter<T>( &self, param: impl Into<Parameter>, ) -> Result<Vec<T>>

where T: TryFrom<CBOR, Error = Error> + 'static,

Returns an array of arguments for the given parameter, decoded as the given type.

impl From<Expression> for Envelope

Allows converting an Expression to an Envelope.

This simply returns the envelope that represents the expression.

fn from(expression: Expression) -> Self

Converts to this type from the input type.

impl From<Request> for Expression

Converts a Request to an Expression.

This extracts the request’s body expression.

fn from(request: Request) -> Self

Converts to this type from the input type.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> 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 TryFrom<(Envelope, Option<&Function>)> for Expression

Allows converting an Envelope and optional expected function to an Expression.

This is similar to TryFrom<Envelope>, but it also checks that the function matches the expected function, if provided.

Errors

Returns an error if:

• The envelope’s subject cannot be extracted as a Function
• The expected function is provided and doesn’t match the extracted function

type Error = Error

The type returned in the event of a conversion error.

fn try_from( (envelope, expected_function): (Envelope, Option<&Function>), ) -> Result<Self>

Performs the conversion.

impl TryFrom<Envelope> for Expression

Allows converting an Envelope to an Expression.

This extracts the function from the envelope’s subject and creates an Expression with that function and the envelope.

Errors

Returns an error if the envelope’s subject cannot be extracted as a Function.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(envelope: Envelope) -> Result<Self>

Performs the conversion.

impl StructuralPartialEq for Expression