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

parameterizedutils
A set of utilities for using indexed types including containers, equality, and comparison. 
justifiedcontainers
Standard containers, with keys that carry typelevel proofs of their own presence.
InfluxDB  Power RealTime Data Analytics at Scale
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.