refl | Provides a Refl encoding in Rust

while

In the agda/cubical library we do tend to export the equivalence (or the iso) along with the path, because of issues like the one you mention.

The reason for those extra transp calls is that transport for Glue has to work in the general case where they might actually be required.

fst (prim^unglue a) should reduce away if you ask for the normal form though.

For Nat comparison you can use Data.Nat's GT (greater than), GTE (greater-equal than), LT (less than), LTE (less-equal than). So GT c a and LT c b for c > a and c < b.

For and you can just put both proofs into a tuple: (GT c a, LT c b). If, for example, you would have wanted to or them, you could use Either (GT c a) (LT c b).

Thus:

Now I know where the actual bug is.

If the same happens to you then kindly note that it is due to the 3rd party library that you are using in your project.

So the solution is to remove that library from your project and try another one , moreover try to code from scratch for that task if possible instead of using such libraries.

It happens because those libraries use another library or libraries.

Hope it helps you.

Happy coding :)

Function parameters are variables. Not variable templates; just regular old variables. And a non-template variable cannot be given template parameters.

You cannot pass a function template anywhere. You can only pass a particular instantiation of a function template. The closest you can get to what you want is to pass a type that has a templated operator() overload, but unless you can provide the template parameters through deduction, the only way to invoke it is via fn.operator()(params). So you may as well have given it a meaningful name.

Found the solution on my own just use $less$colon$less$.MODULE$.refl() instead of Predef.>conforms()

filter' ... (x ∷ filter' ... xs) | x ≡ᵇ id) means that the evaluation of this function is stuck on the test x ≡ᵇ id.

To have it reduce, you would typically use with x ≡ᵇ id. But you've already done that! Yes, but the with you used targeted the inner filter that was stuck at the time. Once it got unstuck, it computed enough to emit x ∷ _ and that got the outer filter stuck on the second test (that happens to be equal to the first one).

The idiomatic way to deal with this is via the inspect idiom that will allow you to, in a single with, get your hands on not only the result of x ≡ᵇ id but also a proof that the result was computed from this expression. Once you reach the point where the outer filter is stuck, you can simply rewrite by this equation and you should then be able to see the function compute just enough that it will be possible to call the induction hypothesis.

I suggest the following solution:

I suggest the following solution: