How to use an arbitrary makeFields lens argument with different types in the same function?

In order to decide what to do, you need to know what type of field (makeField was created).

Therefore, abstraction covering all x bearing types (I noticed the abstraction I was complaining about before using makeFields) is a multi parameter type class HasX as well as other fields. This allows different types of x to be used in a single implementation.

However, in order to realize this, it is necessary to abstract classes such as HasX and HasY. In fact, because ConstraintKinds extension can abstract type classes, is this a little realistic? here:

As long as we abandon this versatility and replace the string, it is necessary to determine the first agent of the intermediate type. In addition, you need to specify the field by passing the second proxy twice with getter as a parameter. I have no idea that this second solution is worth the trouble - additional templates that have to define qx, qy, etc seem to be much more painful than all the roundabouts contained here. Still, if you are reading someone in this article who wants to make suggestions for improvement, I will explain it in full.

The list of specific functions is somewhat arbitrary here, so limit it to where you need to make the FFT work. Field :: U must be defined as its element type by its concrete field implementation. By using various types, you can statically check confusion between Rust integer primitives and field elements. As promised, we abstracted in the field of cooperation. F :: U replaces the primitives used previously in place of the original primitives used, we give the function the actual Field (called zp) implementation. Now we need to get zero and one expression from the field and call zp to replace the addition and multiplication operators. I am using assistance

I think that the kind of function is a little confusing. As with the keyword uint 256 that specifies the type of an int variable of 256, you can also specify the type of the variable holding the function. The only difference is that this type declaration is a bit more complicated. The function is more complex because it looks like this:

Currently stepIncreaser takes parameters as MorningWalk instances and returns functions of type (Int) -> (). Therefore, the returned function will receive an Int type parameter and will return nothing. Here, the returned function and the addSteps () function have the same type of method signature. The same concept applies to stepDecreaser as well. In this article, there is a function with multiple parameters. It converts it to a function that takes only one argument at a time, and generates another function until there are no more arguments. This will give you the final result. Therefore, a function can be said to be just a normal value that can be generated and returned by other functions.