Module snarkvm_circuit_environment::prelude

Re-exports

• pub use crate::count;
• pub use crate::count;
• pub use crate::witness;
• pub use crate::witness;
• pub use crate::CircuitType;
• pub use crate::Count;
• pub use crate::Environment;
• pub use crate::LinearCombination;
• pub use crate::Mode;
• pub use crate::OutputMode;
• pub use crate::Variable;
• pub use console::prelude::One as _;
• pub use console::prelude::Zero as _;
• pub use console::traits::Double as _;
• pub use console::traits::FromBits as _;
• pub use console::traits::Inverse as _;
• pub use console::traits::Square as _;
• pub use console::traits::SquareRoot as _;
• pub use console::traits::ToBits as _;
• pub use snarkvm_fields::Field as _;
• pub use snarkvm_fields::Zero as _;
• pub use snarkvm_utilities::ToBits as _;
• pub use snarkvm_curves::AffineCurve as _;
• pub use crate::traits::*;

Modules

• fmt
  Utilities for formatting and printing strings.
• string_parser
  From https://github.com/Geal/nom/blob/main/examples/string.rs This example shows an example of how to parse an escaped string. The rules for the string are similar to JSON and rust. A string is:

Macros

• bail
  Return early with an error.
• count
• ensure
• output_mode
• rename_selfs
• witness
  The witness! macro is a closure that takes in a list of circuits, eject the value of each circuit, and uses it in the subsequent code block.
• witness_mode
  The witness_mode! macro returns the expected mode given a list of circuits.

Structs

• Error
  The Error type, a wrapper around a dynamic error type.
• Formatter
  Configuration for formatting.
• IndexMap
  A hash table where the iteration order of the key-value pairs is independent of the hash values of the keys.
• OnceCell
  A cell which can be written to only once. It is not thread safe.

Traits

• Add
  The addition operator +.
• AddAssign
  The addition assignment operator +=.
• BitAnd
  The bitwise AND operator &.
• BitAndAssign
  The bitwise AND assignment operator &=.
• BitOr
  The bitwise OR operator |.
• BitOrAssign
  The bitwise OR assignment operator |=.
• BitXor
  The bitwise XOR operator ^.
• BitXorAssign
  The bitwise XOR assignment operator ^=.
• CheckedPow
• Debug
  ? formatting.
• Deref
  Used for immutable dereferencing operations, like *v.
• Display
  Format trait for an empty format, {}.
• Div
  The division operator /.
• DivAssign
  The division assignment operator /=.
• FromStr
  Parse a value from a string
• IntegerProperties
  Properties common to all integer types.
• IntegerType
  Trait bound for integer values. Common to both signed and unsigned integers.
• Inv
  Unary operator for retrieving the multiplicative inverse, or reciprocal, of a value.
• Itertools
  An Iterator blanket implementation that provides extra adaptors and methods.
• Magnitude
  Trait for integers that can be used as an unsigned magnitude. Magnitudes are either used to represent an integer exponent or the right operand in integer shift operations.
• Mul
  The multiplication operator *.
• MulAssign
  The multiplication assignment operator *=.
• Neg
  The unary negation operator -.
• Not
  The unary logical negation operator !.
• NumOne
  Defines a multiplicative identity element for Self.
• Parser
  Operations to parse a string literal into an object.
• Pow
  Binary operator for raising a value to a power.
• PrimeField
  The interface for a prime field.
• Rem
  The remainder operator %.
• RemAssign
  The remainder assignment operator %=.
• Shl
  The left shift operator <<. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ << _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a << b and a.shl(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.
• ShlAssign
  The left shift assignment operator <<=.
• Shr
  The right shift operator >>. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ >> _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a >> b and a.shr(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.
• ShrAssign
  The right shift assignment operator >>=.
• Sub
  The subtraction operator -.
• SubAssign
  The subtraction assignment operator -=.
• TypeName
• Unsigned
  A trait for values which cannot be negative
• WrappingDiv
• WrappingPow
• WrappingRem

Functions

• alpha1
  Recognizes one or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z
• alphanumeric1
  Recognizes one or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z
• alt
  Tests a list of parsers one by one until one succeeds.
• char
  Recognizes one character.
• has_duplicates
  Returns true if the given iterator has duplicate elements.
• many0
  Repeats the embedded parser, gathering the results in a Vec.
• many1
  Runs the embedded parser, gathering the results in a Vec.
• map
  Maps a function on the result of a parser.
• map_res
  Applies a function returning a Result over the result of a parser.
• one_of
  Recognizes one of the provided characters.
• opt
  Optional parser, will return None on Err::Error.
• pair
  Gets an object from the first parser, then gets another object from the second parser.
• recognize
  If the child parser was successful, return the consumed input as produced value.
• tag
  Recognizes a pattern
• terminated
  Gets an object from the first parser, then matches an object from the second parser and discards it.

Type Definitions

• ParserResult
  The nom-compatible parser return type.
• Result
  Result<T, Error>

Derive Macros

• Debug
  Derive macro generating an impl of the trait Debug.