hint VS recursion-schemes

Mueval is based on hint, which is in turn based on the ghc library.

Yeah, that project is pretty much at the bottom of my list, unfortunately. My top projects these days are mgmt, klister, recursion-schemes, and hint... And that's already too much!

You can try using hint (instead of ghci) though I'm not sure it has the breakpoint functionality.

Have you tried hint?

with haskell.nix, well, you've found the github issue, you need to put the apecs package in the right nix incantation.

But the use case for that is for using a Haskell program A to catch errors in that same Haskell program A. For your use case, using a Haskell program A to automatically grade a Haskell program B, I recommend using the hint library instead, as it allows you to load code from external source files, run tests on them, and manipulate the error messages produced by ghc. (full disclosure: I am the maintainer of that library)

I am thinking of giving hint the ability to evaluate TemplateHaskell expressions. It would indeed be quite difficult to write an interpreter for all of Haskell, so my plan is to use the Exp's Show instance to produce a program which constructs and then splices that Exp, e.g. $(pure (InfixE (Just (LitE (IntegerL 1))) (VarE GHC.Num.+) (Just (LitE (IntegerL 1))))) is a Haskell expression which is equivalent to 1 + 1, so I should be able to ask hint to evaluate that to get 2 without having to write my own Haskell interpreter.

Yes please! Right now all of my open-source projects (most notably hint and recursion-schemes) are about to drop into barely-updated mode, and while I knew this would happen and have been working towards finding co-maintainers, I am now realizing that it wasn't enough. I think such a website would definitely have helped, and I am hoping that once it launches, I'll be able to use it to find some co-maintainers to tide over my projects until I become available again.

hint's API takes a string, not an AST (I plan to fix this). Internally, hint delegates to the ghc library, which does expose a parser which you can use if you want. hint exists to provide a friendlier API than the ghc library for interpreting Haskell code, but it does not expose a friendlier API for parsing Haskell code.

Reasonably proud of my part 2 solution, although would like to try using a recursion scheme rather than unstructured recursion:

Yeah, that project is pretty much at the bottom of my list, unfortunately. My top projects these days are mgmt, klister, recursion-schemes, and hint... And that's already too much!

In a programming context, recursion schemes can be used to write recursive (or corecursive) functions, by automating/abstracting away the common boilerplate part of actually doing the recursion. They take the form of polymorphic higher-order functions, which can be imported from a library like this classic one.

Maybe I didn't link the best post. It is unfortunately the only one I know that uses Rust. If you are able to read Haskell, the documentation for the recursion-schemes package might be a better resource?

Writing something as a type of fold over an infinite sequence is nicer than using recursion directly in my opinion. See: https://hackage.haskell.org/package/recursion-schemes

Consider recursion schemes! It let's you separate the logic of how your recursion is structured on your data, and the logic of what you're doing on each recursion stage. So e.g. you can write the core logic of a recursive linked list summation as just fun x accum -> x + accum, and then you just find the appropriate recursion scheme to pipe the list values into x and handle recursing to build accum (a catamorphism in this case)

It's a pretty complicated bug, documented in details at https://github.com/recursion-schemes/recursion-schemes/issues/50

It’s also trivial and easy in Haskell — you just need an instance of `Foldable` or `Traversable` on your collection, and then you can fold or traverse it in a configurable way. Or for recursive structures, use https://hackage.haskell.org/package/recursion-schemes. Or even just pass a traversal function as an argument for maximum flexibility.

https://hackage.haskell.org/package/recursion-schemes is the "normal" library for this type of generalized folding. It even contains Base instances for Maybe and Either.

I've been working on a system which uses recursion-schemes to annotate a recursive type. The annotated tree itself is pretty simple; at each level, we pair the annotation with the base functor, or