Struct ShapeContract 

pub struct ShapeContract<'a> {
    pub index: &'a [&'a str],
    pub terms: &'a [DimMatcher<'a>],
    pub ellipsis_pos: Option<usize>,
}

A shape pattern, which is a sequence of terms that can match a shape.

Fields

index: &'a [&'a str]

The slot index of the contract.

terms: &'a [DimMatcher<'a>]

The terms in the pattern.

ellipsis_pos: Option<usize>

The position of the ellipsis in the pattern, if any.

Implementations

impl<'a> ShapeContract<'a>

pub const fn new(index: &'a [&'a str], terms: &'a [DimMatcher<'a>]) -> Self

Create a new shape pattern from a slice of terms.

Arguments

• terms: a slice of ShapePatternTerm that defines the pattern.

Returns

A new ShapePattern instance.

Macro Support

Consider using the crate::shape_contract macro instead.

use bimm_contracts::{shape_contract, ShapeContract};

static CONTRACT : ShapeContract = shape_contract![
   ...,
   "height" = "h_wins" * "window",
   "width" = "w_wins" * "window",
   "channels",
];

pub fn maybe_key_to_index(&self, key: &str) -> Option<usize>

Convert a key to an index.

pub fn assert_shape<S>(&'a self, shape: S, env: StackEnvironment<'a>)

where S: ShapeArgument,

Assert that the shape matches the pattern.

Arguments

• shape: the shape to match.
• env: the params which are already bound.

Panics

If the shape does not match the pattern, or if there is a conflict in the bindings.

Example

use bimm_contracts::{shape_contract, run_periodically, ShapeContract};

let shape = [1, 2, 3, 2 * 8, 3 * 8, 4];

// Run under backoff amortization.
run_periodically! {{
    // Statically allocated contract.
    static CONTRACT : ShapeContract = shape_contract![
       ...,
       "height" = "h_wins" * "window",
       "width" = "w_wins" * "window",
       "channels",
    ];

    // Assert the shape, given the bindings.
    CONTRACT.assert_shape(
        &shape,
        &[("h_wins", 2), ("w_wins", 3), ("channels", 4)]
    );
}}

pub fn try_assert_shape<S>( &'a self, shape: S, env: StackEnvironment<'a>, ) -> Result<(), String>

where S: ShapeArgument,

Assert that the shape matches the pattern.

Arguments

• shape: the shape to match.
• env: the params which are already bound.

Returns

• Ok(()): if the shape matches the pattern.
• Err(String): if the shape does not match the pattern, with an error message.

Example

use bimm_contracts::{shape_contract, run_periodically, ShapeContract};

let shape = [1, 2, 3, 2 * 8, 3 * 8, 4];

// Statically allocated contract.
static CONTRACT : ShapeContract = shape_contract![
   ...,
   "height" = "h_wins" * "window",
   "width" = "w_wins" * "window",
   "channels",
];

// Assert the shape, given the bindings; or throw.
CONTRACT.try_assert_shape(
    &shape,
    &[("h_wins", 2), ("w_wins", 3), ("channels", 4)]
).unwrap();

pub fn unpack_shape<S, const K: usize>( &'a self, shape: S, keys: &[&'a str; K], env: StackEnvironment<'a>, ) -> [usize; K]

where S: ShapeArgument,

Match and unpack K keys from a shape pattern.

Wraps try_unpack_shape and panics if the shape does not match.

Generics

• K: the length of the keys array.

Arguments

• shape: the shape to match.
• keys: the bound keys to export.
• env: the params which are already bound.

Returns

An [usize; K] of the unpacked keys values.

Panics

If the shape does not match the pattern, or if there is a conflict in the bindings.

Example

use bimm_contracts::{shape_contract, run_periodically, ShapeContract};

let shape = [1, 2, 3, 2 * 8, 3 * 8, 4];

// Statically allocated contract.
static CONTRACT : ShapeContract = shape_contract![
   ...,
   "height" = "h_wins" * "window",
   "width" = "w_wins" * "window",
   "channels",
];

// Unpack the shape, given the bindings.
let [h, w, c] = CONTRACT.unpack_shape(
    &shape,
    &["h_wins", "w_wins", "channels"],
    &[("window", 8)]
);
assert_eq!(h, 2);
assert_eq!(w, 3);
assert_eq!(c, 4);

pub fn try_unpack_shape<S, const K: usize>( &'a self, shape: S, keys: &[&'a str; K], env: StackEnvironment<'a>, ) -> Result<[usize; K], String>

where S: ShapeArgument,

Try and match and unpack K keys from a shape pattern.

Generics

• K: the length of the keys array.

Arguments

• shape: the shape to match.
• keys: the bound keys to export.
• env: the params which are already bound.

Returns

A Result<[usize; K], String> of the unpacked keys values.

Example

use bimm_contracts::{shape_contract, run_periodically, ShapeContract};

let shape = [1, 2, 3, 2 * 8, 3 * 8, 4];

// Statically allocated contract.
static CONTRACT : ShapeContract = shape_contract![
   ...,
   "height" = "h_wins" * "window",
   "width" = "w_wins" * "window",
   "channels",
];

// Unpack the shape, given the bindings; or throw.
let [h, w, c] = CONTRACT.try_unpack_shape(
    &shape,
    &["h_wins", "w_wins", "channels"],
    &[("window", 8)]
).unwrap();
assert_eq!(h, 2);
assert_eq!(w, 3);
assert_eq!(c, 4);

pub fn expect_keys_to_selection<const D: usize>( &'a self, keys: &[&'a str; D], ) -> [usize; D]

Convert a list of keys to a selection.

pub fn _resolve( &'a self, shape: &[usize], env: &mut [Option<isize>], ) -> Result<(), String>

Low-level resolver.

Trait Implementations

impl<'a> Clone for ShapeContract<'a>

fn clone(&self) -> ShapeContract<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ShapeContract<'a>

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

Formats the value using the given formatter.

impl Display for ShapeContract<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq for ShapeContract<'a>

fn eq(&self, other: &ShapeContract<'a>) -> 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<'a> Eq for ShapeContract<'a>

impl<'a> StructuralPartialEq for ShapeContract<'a>