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.

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

Bulk array representations and operators.

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

A Haskell version of an Ethereum client

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)

Keyed container types with verified keys.

A Haskell 98 logically uninhabited data type

A purely functional and persistent hash map

The Data.MultiSet container type

A space-efficient set data structure.

Efficient relational queries on Haskell sets.

Asymptotically optimal Brodal/Okasaki heaps.

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

Anonymous extensible records

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

Graphs and networks library

Generic strict finger-tree structure

Dependently typed elimination functions using singletons

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

Extensions to Data.Map

Very strict CPS'd transformers

Bindings to the igraph C library.

Efficient relational queries on Haskell sets.

Syntax sugar for defining maps

Plugin and base library to support supermonads in Haskell

Typechecking terms of the Edinburgh Logical Framework (LF).

Regional memory pointers

Composition trees for arbitrary monoids.

Program to derive type class instances

Combinators for operating with selections over an underlying functor

Program to derive type class instances

Simple functional ring type.

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

Type-safe file handling

Combinators for unorthodox structure composition

Type composition classes & instances

A modified Merkle Patricia DB

Type-safe communication with USB devices.

A Ethereum contract analyzer.

An efficient implementation of maps from strings to arbitrary values

Combinators for unorthodox function composition

Open type representations and dynamic types

Heaps in Haskell

Ethereum Recursive Length Prefix Encoding

Styled console text output using ANSI escape sequences.

A library for permutations and combinations.

Generic finger-tree structure, with example instances

Optimised list functions for doing index-related things

Queues with verified and unverified versions.

Efficient representable functors

A backend agnostic, concurrent BTree

BK-tree implementation

Maps and sets of partial orders

Prototypical type checker for Type Theory with Sized Natural Numbers

Boxed and unboxed arrays for monad transformers

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

Monoids with holes.

Extends safer-file-handles with ByteString operations

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

Extends safer-file-handles with Text operations

type-level binary search trees in haskell

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

Reading and writing sound files with repa arrays

Perform fft with repa via FFTW

Permissions for bookkeeper records

Subword graph implementation

The basic stack type

Perfect minimal hashing implementation in native Haskell

Friendly helpers for your recursion schemes.

Efficient alternating finger trees

Conceptual modelling support for Haskell

A few more collections

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

A simple multi-way tree data structure.

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