Haskell Data Structures

A dependently typed functional programming language and proof assistant

A tasty Haskell front-end framework

Assorted concrete container types

Extensible Records

Implementation of Univalence in Cubical Sets

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

A framework for generating singleton types

Bulk array representations and operators.

Scalar data types and conversions.

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

Packing and unpacking flat tables.

A Haskell version of an Ethereum client

A language based on homotopy type theory with an interval type

Pure priority search queues

Anonymous records and overloaded labels

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

Distributive functors -- Dual to Traversable

Compiles Clafer models to other formats

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

A Haskell 98 logically uninhabited data type

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

A purely functional and persistent hash map

A space-efficient set data structure.

Keyed container types with verified keys.

Asymptotically optimal Brodal/Okasaki heaps.

Anonymous extensible records

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

Efficient relational queries on Haskell sets.

The Data.MultiSet container type

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

Very strict CPS'd transformers

Generic strict finger-tree structure

Extensions to Data.Map

Bindings to the igraph C library.

Syntax sugar for defining maps

Dependently typed elimination functions using singletons

Composition trees for arbitrary monoids.

Simple functional ring type.

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

Combinators for operating with selections over an underlying functor

Program to derive type class instances

Combinators for unorthodox structure composition

Typechecking terms of the Edinburgh Logical Framework (LF).

Program to derive type class instances

Ethereum Recursive Length Prefix Encoding

Plugin and base library to support supermonads in Haskell

Efficient relational queries on Haskell sets.

An efficient implementation of maps from strings to arbitrary values

A modified Merkle Patricia DB

Open type representations and dynamic types

A backend agnostic, concurrent BTree

Regional memory pointers

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

Type composition classes & instances

A Ethereum contract analyzer.

Heaps in Haskell

A library for permutations and combinations.

Type-safe file handling

Styled console text output using ANSI escape sequences.

Generic finger-tree structure, with example instances

Combinators for unorthodox function composition

Queues with verified and unverified versions.

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

BK-tree implementation

Optimised list functions for doing index-related things

Boxed and unboxed arrays for monad transformers

Prototypical type checker for Type Theory with Sized Natural Numbers

type-level binary search trees in haskell

Monoids with holes.

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

Memoization combinators using arrays for finite sub-domains of functions

Permissions for bookkeeper records

Graphs and networks library

Type-safe communication with USB devices.

Perform fft with repa via FFTW

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

bidirectional arrows, bijective functions, and invariant functors

Reading and writing sound files with repa arrays

Extends safer-file-handles with ByteString operations

Subword graph implementation

Extends safer-file-handles with Text operations

Simple and moderately efficient suffix array implementation

Efficient representable functors

The basic stack type

Perfect minimal hashing implementation in native Haskell

A simple multi-way tree data structure.

Friendly helpers for your recursion schemes.

Maps and sets of partial orders

Efficient alternating finger trees

Conceptual modelling support for Haskell

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

A few more collections

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