Haskell Data Structures

A dependently typed functional programming language and proof assistant

A tasty Haskell front-end framework

Assorted concrete container types

Extensible Records

A framework for generating singleton types

A distribution of the 'containers' package, with all modules exposed.

Packing and unpacking flat tables.

Implementation of Univalence in Cubical Sets

Scalar data types and conversions.

Bulk array representations and operators.

Low-level parallel operators on bulk random-accessble arrays.

A Haskell version of an Ethereum client

Classes and data structures for working with data-kind indexed types

Pure priority search queues

Anonymous records and overloaded labels

A language based on homotopy type theory with an interval type

Distributive functors -- Dual to Traversable

Compiles Clafer models to other formats

Type-level sets and finite maps (with value-level counterparts)

A library of efficient, purely-functional data structures (API)

A purely functional and persistent hash map

Keyed container types with verified keys.

A Haskell 98 logically uninhabited data type

A space-efficient set data structure.

The Data.MultiSet container type

Asymptotically optimal Brodal/Okasaki heaps.

Efficient relational queries on Haskell sets.

Anonymous extensible records

claferIG is an interactive tool that generates instances of Clafer models.

Generic strict finger-tree structure

Extensions to Data.Map

R-Tree is a spatial data structure similar to Quadtrees or B-Trees.

Graphs and networks library

An efficient finite map from (byte)strings to values.

Very strict CPS'd transformers

Dependently typed elimination functions using singletons

Bindings to the igraph C library.

Plugin and base library to support supermonads in Haskell

Efficient relational queries on Haskell sets.

Syntax sugar for defining maps

Program to derive type class instances

Composition trees for arbitrary monoids.

Typechecking terms of the Edinburgh Logical Framework (LF).

Program to derive type class instances

Combinators for operating with selections over an underlying functor

Simple functional ring type.

Support for image reading and writing of Repa arrays using in-place FFI calls

Regional memory pointers

Type composition classes & instances

Combinators for unorthodox structure composition

Type-safe file handling

A modified Merkle Patricia DB

A Ethereum contract analyzer.

An efficient implementation of maps from strings to arbitrary values

Ethereum Recursive Length Prefix Encoding

Heaps in Haskell

Open type representations and dynamic types

Styled console text output using ANSI escape sequences.

A library for permutations and combinations.

Type-safe communication with USB devices.

Generic finger-tree structure, with example instances

Efficient representable functors

A backend agnostic, concurrent BTree

Combinators for unorthodox function composition

Queues with verified and unverified versions.

Prototypical type checker for Type Theory with Sized Natural Numbers

Boxed and unboxed arrays for monad transformers

Optimised list functions for doing index-related things

Types representing line and column positions and ranges in text files.

Maps and sets of partial orders

BK-tree implementation

Monoids with holes.

type-level binary search trees in haskell

Render just the Agda snippets of a literate Agda file to HTML

Memoization combinators using arrays for finite sub-domains of functions

"Ties the knot" on a given set of structures that reference each other by keys.

Simple and moderately efficient suffix array implementation

bidirectional arrows, bijective functions, and invariant functors

Perform fft with repa via FFTW

Reading and writing sound files with repa arrays

Subword graph implementation

Permissions for bookkeeper records

Extends safer-file-handles with ByteString operations

Extends safer-file-handles with Text operations

The basic stack type

Friendly helpers for your recursion schemes.

Perfect minimal hashing implementation in native Haskell

Efficient alternating finger trees

Conceptual modelling support for Haskell

A simple multi-way tree data structure.

A few more collections

Packed, strict nibble arrays with a list interface (ByteString for nibbles)

Helps when going "seed values" -> alternatives and optional -> answers