fn disallowed_operators() -> Vec<BinaryOpKind> {
    vec![
        BinaryOpKind::And,
        BinaryOpKind::Or,
        BinaryOpKind::Divide,
        BinaryOpKind::Multiply,
    ]
}
/// For now we disallow statement of the form `constrain x / y` as their meaning is a bit ambiguous
/// In the future, if the user inputs a disallowed operator, we may modify the AST so that it's RHS is `== 0`
///
/// We could also do it for the other expressions:
///
/// Example : `constrain x` becomes `constrain x == 0`
///
/// Example :  `constrain x / y` becomes `constrain x/y == 0`
///
///
/// XXX: Although explicitness is preferred, in this case it seems that since we will always be adding a `== 0`
/// it may be fine. Since this change is backwards compatible, it is not necessary to make an eager decision without
/// more case study.
For now we disallow statement of the form `constrain x / y` as their meaning is a bit ambiguous
In the future, if the user inputs a disallowed operator, we may modify the AST so that it's RHS is `== 0`

We could also do it for the other expressions.

Example : `constrain x` becomes `constrain x == 0`

Example :  `constrain x / y` becomes `constrain x/y == 0`

Although explicitness is preferred, in this case it seems that since we will always be adding a `== 0`
it may be fine. Since this change is backwards compatible, it is not necessary to make an eager decision without
more case study.
For now we disallow statement of the form ` constrain x / y ` as their meaning is a bit ambiguous In the future if the user inputs a disallowed operator we may modify the AST so that it ' s RHS is ` == 0 ` We could also do it for the other expressions . Example : ` constrain x ` becomes ` constrain x == 0 ` Example : ` constrain x / y ` becomes ` constrain x / y == 0 ` Although explicitness is preferred in this case it seems that since we will always be adding a ` == 0 ` it may be fine . Since this change is backwards compatible it is not necessary to make an eager decision without more case study .
fn disallowed_operators() -> Vec<BinaryOpKind> {
    vec![
        BinaryOpKind::And,
        BinaryOpKind::Or,
        BinaryOpKind::Divide,
        BinaryOpKind::Multiply,
    ]
}
fn disallowed_operators ( ) -> Vec < BinaryOpKind > { vec ! [ BinaryOpKind And BinaryOpKind Or BinaryOpKind Divide BinaryOpKind Multiply ] }
For now we disallow statement of the form `constrain x / y` as their meaning is a bit ambiguous
In the future, if the user inputs a disallowed operator, we may modify the AST so that it's RHS is `== 0`
For now we disallow statement of the form ` constrain x / y ` as their meaning is a bit ambiguous In the future if the user inputs a disallowed operator we may modify the AST so that it ' s RHS is ` == 0 `