falgebragen alternatives and similar packages
Based on the "Data" category.
Alternatively, view falgebragen alternatives based on common mentions on social networks and blogs.

semanticsource
Parsing, analyzing, and comparing source code across many languages 
lens
Lenses, Folds, and Traversals  Join us on web.libera.chat #haskelllens 
text
Haskell library for space and timeefficient operations over Unicode text. 
codebuilder
Packages for defining APIs, running them, generating client code and documentation. 
unorderedcontainers
Efficient hashingbased container types 
cassava
A CSV parsing and encoding library optimized for ease of use and high performance 
compendiumclient
Mu (μ) is a purely functional framework for building micro services. 
holmes
A reference library for constraintsolving with propagators and CDCL. 
binary
Efficient, pure binary serialisation using ByteStrings in Haskell. 
resourcepool
A highperformance striped resource pooling implementation for Haskell 
primitive
This package provides various primitive memoryrelated operations. 
discrimination
Fast linear time sorting and discrimination for a large class of data types 
dependentsum
Dependent sums and supporting typeclasses for comparing and displaying them 
jsonautotype
Automatic Haskell type inference from JSON input 
reflection
Reifies arbitrary Haskell terms into types that can be reflected back into terms 
safecopy
An extension to Data.Serialize with builtin version control 
audiovisual
Extensible records, variants, structs, effects, tangles 
dependentmap
Dependentlytyped finite maps (partial dependent products) 
IORefCAS
A collection of different packages for CAS based data structures. 
protobuf
An implementation of Google's Protocol Buffers in Haskell. 
orgmodeparse
Attoparsec parser combinators for parsing orgmode structured text! 
streaming
An optimized general monad transformer for streaming applications, with a simple prelude of functions 
bifunctors
Haskell 98 bifunctors, bifoldables and bitraversables 
texticu
This package provides the Haskell Data.Text.ICU library, for performing complex manipulation of Unicode text. 
scientific
Arbitraryprecision floatingpoint numbers represented using scientific notation 
uuidtypes
A Haskell library for creating, printing and parsing UUIDs 
typerepmap
⚡️Efficient implementation of Map with types as keys
Less time debugging, more time building
Do you think we are missing an alternative of falgebragen or a related project?
README
FAlgebra Data Combinator Generator
Generate an falgebra combinator from any data type.
https://hackage.haskell.org/package/falgebragen0.1.0.2
Description
This library provides a function to generate a special falgebra combinator from any data type (GADTs are not currently supported).
This was inspired by the recursionschemes 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 ''<data
type name>
as in the example below:
 List type
data List a = Nil  List a (List a)
makeBaseFunctor ''List
makeCombinator ''ListF
This example will generate the following code:
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 recursionschemes:
Without the combinator:
length :: [a] > Int length = cata gene where gene Nil = 0 gene (Cons a x) = x + 1
With the combinator:
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
recursionschemes 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.