combinators

[KiaraGrouwstra]

my approach needs strong polymorphism, and combinators are a huge part of this. this feature is non-negotiable and I'll need to figure things out. while theoretically type variables can be functions all the way down, in practice I can probably bias things to bound complexity somehow (don't (usually) instantiate unbounded type variables to functions?).

functional programming makes gratuitous use of combinators, or functions manipulating functions. this has two sides:

• functions returning functions, in our curried language analogous to functions taking multiple parameters. testing these basically requires tuples of multiple arguments as input rather than just one. the tricky part here is that due to type variables, the type of further arguments can be influenced by the type variable instantiations of previous parameters.
• functions taking functions as parameters -- this is tough because my QuickCheck value instantiation from type fails for function types. I have had my own method for instantiating functions from a type signature, but for now just added programs by type as combinator samples.

notes:

• combinators error, cannot generate input samples of type function
• to allow generating generic function types, track type variable names to generate new ones

update: I feel like trying the remaining blocks I've just hit all the ugly edge-cases now.

• isFn checks for type that are a function, while there are also types that contain a function type wrapped inside e.g. a list -- these types similarly could not be instantiated by QuickCheck... this gives many types in type_fn_instantiations that cannot get instantiations. I just added a hasFn check to just ditch the bad stuff from rest for now. cuz honestly, lists of functions is some bs that doesn't happen in the real world, and I don't care.