Someone needs to create a brew formula for `hear`.

And how does repogather do it? From the README, it looks to me like it might provide the content of each file to the LLM to gauge its relevance. But this would seem prohibitively expensive on anything that isn't a very small codebase (the project I'm working on has on the order of 400k SLOC), even with gpt-4o-mini, wouldn't it?

Yes, Form Builder, in Orbeon Forms, allows you to create a page with form fields, use the provided values to call a REST/CRUD API, and show the result on that page. You can try that out for yourself on demo.orbeon.com, or download the software and run it locally.

There is an open source (LGPL) Community Edition, but the services & actions feature you need for this is only available in the Professional Edition. This being said, if you just need this for your own local testing, you can get a trial license (automatic process, valid 3 months, no limit on number of licenses you get), and have fun with it.

Bias: I'm one of the Orbeon Forms developers ;). ‑Alex

Here is a link:

http://www.haskell.org/haskellwiki/Correctness_of_short_cut_...

OK, maybe we're getting somewhere. Let me try to write this `map`, just to see. I'm using Scala, so I can put some types, and have the compiler yell at me if I'm doing something overtly wrong (I need all the help I can get!).

For clarity, let's define a type alias for reducers:

    type Reducer[X, A] = (X, A) ⇒ X

Let's define `map` to match the type definition you provided. And with that type definition, I only see one way in which the function can be implemented. So it must be:

    def map[X, A, B](f: A ⇒ B): (Reducer[X, B] ⇒ Reducer[X, A]) =
        (redB: Reducer[X, B]) ⇒ (x: X, a: A) ⇒ redB(x, f(a))

How can I use this? Let's try the following:

    def addup(zero: Int, a: List[Int]) = a.foldLeft(zero)(_ + _)
    def parseList(a: List[String]) = a.map(_.toInt)

    map(parseList)(addup)(1, List("7", "8"))

This returns 16. OK, parsing the list, and adding up starting from 1. But it doesn't look to me like `map` implements anything like the usual semantic of map. It just converts the data structure, and applies the reducer. What am I missing here?

Providing the signature of this new `map` function (e.g. as in Haskell's fmal http://www.haskell.org/hoogle/?hoogle=fmap), would certainly go a long way towards helping people understand what this `map` does.