Struct leo_compiler::program::program::ConstrainedProgram [−][src]
pub struct ConstrainedProgram<'a, F: PrimeField, G: GroupType<F>> { pub asg: Program<'a>, // some fields omitted }
Fields
asg: Program<'a>
Implementations
pub fn evaluate_console_assert<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
expression: &'a Expression<'a>,
span: &Span
) -> Result<(), ConsoleError>
pub fn evaluate_console_function_call<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
console: &ConsoleStatement<'a>
) -> Result<(), ConsoleError>
pub fn format<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
args: &ConsoleArgs<'a>
) -> Result<String, ConsoleError>
pub fn store_definition(
&mut self,
variable: &Variable<'_>,
value: ConstrainedValue<'a, F, G>
)
pub fn enforce_array<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
array: &[(Cell<&'a Expression<'a>>, bool)],
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_array<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
array: &[(Cell<&'a Expression<'a>>, bool)],
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
Enforce array expressions
pub fn enforce_array_initializer<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
element_expression: &'a Expression<'a>,
actual_size: usize
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_array_initializer<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
element_expression: &'a Expression<'a>,
actual_size: usize
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
Returns an array value from an array initializer expression.
pub fn array_bounds_check<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
index_resolved: &Integer,
array_len: u32,
span: &Span
) -> Result<(), ExpressionError>
pub fn enforce_array_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
array: &'a Expression<'a>,
index: &'a Expression<'a>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_array_range_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
array: &'a Expression<'a>,
left: Option<&'a Expression<'a>>,
right: Option<&'a Expression<'a>>,
length: usize,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_binary_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
left: &'a Expression<'a>,
right: &'a Expression<'a>
) -> Result<(ConstrainedValue<'a, F, G>, ConstrainedValue<'a, F, G>), ExpressionError>
pub fn enforce_circuit_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
expr: &CircuitAccessExpression<'a>
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_circuit<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
expr: &CircuitInitExpression<'a>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_conditional_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
conditional: &'a Expression<'a>,
first: &'a Expression<'a>,
second: &'a Expression<'a>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_conditional_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
conditional: &'a Expression<'a>,
first: &'a Expression<'a>,
second: &'a Expression<'a>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
Enforce ternary conditional expression
pub fn enforce_core_circuit_call_expression<CS: ConstraintSystem<F>, C: CoreCircuit<'a, F, G>>(
&mut self,
cs: &mut CS,
core_circuit: &C,
function: &'a Function<'a>,
target: Option<&'a Expression<'a>>,
arguments: &[Cell<&'a Expression<'a>>],
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_core_circuit_call_expression<CS: ConstraintSystem<F>, C: CoreCircuit<'a, F, G>>(
&mut self,
cs: &mut CS,
core_circuit: &C,
function: &'a Function<'a>,
target: Option<&'a Expression<'a>>,
arguments: &[Cell<&'a Expression<'a>>],
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
Call a default core circuit function with arguments
pub fn enforce_function_call_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
function: &'a Function<'a>,
target: Option<&'a Expression<'a>>,
arguments: &[Cell<&'a Expression<'a>>],
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn evaluate_ref(
&mut self,
variable_ref: &VariableRef<'_>
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn evaluate_ref(
&mut self,
variable_ref: &VariableRef<'_>
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
Enforce a variable expression by getting the resolved value
pub fn enforce_tuple_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
tuple: &'a Expression<'a>,
index: usize,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_tuple<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
tuple: &[Cell<&'a Expression<'a>>]
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
pub fn enforce_tuple<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
tuple: &[Cell<&'a Expression<'a>>]
) -> Result<ConstrainedValue<'a, F, G>, ExpressionError>
Enforce tuple expressions
pub fn allocate_array<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
name: &str,
array_type: &Type<'_>,
array_len: usize,
input_value: Option<InputValue>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, FunctionError>
pub fn allocate_main_function_input<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
type_: &Type<'_>,
name: &str,
input_option: Option<InputValue>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, FunctionError>
Process constant inputs and return ConstrainedValue with constant value in it.
pub fn constant_main_function_input<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
type_: &Type<'_>,
name: &str,
input_option: Option<InputValue>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, FunctionError>
pub fn allocate_input_keyword<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
span: &Span,
expected_type: &'a Circuit<'a>,
input: &Input
) -> Result<ConstrainedValue<'a, F, G>, FunctionError>
pub fn allocate_input_section<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
identifier: Identifier,
expected_type: &'a Circuit<'a>,
section: IndexMap<Parameter, Option<InputValue>>
) -> Result<ConstrainedValue<'a, F, G>, FunctionError>
pub fn allocate_tuple<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
name: &str,
types: &[Type<'_>],
input_value: Option<InputValue>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, FunctionError>
pub fn enforce_main_function<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
function: &'a Function<'a>,
input: &Input
) -> Result<Output, FunctionError>
pub fn conditionally_select_result<CS: ConstraintSystem<F>>(
cs: &mut CS,
expected_return: &Type<'a>,
results: Vec<(Boolean, ConstrainedValue<'a, F, G>)>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, StatementError>
pub fn conditionally_select_result<CS: ConstraintSystem<F>>(
cs: &mut CS,
expected_return: &Type<'a>,
results: Vec<(Boolean, ConstrainedValue<'a, F, G>)>,
span: &Span
) -> Result<ConstrainedValue<'a, F, G>, StatementError>
Returns a conditionally selected result from the given possible function returns and given function return type.
pub fn resolve_mut_ref<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
assignee: &'a Expression<'a>,
target_value: ConstrainedValue<'a, F, G>,
indicator: &Boolean
) -> Result<bool, StatementError>
pub fn enforce_assign_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
statement: &AssignStatement<'a>
) -> Result<(), StatementError>
pub fn resolve_assign<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
assignee: &AssignStatement<'a>,
target_value: ConstrainedValue<'a, F, G>,
indicator: &Boolean
) -> Result<(), StatementError>
pub fn evaluate_block<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
block: &BlockStatement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
pub fn evaluate_block<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
block: &BlockStatement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
Evaluates a branch of one or more statements and returns a result in the given scope.
pub fn enforce_conditional_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
statement: &ConditionalStatement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
pub fn enforce_conditional_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
statement: &ConditionalStatement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
Enforces a conditional statement with one or more branches.
Due to R1CS constraints, we must evaluate every branch to properly construct the circuit.
At program execution, we will pass an indicator
bit down to all child statements within each branch.
The indicator
bit will select that branch while keeping the constraint system satisfied.
pub fn enforce_definition_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
statement: &DefinitionStatement<'a>
) -> Result<(), StatementError>
pub fn enforce_iteration_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
statement: &IterationStatement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
pub fn enforce_return_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
statement: &ReturnStatement<'a>
) -> Result<ConstrainedValue<'a, F, G>, StatementError>
pub fn enforce_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
statement: &'a Statement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
pub fn enforce_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
indicator: &Boolean,
statement: &'a Statement<'a>
) -> StatementResult<Vec<IndicatorAndConstrainedValue<'a, F, G>>>
Enforce a program statement.
Returns a Vector of (indicator, value) tuples.
Each evaluated statement may execute of one or more statements that may return early.
To indicate which of these return values to take we conditionally select the value according
to the indicator
bit that evaluates to true.
Auto Trait Implementations
impl<'a, F, G> !RefUnwindSafe for ConstrainedProgram<'a, F, G>
impl<'a, F, G> !Send for ConstrainedProgram<'a, F, G>
impl<'a, F, G> !Sync for ConstrainedProgram<'a, F, G>
impl<'a, F, G> Unpin for ConstrainedProgram<'a, F, G> where
F: Unpin,
G: Unpin,
impl<'a, F, G> !UnwindSafe for ConstrainedProgram<'a, F, G>
Blanket Implementations
Mutably borrows from an owned value. Read more
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Causes self
to use its Binary
implementation when Debug
-formatted.
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Causes self
to use its Display
implementation when
Debug
-formatted. Read more
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Causes self
to use its LowerExp
implementation when
Debug
-formatted. Read more
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Causes self
to use its LowerHex
implementation when
Debug
-formatted. Read more
Causes self
to use its Octal
implementation when Debug
-formatted.
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Causes self
to use its Pointer
implementation when
Debug
-formatted. Read more
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Causes self
to use its UpperExp
implementation when
Debug
-formatted. Read more
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Causes self
to use its UpperHex
implementation when
Debug
-formatted. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
impl<T> Pipe for T where
T: ?Sized,
impl<T> Pipe for T where
T: ?Sized,
Pipes by value. This is generally the method you want to use. Read more
Borrows self
and passes that borrow into the pipe function. Read more
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
Mutably borrows self
and passes that borrow into the pipe function. Read more
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Borrows self
, then passes self.borrow()
into the pipe function. Read more
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
Mutably borrows self
, then passes self.borrow_mut()
into the pipe
function. Read more
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.as_ref()
into the pipe function.
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
Mutably borrows self
, then passes self.as_mut()
into the pipe
function. Read more
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.deref()
into the pipe function.
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
Pipes a dereference into a function that cannot normally be called in suffix position. Read more
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more
Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more
type Output = T
type Output = T
Should always be Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Immutable access to the Borrow<B>
of a value. Read more
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Mutable access to the BorrowMut<B>
of a value. Read more
Immutable access to the AsRef<R>
view of a value. Read more
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Mutable access to the AsMut<R>
view of a value. Read more
Immutable access to the Deref::Target
of a value. Read more
Mutable access to the Deref::Target
of a value. Read more
Calls .tap()
only in debug builds, and is erased in release builds.
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Calls .tap_borrow()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Calls .tap_borrow_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Calls .tap_ref()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Calls .tap_ref_mut()
only in debug builds, and is erased in release
builds. Read more
Provides immutable access for inspection. Read more
Calls tap
in debug builds, and does nothing in release builds.
Provides mutable access for modification. Read more
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Calls tap_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
Provides immutable access to the reference for inspection.
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Calls tap_ref
in debug builds, and does nothing in release builds.
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the reference for modification.
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_ref_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the borrow for inspection. Read more
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Calls tap_borrow
in debug builds, and does nothing in release builds.
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the borrow for modification.
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_borrow_mut
in debug builds, and does nothing in release
builds. Read more
Immutably dereferences self
for inspection.
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Calls tap_deref
in debug builds, and does nothing in release builds.
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Mutably dereferences self
for modification.
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Calls tap_deref_mut
in debug builds, and does nothing in release
builds. Read more