fn should_keep_old_sig(new_sig: &FoldedElement<R>, old_sig: &FoldedElement<R>) -> bool {
        !old_sig.is_abstract() && new_sig.is_abstract()
            || old_sig.is_abstract() == new_sig.is_abstract()
                && !old_sig.is_synthesized()
                && new_sig.is_synthesized()
    }
// Reasons to keep the old signature:
//   - We don't want to override a concrete method with an
//     abstract one;
//   - We don't want to override a method that's actually
//     implemented by the programmer with one that's "synthetic",
//     e.g. arising merely from a require-extends declaration in a
//     trait.
// When these two considerations conflict, we give precedence to
// abstractness for determining priority of the method.
Reasons to keep the old signature:
We don't want to override a concrete method with an
abstract one;
We don't want to override a method that's actually
implemented by the programmer with one that's "synthetic",
e.g. arising merely from a require-extends declaration in a
trait.
When these two considerations conflict, we give precedence to
abstractness for determining priority of the method.
Reasons to keep the old signature : We don ' t want to override a concrete method with an abstract one ; We don ' t want to override a method that ' s actually implemented by the programmer with one that ' s " synthetic " e . g . arising merely from a require - extends declaration in a trait . When these two considerations conflict we give precedence to abstractness for determining priority of the method .
fn should_keep_old_sig(new_sig: &FoldedElement<R>, old_sig: &FoldedElement<R>) -> bool {
        !old_sig.is_abstract() && new_sig.is_abstract()
            || old_sig.is_abstract() == new_sig.is_abstract()
                && !old_sig.is_synthesized()
                && new_sig.is_synthesized()
    }
fn should_keep_old_sig ( new_sig : & FoldedElement < R > , old_sig : & FoldedElement < R > ) -> bool { ! old_sig . is_abstract ( ) && new_sig . is_abstract ( ) || old_sig . is_abstract ( ) == new_sig . is_abstract ( ) && ! old_sig . is_synthesized ( ) && new_sig . is_synthesized ( ) }
Reasons to keep the old signature:
 We don't want to override a concrete method with an
abstract one;
 We don't want to override a method that's actually
implemented by the programmer with one that's "synthetic",
e.g.
Reasons to keep the old signature : We don ' t want to override a concrete method with an abstract one ; We don ' t want to override a method that ' s actually implemented by the programmer with one that ' s " synthetic " e . g .
new_sig
&FoldedElement<R>
old_sig
&FoldedElement<R>