newType | A handy function for creating opaque types

An Iterator i o r represents a process that repeatedly takes a value of type i and outputs a value of type o, eventually breaking the iteration after one of the is by returning a r instead. E.g.

If you are sure that the key is present then you can use fromJust to turn the Maybe User into a User:

Type families are unmatchable and must be fully saturated. This means they can not be passed partially applied as an argument. This is basically what the error message says

• The associated type family ‘T’ should have 1 argument, but has been given none

At the present time this is not distinguished at the kind level (see Unsaturated type families proposal) but there is a very clear distinction within GHC.

According to :kind both T and Identity have the same kind while in reality Identity is Matchable and T is Unmatchable:

After some tests I could build a custom module type by copying parts of code from moduleobject.c

Your problem is that your code does create an instance of a subclass of module, but never initializes it and gets random values in key members. Additionaly, modules are expected to be gc collectables, so you have to create your custom module with PyObject_GC_New.

The following code replaces your initial testmod_create function with a full initialization of the module:

One answer to the linked question mentions adding an extra type parameter, so that instead of Tree (Labeled a) we use Tree Labeled a:

I see two problems with this program. One of them I know how to fix, but the other apparently requires more knowledge of recursion schemes than I have.

The one I can fix is that it's looking up the wrong values in its cache. When given = 10, of course validCoins = [10,5,1], and so we find (zeroes, toProcess) = ([0], [5,9]). So far so good: we can give a dime directly, or give a nickel and then make change for the remaining five cents, or we can give a penny and change the remaining nine cents. But then when we write lookup 9 attr, we're saying "look 9 steps in history to when curr = 1", where what we meant was "look 1 step into history to when curr = 9". As a result we drastically undercount in pretty much all cases: even change 100 is only 16, while a Google search claims the right result is 292 (I haven't verified this today by implementing it myself).

There are a few equivalent ways to fix this; the smallest diff would be to replace

If you provide the applicative functor to liftA3, then the following typechecks:

I think there's a couple reasoning errors going on here at once.

First: when you write

One simple way to solve it is to change the second deriving clause to: