Struct leo_asg::reducer::ReconstructingDirector

pub struct ReconstructingDirector<'a, R: ReconstructingReducerExpression<'a>> { /* fields omitted */ }

Implementations

impl<'a, R: ReconstructingReducerExpression<'a>> ReconstructingDirector<'a, R>

pub fn new(context: AsgContext<'a>, reducer: R) -> Self

pub fn reducer(self) -> R

pub fn reduce_expression(
    &mut self,
    input: &'a Expression<'a>
) -> &'a Expression<'a>

pub fn reduce_array_access(
    &mut self,
    input: ArrayAccessExpression<'a>
) -> Expression<'a>

pub fn reduce_array_init(
    &mut self,
    input: ArrayInitExpression<'a>
) -> Expression<'a>

pub fn reduce_array_inline(
    &mut self,
    input: ArrayInlineExpression<'a>
) -> Expression<'a>

pub fn reduce_array_range_access(
    &mut self,
    input: ArrayRangeAccessExpression<'a>
) -> Expression<'a>

pub fn reduce_binary(&mut self, input: BinaryExpression<'a>) -> Expression<'a>

pub fn reduce_call(&mut self, input: CallExpression<'a>) -> Expression<'a>

pub fn reduce_circuit_access(
    &mut self,
    input: CircuitAccessExpression<'a>
) -> Expression<'a>

pub fn reduce_circuit_init(
    &mut self,
    input: CircuitInitExpression<'a>
) -> Expression<'a>

pub fn reduce_ternary_expression(
    &mut self,
    input: TernaryExpression<'a>
) -> Expression<'a>

pub fn reduce_cast_expression(
    &mut self,
    input: CastExpression<'a>
) -> Expression<'a>

pub fn reduce_constant(&mut self, input: Constant<'a>) -> Expression<'a>

pub fn reduce_tuple_access(
    &mut self,
    input: TupleAccessExpression<'a>
) -> Expression<'a>

pub fn reduce_tuple_init(
    &mut self,
    input: TupleInitExpression<'a>
) -> Expression<'a>

pub fn reduce_unary(&mut self, input: UnaryExpression<'a>) -> Expression<'a>

pub fn reduce_variable_ref(&mut self, input: VariableRef<'a>) -> Expression<'a>

impl<'a, R: ReconstructingReducerStatement<'a>> ReconstructingDirector<'a, R>

pub fn reduce_statement(
    &mut self,
    input: &'a Statement<'a>
) -> &'a Statement<'a>

pub fn reduce_assign_access(
    &mut self,
    input: AssignAccess<'a>
) -> AssignAccess<'a>

pub fn reduce_assign(&mut self, input: AssignStatement<'a>) -> Statement<'a>

pub fn reduce_block(&mut self, input: BlockStatement<'a>) -> Statement<'a>

pub fn reduce_conditional_statement(
    &mut self,
    input: ConditionalStatement<'a>
) -> Statement<'a>

pub fn reduce_formatted_string(
    &mut self,
    input: FormatString<'a>
) -> FormatString<'a>

pub fn reduce_console(&mut self, input: ConsoleStatement<'a>) -> Statement<'a>

pub fn reduce_definition(
    &mut self,
    input: DefinitionStatement<'a>
) -> Statement<'a>

pub fn reduce_expression_statement(
    &mut self,
    input: ExpressionStatement<'a>
) -> Statement<'a>

pub fn reduce_iteration(
    &mut self,
    input: IterationStatement<'a>
) -> Statement<'a>

pub fn reduce_return(&mut self, input: ReturnStatement<'a>) -> Statement<'a>

impl<'a, R: ReconstructingReducerProgram<'a>> ReconstructingDirector<'a, R>

pub fn reduce_circuit_member(
    &mut self,
    input: CircuitMember<'a>
) -> CircuitMember<'a>

pub fn reduce_circuit(&mut self, input: &'a Circuit<'a>) -> &'a Circuit<'a>

pub fn reduce_program(&mut self, input: Program<'a>) -> Program<'a>