Trait leo_asg::reducer::MonoidalReducerExpression[−][src]

pub trait MonoidalReducerExpression<'a, T: Monoid> {

Show methods    fn reduce_expression(&mut self, input: &'a Expression<'a>, value: T) -> T { ... }

    fn reduce_array_access(
        &mut self, 
        input: &ArrayAccessExpression<'a>, 
        array: T, 
        index: T
    ) -> T { ... }

    fn reduce_array_init(
        &mut self, 
        input: &ArrayInitExpression<'a>, 
        element: T
    ) -> T { ... }

    fn reduce_array_inline(
        &mut self, 
        input: &ArrayInlineExpression<'a>, 
        elements: Vec<T>
    ) -> T { ... }

    fn reduce_array_range_access(
        &mut self, 
        input: &ArrayRangeAccessExpression<'a>, 
        array: T, 
        left: Option<T>, 
        right: Option<T>
    ) -> T { ... }

    fn reduce_binary(
        &mut self, 
        input: &BinaryExpression<'a>, 
        left: T, 
        right: T
    ) -> T { ... }

    fn reduce_call(
        &mut self, 
        input: &CallExpression<'a>, 
        target: Option<T>, 
        arguments: Vec<T>
    ) -> T { ... }

    fn reduce_circuit_access(
        &mut self, 
        input: &CircuitAccessExpression<'a>, 
        target: Option<T>
    ) -> T { ... }

    fn reduce_circuit_init(
        &mut self, 
        input: &CircuitInitExpression<'a>, 
        values: Vec<T>
    ) -> T { ... }

    fn reduce_ternary_expression(
        &mut self, 
        input: &TernaryExpression<'a>, 
        condition: T, 
        if_true: T, 
        if_false: T
    ) -> T { ... }

    fn reduce_cast_expression(
        &mut self, 
        input: &CastExpression<'a>, 
        inner: T
    ) -> T { ... }

    fn reduce_constant(&mut self, input: &Constant<'a>) -> T { ... }

    fn reduce_tuple_access(
        &mut self, 
        input: &TupleAccessExpression<'a>, 
        tuple_ref: T
    ) -> T { ... }

    fn reduce_tuple_init(
        &mut self, 
        input: &TupleInitExpression<'a>, 
        values: Vec<T>
    ) -> T { ... }

    fn reduce_unary(&mut self, input: &UnaryExpression<'a>, inner: T) -> T { ... }

    fn reduce_variable_ref(&mut self, input: &VariableRef<'a>) -> T { ... }

}

Provided methods

Implementors