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

Agda
Agda is a dependently typed programming language / interactive theorem prover. 
vinyl
Extensible Records for Haskell. Pull requests welcome! Come visit us on #vinyl on freenode. 
repaeval
High performance, regular, shape polymorphic parallel arrays. 
repascalar
High performance, regular, shape polymorphic parallel arrays. 
repaconvert
High performance, regular, shape polymorphic parallel arrays. 
repaarray
High performance, regular, shape polymorphic parallel arrays. 
parameterizedutils
A set of utilities for using indexed types including containers, equality, and comparison. 
ethereumclienthaskell
A Haskell version of an Ethereum client 
typelevelsets
Typelevel sets for Haskell (with valuelevel counterparts and various operations) 
justifiedcontainers
Standard containers, with keys that carry typelevel proofs of their own presence. 
bytestringtrie
An efficient finite map from (byte)strings to values. 
ixsettyped
More strongly typed variant of the ixset Haskell package 
knit
Ties the knot on data structures that reference each other by unique keys 
nonemptycontainers
Efficient nonempty variants of containers data types, with full API 
eliminators
Dependently typed elimination functions using singletons 
claferIG
Support for reasoning on Clafer models by instantiation and counter example generation. 
igraph
Incomplete Haskell bindings to the igraph library (which is written in C) 
selections
Haskell Package for operating with selections over an underlying functor 
mapsyntax
Syntax sugar and explicit semantics for statically defined maps
Collect and Analyze Billions of Data Points in Real Time
Do you think we are missing an alternative of naperian or a related project?
README
naperian
This package provides Naperian
functors, a more powerful form of
Distributive
functor which is equal in power to a Representable
functor (for
some Rep
), but which can be implemented asymptotically more efficiently for
instances which don't support random access.
Distributive
functors allow distribution of Functor
s:
distribute :: (Distributive f, Functor g) => g (f a) > f (g a)
With Distributive
, you can, for example, zip two containers by distributing
the Pair
Functor
:
data Pair a = Pair a a deriving Functor
zipDistributive :: Distributive f => f a > f a > f (a, a)
zipDistributive xs ys = fmap f $ distribute (Pair xs ys)
where f (Pair x y) = (x, y)
Note that the two containers must have elements of the same type. Naperian
,
however, allows the containers to have elements of different types:
zipNaperian :: Naperian f => f a > f b > f (a, b)
It does so by allowing distribution of Functor1
s, where a Functor1
is a
functor from Hask > Hask
to Hask
:
class Functor1 w where
map1 :: (forall a. f a > g a) > w f > w g
distribute1 :: (Naperian f, Functor1 w) => w f > f (w Identity)
The more polymorphic zip can then be implemented by distributing the Pair1
Functor1
:
data Pair1 a b f = Pair1 (f a) (f b)
instance Functor1 (Pair1 a b) where ...
zipNaperian :: Naperian f => f a > f b > f (a, b)
zipNaperian as bs = fmap f $ distribute1 (Pair1 as bs)
where f (Pair1 (Identity a) (Identity b)) = (a, b)
Naperian
functors can be shown to be equivalent to Representable
functors,
for some Rep
, by selecting Rep f = ∀x. f x > x
. That is, a position in a
Naperian
container can be represented as a function which gets the value at
that position. tabulate
can then be derived using the Functor1
:
newtype TabulateArg a f = TabulateArg ((forall x. f x > x) > a)
The rest is left as an exercise for the reader.