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. -
repa-eval
High performance, regular, shape polymorphic parallel arrays. -
repa-scalar
High performance, regular, shape polymorphic parallel arrays. -
repa-convert
High performance, regular, shape polymorphic parallel arrays. -
repa-array
High performance, regular, shape polymorphic parallel arrays. -
parameterized-utils
A set of utilities for using indexed types including containers, equality, and comparison. -
ethereum-client-haskell
A Haskell version of an Ethereum client -
type-level-sets
Type-level sets for Haskell (with value-level counterparts and various operations) -
justified-containers
Standard containers, with keys that carry type-level proofs of their own presence. -
bytestring-trie
An efficient finite map from (byte)strings to values. -
ixset-typed
More strongly typed variant of the ixset Haskell package -
knit
Ties the knot on data structures that reference each other by unique keys -
nonempty-containers
Efficient non-empty 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 -
map-syntax
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.