# F-Algebra Data Combinator Generator Generate an f-algebra combinator from any data type. https://hackage.haskell.org/package/f-algebra-gen-0.1.0.0 ## Description This library provides a function to generate a special f-algebra combinator from any data type (GADTs are not currently supported). This was inspired by the recursion-schemes library where they have a function to automagically generate a base functor. Although, this new base functor data type has custom constructors and to define the \*-morphism algebras turns into boring pattern matching. So, this library provides a function called `makeCombinator` that produces a nice combinator to deal with data types as they were defined in terms of Pairs (`(,)`) and Sums (`Either`). With this nice combinator we are able to view a data type as its equivalent categorical isomorphism and manipulate it with an interface similar as the `either` function provided from `base`. ## Example To create this special combinator you just need to call `makeCombinator ''` as in the example below: ```Haskell -- List type data List a = Nil | List a (List a) makeBaseFunctor ''List makeCombinator ''ListF ``` This example will generate the following code: ```Haskell makeCombinator ''ListF ======> listf f_acw7 f_acw8 Nil = f_acw7 () listf f_acw7 f_acw8 (Cons a_acw9 a_acwa) = f_acw8 (a_acw9, a_acwa) ``` As you can see it's pretty close as to have the type defined as the set of sums and pairs `data List a = Either () (a, List a)`, which we could then use `either` function as well as other convinent `(,)` combinators. An **important** note is that the generated function has always the same name as the data type but in low characters **and** the order of the functions to be applied to the type constructors it's the same order which they were declared. A simple example on how we can beneficiate from using this special combinator when defining catamorphisms using recursion-schemes: - Without the combinator: ```Haskell length :: [a] -> Int length = cata gene where gene Nil = 0 gene (Cons a x) = x + 1 ``` - With the combinator: ```Haskell makeCombinator'' ListF length :: [a] -> Int length = cata (listf (const 0) (succ . snd)) ``` I recognize that for such a simple data type and catamorphism it's hard to see any gain in readability/implementation. But with this special combinator it's a lot easier to go from paper to code as it's almost a direct translation. There's a fully working example in the `examples` folder that uses the recursion-schemes library as well as a nice small program calculus (AoP inspired) combinators library to show how simple and straightforward it is to use it with this new combinator.